diff --git a/Space-Invaders/Header/Bullet/BulletConfig.h b/Space-Invaders/Header/Bullet/BulletConfig.h new file mode 100644 index 000000000..41c2e7f52 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletConfig.h @@ -0,0 +1,17 @@ +#pragma once + +namespace Bullet +{ + enum class BulletType + { + LASER_BULLET, + TORPEDO, + FROST_BULLET, + }; + + enum class MovementDirection + { + UP, + DOWN, + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/BulletController.h b/Space-Invaders/Header/Bullet/BulletController.h new file mode 100644 index 000000000..5e99d99f4 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletController.h @@ -0,0 +1,33 @@ +#pragma once +#include "../../Header/Projectile/IProjectile.h" +#include "../../Header/Bullet/BulletConfig.h" + +namespace Bullet +{ + class BulletView; + class BulletModel; + enum class BulletType; + + class BulletController : public Projectile::IProjectile + { + protected: + BulletView* bullet_view; + BulletModel* bullet_model; + + void updateProjectilePosition() override; + void moveUp(); + void moveDown(); + void handleOutOfBounds(); + + public: + BulletController(BulletType type); + virtual ~BulletController() override; + + void initialize(sf::Vector2f position, Bullet::MovementDirection direction) override; + void update() override; + void render() override; + + sf::Vector2f getProjectilePosition() override; + BulletType getBulletType(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/BulletModel.h b/Space-Invaders/Header/Bullet/BulletModel.h new file mode 100644 index 000000000..b54eae035 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletModel.h @@ -0,0 +1,37 @@ +#pragma once +#include + +namespace Bullet +{ + enum class BulletType; + enum class MovementDirection; + + class BulletModel + { + private: + float movement_speed = 300.f; + sf::Vector2f bullet_position; + + BulletType bullet_type; + MovementDirection movement_direction; + + public: + + BulletModel(BulletType type); + ~BulletModel(); + + void initialize(sf::Vector2f position, MovementDirection direction); + + sf::Vector2f getBulletPosition(); + void setBulletPosition(sf::Vector2f position); + + BulletType getBulletType(); + void setBulletType(BulletType type); + + MovementDirection getMovementDirection(); + void setMovementDirection(MovementDirection direction); + + float getMovementSpeed(); + void setMovementSpeed(float speed); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/BulletService.h b/Space-Invaders/Header/Bullet/BulletService.h new file mode 100644 index 000000000..a5049b865 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletService.h @@ -0,0 +1,31 @@ +#pragma once +#include +#include "SFML/System/Vector2.hpp" +#include "../../Header/Projectile/IProjectile.h" + +namespace Bullet +{ + class BulletController; + enum class BulletType; + enum class MovementDirection; + + class BulletService + { + private: + std::vector bullet_list; + + BulletController* createBullet(BulletType bullet_type); + void destroy(); + + public: + BulletService(); + virtual ~BulletService(); + + void initialize(); + void update(); + void render(); + + BulletController* spawnBullet(BulletType bullet_type, sf::Vector2f position, MovementDirection direction); + void destroyBullet(BulletController* bullet_controller); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/BulletView.h b/Space-Invaders/Header/Bullet/BulletView.h new file mode 100644 index 000000000..216aa8c75 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletView.h @@ -0,0 +1,32 @@ +#pragma once +#include + +namespace Bullet +{ + class BulletController; + enum class BulletType; + + class BulletView + { + private: + const float bullet_sprite_width = 18.f; + const float bullet_sprite_height = 18.f; + + sf::RenderWindow* game_window; + sf::Texture bullet_texture; + sf::Sprite bullet_sprite; + + BulletController* bullet_controller; + + void initializeImage(BulletType type); + void scaleImage(); + + public: + BulletView(); + ~BulletView(); + + void initialize(BulletController* controller); + void update(); + void render(); + }; +} diff --git a/Space-Invaders/Header/Bullet/Controllers/FrostBulletController.h b/Space-Invaders/Header/Bullet/Controllers/FrostBulletController.h new file mode 100644 index 000000000..e47102bbe --- /dev/null +++ b/Space-Invaders/Header/Bullet/Controllers/FrostBulletController.h @@ -0,0 +1,20 @@ +#pragma once +#include "../../Header/Bullet/BulletController.h" + +namespace Bullet +{ + namespace Controller + { + class FrostBulletController : public BulletController + { + private: + const float torpedo_movement_speed = 200.f; + + public: + FrostBulletController(BulletType type); + ~FrostBulletController(); + + void initialize(sf::Vector2f position, MovementDirection direction) override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/Controllers/LaserBulletController.h b/Space-Invaders/Header/Bullet/Controllers/LaserBulletController.h new file mode 100644 index 000000000..5e0858f37 --- /dev/null +++ b/Space-Invaders/Header/Bullet/Controllers/LaserBulletController.h @@ -0,0 +1,17 @@ +#pragma once +#include "../../Header/Bullet/BulletController.h" + +namespace Bullet +{ + namespace Controller + { + class LaserBulletController : public BulletController + { + public: + LaserBulletController(BulletType type); + ~LaserBulletController(); + + void initialize(sf::Vector2f position, MovementDirection direction) override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/Controllers/TorpedoController.h b/Space-Invaders/Header/Bullet/Controllers/TorpedoController.h new file mode 100644 index 000000000..5cba6bc70 --- /dev/null +++ b/Space-Invaders/Header/Bullet/Controllers/TorpedoController.h @@ -0,0 +1,20 @@ +#pragma once +#include "../../Header/Bullet/BulletController.h" + +namespace Bullet +{ + namespace Controller + { + class TorpedoController : public BulletController + { + private: + const float torpedo_movement_speed = 200.f; + + public: + TorpedoController(BulletType type); + ~TorpedoController(); + + void initialize(sf::Vector2f position, MovementDirection direction) override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Collectible/ICollectible.h b/Space-Invaders/Header/Collectible/ICollectible.h new file mode 100644 index 000000000..b399b7856 --- /dev/null +++ b/Space-Invaders/Header/Collectible/ICollectible.h @@ -0,0 +1,17 @@ +#pragma once +#include + +namespace Collectible +{ + class ICollectible + { + public: + virtual void onCollected() = 0; + virtual void initialize(sf::Vector2f position) = 0; + virtual void update() = 0; + virtual void render() = 0; + virtual sf::Vector2f getCollectiblePosition() = 0; + + virtual ~ICollectible() {}; + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Element/Bunker/BunkerController.h b/Space-Invaders/Header/Element/Bunker/BunkerController.h new file mode 100644 index 000000000..f4b350752 --- /dev/null +++ b/Space-Invaders/Header/Element/Bunker/BunkerController.h @@ -0,0 +1,28 @@ +#pragma once +#include +#include "../../Header/Element/Bunker/BunkerModel.h" + +namespace Element +{ + namespace Bunker + { + class BunkerView; + + class BunkerController + { + private: + BunkerView* bunker_view; + BunkerData bunker_data; + + public: + BunkerController(); + ~BunkerController(); + + void initialize(BunkerData data); + void update(); + void render(); + + sf::Vector2f getBunkerPosition(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Element/Bunker/BunkerModel.h b/Space-Invaders/Header/Element/Bunker/BunkerModel.h new file mode 100644 index 000000000..7ee3aa729 --- /dev/null +++ b/Space-Invaders/Header/Element/Bunker/BunkerModel.h @@ -0,0 +1,15 @@ +#pragma once +#include + +namespace Element +{ + namespace Bunker + { + struct BunkerData + { + sf::Vector2f position; + BunkerData(); + BunkerData(sf::Vector2f position); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Element/Bunker/BunkerView.h b/Space-Invaders/Header/Element/Bunker/BunkerView.h new file mode 100644 index 000000000..3ae92bb0a --- /dev/null +++ b/Space-Invaders/Header/Element/Bunker/BunkerView.h @@ -0,0 +1,36 @@ +#pragma once +#include + +namespace Element +{ + namespace Bunker + { + class BunkerController; + + class BunkerView + { + private: + const float bunker_sprite_width = 80.f; + const float bunker_sprite_height = 80.f; + + BunkerController* bunker_controller; + sf::RenderWindow* game_window; + + sf::Texture bunker_texture; + sf::Sprite bunker_sprite; + + const sf::String bunker_texture_path = "assets/textures/bunker.png"; + + void scaleSprite(); + void initializeImage(); + + public: + BunkerView(); + ~BunkerView(); + + void initialize(BunkerController* controller); + void update(); + void render(); + }; + } +} diff --git a/Space-Invaders/Header/Element/ElementService.h b/Space-Invaders/Header/Element/ElementService.h new file mode 100644 index 000000000..2c82a91a3 --- /dev/null +++ b/Space-Invaders/Header/Element/ElementService.h @@ -0,0 +1,29 @@ +#pragma once +#include"../../Header/Element/Bunker/BunkerController.h" +#include"../../Header/Element/Bunker/BunkerView.h" +namespace Element +{ + class BunkerController; + + class ElementService + { + private: + + const std::vector bunker_data_list = { Bunker::BunkerData(sf::Vector2f(130.f, 800.f)), + Bunker::BunkerData(sf::Vector2f(430.0f, 800.f)), + Bunker::BunkerData(sf::Vector2f(730.0f, 800.f)), + Bunker::BunkerData(sf::Vector2f(1130.0f, 800.f)), + Bunker::BunkerData(sf::Vector2f(1430.0f, 800.f)), + Bunker::BunkerData(sf::Vector2f(1730.0f, 800.f)) }; + std::vector bunker_list; + void destroy(); + + public: + ElementService(); + ~ElementService(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/Controllers/SubZeroController.h b/Space-Invaders/Header/Enemy/Controllers/SubZeroController.h new file mode 100644 index 000000000..6ae9851df --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/SubZeroController.h @@ -0,0 +1,24 @@ +#pragma once +#include "../../header/Enemy/EnemyController.h" + +namespace Enemy +{ + namespace Controller + { + class SubzeroController : public EnemyController + { + private: + float vertical_movement_speed = 100.f; + float subzero_rate_of_fire = 150.f; + + void move() override; + void moveDown(); + public: + SubzeroController(EnemyType type); + ~SubzeroController(); + + void fireBullet(); + void initialize() override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/Controllers/UFOController.h b/Space-Invaders/Header/Enemy/Controllers/UFOController.h new file mode 100644 index 000000000..86abfdc3f --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/UFOController.h @@ -0,0 +1,27 @@ +#pragma once +#include "../../header/Enemy/EnemyController.h" +#include "../../header/Powerup/PowerupConfig.h" + +namespace Enemy +{ + namespace Controller + { + class UFOController : public EnemyController + { + private: + + void move() override; + void moveLeft(); + void moveRight(); + + void fireBullet() override; + Powerup::PowerupType getRandomPowerupType(); + + public: + UFOController(EnemyType type); + ~UFOController(); + + void initialize() override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/Controllers/ZapperController.h b/Space-Invaders/Header/Enemy/Controllers/ZapperController.h new file mode 100644 index 000000000..4b0f6cc6f --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/ZapperController.h @@ -0,0 +1,27 @@ +#pragma once +#include "../../header/Enemy/EnemyController.h" +#include"../../Header/Bullet/BulletConfig.h" + +namespace Enemy +{ + namespace Controller + { + class ZapperController : public EnemyController + { + private: + float vertical_travel_distance = 100.f; + float zapper_rate_of_fire = 150.f; + + void move() override; + void moveLeft(); + void moveRight(); + void moveDown(); + public: + ZapperController(EnemyType type); + ~ZapperController(); + + void fireBullet(); + void initialize() override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyConfig.h b/Space-Invaders/Header/Enemy/EnemyConfig.h new file mode 100644 index 000000000..ae5e1429b --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyConfig.h @@ -0,0 +1,23 @@ +#pragma once +namespace Enemy +{ + enum class EnemyType + { + ZAPPER, + SUBZERO, + UFO, + //THUNDER_SNAKE, + }; + enum class EnemyState + { + PATROLLING, + ATTACK, + DEAD, + }; + enum class MovementDirection + { + LEFT, + RIGHT, + DOWN, + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyController.h b/Space-Invaders/Header/Enemy/EnemyController.h new file mode 100644 index 000000000..d0b538c09 --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyController.h @@ -0,0 +1,45 @@ +#pragma once +#include + +namespace Enemy +{ + class EnemyView; + class EnemyModel; + enum class EnemyType; + enum class EnemyState; + + class EnemyController + { + protected: + + float vertical_movement_speed = 30.f; + float horizontal_movement_speed = 200.0f; + + float rate_of_fire = 3.f; + float elapsed_fire_duration = 0.f; + + void updateFireTimer(); + void processBulletFire(); + virtual void fireBullet() = 0; + + sf::Vector2f getRandomInitialPosition(); + void handleOutOfBounds(); + + void virtual move() = 0; + + public: + EnemyController(EnemyType type); + virtual ~EnemyController(); + + void virtual initialize(); + void update(); + void render(); + + EnemyView* enemy_view; + EnemyModel* enemy_model; + + sf::Vector2f getEnemyPosition(); + EnemyType getEnemyType(); + EnemyState getEnemyState(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyModel.h b/Space-Invaders/Header/Enemy/EnemyModel.h new file mode 100644 index 000000000..9245cd4f4 --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyModel.h @@ -0,0 +1,53 @@ +#pragma once +#include +using namespace sf; + +namespace Enemy +{ + enum class EnemyType; + enum class EnemyState; + enum class MovementDirection; + + class EnemyModel + { + public: + EnemyModel(EnemyType type); + ~EnemyModel(); + + const sf::Vector2f left_most_position = sf::Vector2f(50.0f, 950.0f); + const sf::Vector2f right_most_position = sf::Vector2f(1800.0f, 950.0f); + const sf::Vector2f barrel_position_offset = sf::Vector2f(20.f, 50.f); + + const float vertical_travel_distance = 100.f; + const float enemyMoveSpeed = 50.0f; + + void initialize(); + + Vector2f getEnemyPosition(); + void setEnemyPosition(Vector2f position); + + sf::Vector2f getReferencePosition(); + void setReferencePosition(sf::Vector2f position); + + MovementDirection getMovementDirection(); + void setMovementDirection(MovementDirection direction); + + EnemyType getEnemyType(); + void setEnemyType(EnemyType type); + + EnemyState getEnemyState(); + void setEnemyState(EnemyState state); + + private: + sf::Vector2f reference_position = sf::Vector2f(50.f, 50.f); + sf::Vector2f enemy_position; + + MovementDirection movement_direction; + EnemyType enemy_type; + EnemyState enemy_state; + + const Vector2f initialPostion = Vector2f(500.0f, 500.0f); + Vector2f currentPosition; + bool enemyAlive; + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyService.h b/Space-Invaders/Header/Enemy/EnemyService.h new file mode 100644 index 000000000..fe9703fc5 --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyService.h @@ -0,0 +1,34 @@ +#pragma once +#include + +namespace Enemy +{ + class EnemyController; + enum class EnemyType; + + class EnemyService + { + private: + const float spawn_intreval = 3.0f; + + std::vector enemy_list; + float spawn_time = 0.0f; + + void updateSpawnTime(); + void processEnemySpawn(); + EnemyType getRandomEnemyType(); + EnemyController* createEnemy(EnemyType type); + void destroy(); + + public: + EnemyService(); + virtual ~EnemyService(); + + void initialize(); + void update(); + void render(); + + EnemyController* spawnEnemy(); + void destroyEnemy(EnemyController* enemy_controller); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyView.h b/Space-Invaders/Header/Enemy/EnemyView.h new file mode 100644 index 000000000..c55642511 --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyView.h @@ -0,0 +1,40 @@ +#pragma once +#include +#include "../../Header/Enemy/EnemyController.h" + +namespace Enemy +{ + class EnemyController; + enum class EnemyType; + class EnemyView + { + private: + + const sf::String subzero_texture_path = "assets/textures/subzero.png"; + const sf::String zapper_texture_path = "assets/textures/zapper.png"; + const sf::String ufo_texture_path = "assets/textures/ufo.png"; + + const float Enemy_sprite_width = 60.f; + const float Enemy_sprite_height = 60.f; + + EnemyController* enemy_controller; + + sf::RenderWindow* game_window; + + sf::Texture Enemy_texture; + sf::Sprite Enemy_sprite; + + void initializeEnemySprite(EnemyType type); + void scaleEnemySprite(); + + public: + EnemyView(); + ~EnemyView(); + + void initialize(EnemyController* controller); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Event/EventService.h b/Space-Invaders/Header/Event/EventService.h new file mode 100644 index 000000000..4d1a846ab --- /dev/null +++ b/Space-Invaders/Header/Event/EventService.h @@ -0,0 +1,51 @@ +#pragma once +#include +#include +using namespace sf; + +namespace EventSpace +{ + enum class ButtonState + { + PRESSED, + HELD, + RELEASED, + }; + + class EventService + { + private: + sf::Event game_event; + RenderWindow* game_window; + + bool isGameWindowOpen(); + bool gameWindowWasClosed(); + bool hasQuitGame(); + + ButtonState left_mouse_button_state; + ButtonState right_mouse_button_state; + ButtonState left_arrow_button_state; + ButtonState right_arrow_button_state; + ButtonState A_button_state; + ButtonState D_button_state; + + void updateMouseButtonsState(ButtonState& current_button_state, sf::Mouse::Button mouse_button); + void updateKeyboardButtonsState(ButtonState& current_button_state, sf::Keyboard::Key keyboard_button); + + public: + EventService(); + ~EventService(); + + void initialize(); + void update(); + void processEvents(); + bool pressedEscapeKey(); + bool isKeyboardEvent(); + bool pressedLeftKey(); + bool pressedRightKey(); + bool pressedLeftMouseButton(); + bool pressedRightMouseButton(); + bool pressedAKey(); + bool pressedDKey(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Gameplay/GameplayController.h b/Space-Invaders/Header/Gameplay/GameplayController.h new file mode 100644 index 000000000..066bcc2e5 --- /dev/null +++ b/Space-Invaders/Header/Gameplay/GameplayController.h @@ -0,0 +1,21 @@ +#pragma once +#include + +namespace Gameplay +{ + class GameplayView; + + class GameplayController + { + private: + GameplayView* gameplay_view; + + public: + GameplayController(); + ~GameplayController(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Gameplay/GameplayService.h b/Space-Invaders/Header/Gameplay/GameplayService.h new file mode 100644 index 000000000..89537f758 --- /dev/null +++ b/Space-Invaders/Header/Gameplay/GameplayService.h @@ -0,0 +1,20 @@ +#pragma once + +namespace Gameplay +{ + class GameplayController; + + class GameplayService + { + private: + GameplayController* gameplay_controller; + + public: + GameplayService(); + ~GameplayService(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Gameplay/GameplayView.h b/Space-Invaders/Header/Gameplay/GameplayView.h new file mode 100644 index 000000000..0e9329113 --- /dev/null +++ b/Space-Invaders/Header/Gameplay/GameplayView.h @@ -0,0 +1,26 @@ +#pragma once +#include + +namespace Gameplay +{ + class GameplayView + { + private: + const sf::String background_texture_path = "assets/textures/space_invaders_bg.png"; + + sf::RenderWindow* game_window; + sf::Texture background_texture; + sf::Sprite background_sprite; + + void initializeBackgroundSprite(); + void scaleBackgroundSprite(); + + public: + GameplayView(); + ~GameplayView(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Global/Config.h b/Space-Invaders/Header/Global/Config.h new file mode 100644 index 000000000..59225e382 --- /dev/null +++ b/Space-Invaders/Header/Global/Config.h @@ -0,0 +1,39 @@ +#pragma once +#include + +namespace Global +{ + class Config + { + public: + static const sf::String outscal_logo_texture_path; + static const sf::String background_texture_path; + static const sf::String player_texture_path; + + static const sf::String zapper_texture_path; + static const sf::String thunder_snake_texture_path; + static const sf::String subzero_texture_path; + static const sf::String ufo_texture_path; + static const sf::String bunker_texture_path; + + static const sf::String shield_texture_path; + static const sf::String tripple_laser_texture_path; + static const sf::String rapid_fire_texture_path; + static const sf::String outscal_bomb_texture_path; + + static const sf::String laser_bullet_texture_path; + static const sf::String torpedoe_texture_path; + static const sf::String frost_beam_texture_path; + + static const sf::String play_button_texture_path; + static const sf::String instructions_button_texture_path; + static const sf::String quit_button_texture_path; + static const sf::String menu_button_texture_path; + + static const sf::String bubble_bobble_font_path; + static const sf::String DS_DIGIB_font_path; + + static const sf::String background_music_path; + static const sf::String button_click_sound_path; + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Global/ServiceLocator.h b/Space-Invaders/Header/Global/ServiceLocator.h new file mode 100644 index 000000000..32da13912 --- /dev/null +++ b/Space-Invaders/Header/Global/ServiceLocator.h @@ -0,0 +1,59 @@ +#pragma once +#include"../../Header/Graphic/GraphicsServices.h" +#include"../../Header/Event/EventService.h" +#include"../../Header/Player/PlayerService.h" +#include"../../Header/Time/TimeService.h" +#include"../../Header/UI/UIService.h" +#include"../../Header/Enemy/EnemyService.h" +#include"../../header/Gameplay/GameplayService.h" +#include"../../Header/Element/ElementService.h" +#include"../../Header/Sound/SoundService.h" +#include"../../Header/Bullet/BulletService.h" +#include"../../Header/Main/GameServices.h" +#include"../../Header/Powerup/PowerupService.h" + +namespace Global +{ + class ServiceLocator + { + private: + Graphic::GraphicsService* graphics_service; + EventSpace::EventService* event_service; + Player::PlayerService* player_service; + TimeSpace::TimeService* time_service; + UI::UIService* ui_service; + Enemy::EnemyService* enemy_service; + Gameplay::GameplayService* gameplay_service; + Element::ElementService* element_service; + SoundSpace::SoundService* sound_service; + Bullet::BulletService* bullet_service; + Powerup::PowerupService* powerup_service; + + ServiceLocator(); + + ~ServiceLocator(); + + void deleteServiceLocator(); + void createServices(); + void clearAllServices(); + + public: + static ServiceLocator* getInstance(); + + void initialize(); + void update(); + void render(); + + Graphic::GraphicsService* getGraphicsService(); + EventSpace::EventService* getEventService(); + Player::PlayerService* getPlayerService(); + TimeSpace::TimeService* getTimeService(); + UI::UIService* getUIService(); + Enemy::EnemyService* getEnemyService(); + Gameplay::GameplayService* getGameplayService(); + Element::ElementService* getElementService(); + SoundSpace::SoundService* getSoundService(); + Bullet::BulletService* getBulletService(); + Powerup::PowerupService* getPowerupService(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Graphic/GraphicsServices.h b/Space-Invaders/Header/Graphic/GraphicsServices.h new file mode 100644 index 000000000..2d1279de3 --- /dev/null +++ b/Space-Invaders/Header/Graphic/GraphicsServices.h @@ -0,0 +1,36 @@ +#pragma once +#include +#include +using namespace std; +using namespace sf; + +namespace Graphic +{ + class GraphicsService + { + private: + const string gameWindowTitle = "Space Defenders"; + const int windowHight = 1920, windowWidth = 1080; + const Color windowColor = Color::Blue; + + VideoMode* video_mode; + RenderWindow* gameWindow; + + void setVideoMode(); + void onDestroy(); + + public: + GraphicsService(); + ~GraphicsService(); + + RenderWindow* createGameWindow(); + + void initialize(); + void update(); + void render(); + bool isGameWindowOpen(); + + RenderWindow* getGameWindow(); + Color getWindowColor(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Main/GameServices.h b/Space-Invaders/Header/Main/GameServices.h new file mode 100644 index 000000000..4eaae3299 --- /dev/null +++ b/Space-Invaders/Header/Main/GameServices.h @@ -0,0 +1,40 @@ +#pragma once +#include "../../Header/Global/ServiceLocator.h" + +namespace Global { + class ServiceLocator; +} +namespace Main +{ + enum class GameState + { + BOOT, + MAIN_MENU, + GAMEPLAY, + }; + class GameService + { + private: + void showMainMenu(); + static GameState current_state; + + Global::ServiceLocator* service_locator; + sf::RenderWindow* game_window; + + void initialize(); + void initializeVariables(); + void destroy(); + + public: + GameService(); + ~GameService(); + + void start(); + void update(); + void render(); + bool isRunning(); + + static void setGameState(GameState new_state); + static GameState getGameState(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Player/PlayerController.h b/Space-Invaders/Header/Player/PlayerController.h new file mode 100644 index 000000000..df1df5739 --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerController.h @@ -0,0 +1,31 @@ +#pragma once +#include + +namespace Player +{ + enum class PlayerState; + class PlayerView; + class PlayerModel; + + class PlayerController + { + private: + PlayerView* player_view; + PlayerModel* player_model; + + void processPlayerInput(); + void moveLeft(); + void moveRight(); + + public: + PlayerController(); + ~PlayerController(); + + void initialize(); + void update(); + void render(); + + sf::Vector2f getPlayerPosition(); + void fireBullet(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Player/PlayerModel.h b/Space-Invaders/Header/Player/PlayerModel.h new file mode 100644 index 000000000..4c80dc46e --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerModel.h @@ -0,0 +1,52 @@ +#pragma once +#include +using namespace sf; + +namespace Player +{ + enum class PlayerState + { + ALIVE, + DEAD, + }; + + class PlayerModel + { + public: + PlayerModel(); + ~PlayerModel(); + + const sf::Vector2f left_most_position = sf::Vector2f(50.0f, 950.0f); + const sf::Vector2f right_most_position = sf::Vector2f(1800.0f, 950.0f); + + Vector2f barrel_position_offset = Vector2f(0.f, 20.f); + + const float playerMoveSpeed = 550.0f; + + void initialize(); + + void reset(); + + Vector2f getPlayerPosition(); + + void setPlayerPosition(Vector2f position); + + int playerScore; + + bool isPlayerAlive(); + void setPlayerAlive(bool alive); + + int getPlayerScore(); + void setPlayerScore(int score); + + + PlayerState getPlayerState(); + void setPlayerState(PlayerState state); + + private: + const Vector2f initialPostion = Vector2f(915.0f, 950.0f); + Vector2f currentPosition; + bool playerAlive; + PlayerState player_state; + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Player/PlayerService.h b/Space-Invaders/Header/Player/PlayerService.h new file mode 100644 index 000000000..4691d2b8a --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerService.h @@ -0,0 +1,19 @@ +#pragma once + +namespace Player +{ + class PlayerController; + class PlayerService + { + private: + PlayerController* player_controller; + + public: + PlayerService(); + ~PlayerService(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Player/PlayerView.h b/Space-Invaders/Header/Player/PlayerView.h new file mode 100644 index 000000000..627d8ac0a --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerView.h @@ -0,0 +1,35 @@ +#pragma once +#include +#include "../../Header/Player/PlayerController.h" + +namespace Player +{ + class PlayerView + { + private: + + const sf::String player_texture_path = "assets/textures/player_ship.png"; + const float player_sprite_width = 100.f; + const float player_sprite_height = 100.f; + + sf::RenderWindow* game_window; + + sf::Texture player_texture; + sf::Sprite player_sprite; + + void initializePlayerSprite(); + void scalePlayerSprite(); + + PlayerController* player_controller; + + public: + PlayerView(); + ~PlayerView(); + + void initialize(PlayerController* controller); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Powerup/Controllers/OutscalBombController.h b/Space-Invaders/Header/Powerup/Controllers/OutscalBombController.h new file mode 100644 index 000000000..6f70f09be --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/OutscalBombController.h @@ -0,0 +1 @@ +#pragma once diff --git a/Space-Invaders/Header/Powerup/Controllers/RapidFireController.h b/Space-Invaders/Header/Powerup/Controllers/RapidFireController.h new file mode 100644 index 000000000..6f70f09be --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/RapidFireController.h @@ -0,0 +1 @@ +#pragma once diff --git a/Space-Invaders/Header/Powerup/Controllers/ShieldController.h b/Space-Invaders/Header/Powerup/Controllers/ShieldController.h new file mode 100644 index 000000000..6f70f09be --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/ShieldController.h @@ -0,0 +1 @@ +#pragma once diff --git a/Space-Invaders/Header/Powerup/Controllers/TrippleLaserController.h b/Space-Invaders/Header/Powerup/Controllers/TrippleLaserController.h new file mode 100644 index 000000000..6f70f09be --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/TrippleLaserController.h @@ -0,0 +1 @@ +#pragma once diff --git a/Space-Invaders/Header/Powerup/PowerupConfig.h b/Space-Invaders/Header/Powerup/PowerupConfig.h new file mode 100644 index 000000000..88d8c4639 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupConfig.h @@ -0,0 +1,12 @@ +#pragma once + +namespace Powerup +{ + enum class PowerupType + { + SHIELD, + RAPID_FIRE, + TRIPPLE_LASER, + OUTSCAL_BOMB, + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Powerup/PowerupController.h b/Space-Invaders/Header/Powerup/PowerupController.h new file mode 100644 index 000000000..411aea85d --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupController.h @@ -0,0 +1,33 @@ +#pragma once +#include "../../header/Collectible/ICollectible.h" + +namespace Powerup +{ + class PowerupView; + class PowerupModel; + + enum class PowerupType; + + class PowerupController : public Collectible::ICollectible + { + protected: + PowerupView* powerup_view; + PowerupModel* powerup_model; + + void updatePowerupPosition(); + void handleOutOfBounds(); + + public: + PowerupController(PowerupType type); + virtual ~PowerupController(); + + void initialize(sf::Vector2f position) override; + void update() override; + void render() override; + + void onCollected() override; + + sf::Vector2f getCollectiblePosition() override; + PowerupType getPowerupType(); + }; +} diff --git a/Space-Invaders/Header/Powerup/PowerupModel.h b/Space-Invaders/Header/Powerup/PowerupModel.h new file mode 100644 index 000000000..e80c15e07 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupModel.h @@ -0,0 +1,31 @@ +#pragma once +#include + +namespace Powerup +{ + enum class PowerupType; + + class PowerupModel + { + private: + float movement_speed = 300.f; + + sf::Vector2f powerup_position; + PowerupType powerup_type; + + public: + PowerupModel(PowerupType type); + ~PowerupModel(); + + void initialize(sf::Vector2f position); + + sf::Vector2f getPowerupPosition(); + void setPowerupPosition(sf::Vector2f position); + + PowerupType getPowerupType(); + void setPowerupType(PowerupType type); + + float getMovementSpeed(); + void setMovementSpeed(float speed); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Powerup/PowerupService.h b/Space-Invaders/Header/Powerup/PowerupService.h new file mode 100644 index 000000000..2d3020d51 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupService.h @@ -0,0 +1,32 @@ +#pragma once +#include +#include "SFML/System/Vector2.hpp" +#include "../../Header/Collectible/ICollectible.h" + +namespace Powerup +{ + + class PowerupController; + enum class PowerupType; + + class PowerupService + { + private: + std::vector powerup_list; + + PowerupController* createPowerup(PowerupType powerup_type); + void destroy(); + + public: + PowerupService(); + virtual ~PowerupService(); + + void initialize(); + void update(); + void render(); + + + PowerupController* spawnPowerup(PowerupType powerup_type, sf::Vector2f position); + void destroyPowerup(PowerupController* powerup_controller); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Powerup/PowerupView.h b/Space-Invaders/Header/Powerup/PowerupView.h new file mode 100644 index 000000000..47bf0fef5 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupView.h @@ -0,0 +1,36 @@ +#pragma once +#include +#include "../../header/UI/UIElement/ImageView.h" + +namespace Powerup +{ + class PowerupController; + + enum class PowerupType; + + class PowerupView + { + private: + const float powerup_sprite_width = 30.f; + const float powerup_sprite_height = 30.f; + + sf::RenderWindow* game_window; + + PowerupController* powerup_controller; + UI::UIElement::ImageView* powerup_image; + + void createUIElements(); + void initializeImage(); + sf::String getPowerupTexturePath(); + + void destroy(); + + public: + PowerupView(); + ~PowerupView(); + + void initialize(PowerupController* controller); + void update(); + void render(); + }; +} diff --git a/Space-Invaders/Header/Projectile/IProjectile.h b/Space-Invaders/Header/Projectile/IProjectile.h new file mode 100644 index 000000000..dad92626b --- /dev/null +++ b/Space-Invaders/Header/Projectile/IProjectile.h @@ -0,0 +1,21 @@ +#pragma once +#include +#include "../../Header/Bullet/BulletConfig.h" + +namespace Projectile +{ + enum class MovementDirection; + + class IProjectile + { + public: + virtual void initialize(sf::Vector2f position, Bullet::MovementDirection direction) = 0; + virtual void update() = 0; + virtual void render() = 0; + + virtual void updateProjectilePosition() = 0; + virtual sf::Vector2f getProjectilePosition() = 0; + + virtual ~IProjectile() {}; + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Sound/SoundService.h b/Space-Invaders/Header/Sound/SoundService.h new file mode 100644 index 000000000..cae1b7bad --- /dev/null +++ b/Space-Invaders/Header/Sound/SoundService.h @@ -0,0 +1,29 @@ +#pragma once +#include "SFML/Audio.hpp" + +namespace SoundSpace +{ + enum class SoundType + { + BUTTON_CLICK, + }; + + class SoundService + { + private: + const int background_music_volume = 30; + + sf::Music background_music; + sf::Sound sound_effect; + sf::SoundBuffer buffer_button_click; + + void loadBackgroundMusicFromFile(); + void loadSoundFromFile(); + + public: + void initialize(); + + void playSound(SoundType soundType); + void playBackgroundMusic(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Time/TimeService.h b/Space-Invaders/Header/Time/TimeService.h new file mode 100644 index 000000000..e562923ef --- /dev/null +++ b/Space-Invaders/Header/Time/TimeService.h @@ -0,0 +1,25 @@ +#pragma once +#include + +namespace TimeSpace +{ + class TimeService + { + /*TimeService(); + ~TimeService();*/ + + private: + std::chrono::time_point previous_time; + float delta_time; + + void updateDeltaTime(); + float calculateDeltaTime(); + void updatePreviousTime(); + + public: + void initialize(); + void update(); + + float getDeltaTime(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/Interface/IUIController.h b/Space-Invaders/Header/UI/Interface/IUIController.h new file mode 100644 index 000000000..7244fe98f --- /dev/null +++ b/Space-Invaders/Header/UI/Interface/IUIController.h @@ -0,0 +1,18 @@ +#pragma once + +namespace UI +{ + namespace Interface + { + class IUIController + { + public: + virtual void initialize() = 0; + virtual void update() = 0; + virtual void render() = 0; + virtual void show() = 0; + + virtual ~IUIController() { } + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/MainMenu/MainMenuUIContoller.h b/Space-Invaders/Header/UI/MainMenu/MainMenuUIContoller.h new file mode 100644 index 000000000..13828a6b1 --- /dev/null +++ b/Space-Invaders/Header/UI/MainMenu/MainMenuUIContoller.h @@ -0,0 +1,50 @@ +#pragma once +#include +#include "../../header/UI/Interface/IUIController.h" +#include "../../header/UI/UIElement/ImageView.h" +#include "../../header/UI/UIElement/ButtonView.h" + +namespace UI +{ + namespace MainMenu + { + class MainMenuUIController : public Interface::IUIController + { + private: + + const float button_width = 400.f; + const float button_height = 140.f; + + const float play_button_y_position = 500.f; + const float instructions_button_y_position = 700.f; + const float quit_button_y_position = 900.f; + + const float background_alpha = 85.f; + + UIElement::ImageView* background_image; + + UIElement::ButtonView* play_button; + UIElement::ButtonView* instructions_button; + UIElement::ButtonView* quit_button; + + void createImage(); + void createButtons(); + void initializeBackgroundImage(); + void initializeButtons(); + void registerButtonCallback(); + + void playButtonCallback(); + void instructionsButtonCallback(); + void quitButtonCallback(); + + public: + MainMenuUIController(); + ~MainMenuUIController(); + + void initialize() override; + void update() override; + void render() override; + void show() override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/ButtonView.h b/Space-Invaders/Header/UI/UIElement/ButtonView.h new file mode 100644 index 000000000..939e5f2be --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/ButtonView.h @@ -0,0 +1,36 @@ +#pragma once +#include "../../header/UI/UIElement/ImageView.h" +#include +#include +#include + +namespace UI +{ + namespace UIElement + { + class ButtonView : public ImageView + { + private: + using CallbackFunction = std::function; + + CallbackFunction callback_function = nullptr; + + void printButtonClicked(); + + protected: + sf::String button_title; + + virtual void handleButtonInteraction(); + virtual bool clickedButton(sf::Sprite* button_sprite, sf::Vector2f mouse_position); + + public: + ButtonView(); + virtual ~ButtonView(); + + virtual void initialize(sf::String title, sf::String texture_path, float button_width, float button_height, sf::Vector2f position); + virtual void update() override; + virtual void render() override; + + void registerCallbackFuntion(CallbackFunction button_callback); + }; + } \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/ImageView.h b/Space-Invaders/Header/UI/UIElement/ImageView.h new file mode 100644 index 000000000..aab427837 --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/ImageView.h @@ -0,0 +1,31 @@ +#pragma once +#include "../../header/UI/UIElement/UIView.h" + +namespace UI +{ + namespace UIElement + { + class ImageView : public UIView + { + protected: + sf::Texture image_texture; + sf::Sprite image_sprite; + + public: + ImageView(); + virtual ~ImageView(); + + virtual void initialize(sf::String texture_path, float image_width, float image_height, sf::Vector2f position); + virtual void update() override; + virtual void render() override; + + virtual void setTexture(sf::String texture_path); + virtual void setScale(float width, float height); + virtual void setPosition(sf::Vector2f position); + virtual void setRotation(float rotation_angle); + virtual void setOriginAtCentre(); + virtual void setImageAlpha(float alpha); + virtual void setCentreAlinged(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/TextView.h b/Space-Invaders/Header/UI/UIElement/TextView.h new file mode 100644 index 000000000..8a83a8e9e --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/TextView.h @@ -0,0 +1,45 @@ +#pragma once +#include "../../header/UI/UIElement/UIView.h" + +namespace UI +{ + namespace UIElement + { + enum class FontType + { + BUBBLE_BOBBLE, + DS_DIGIB, + }; + + class TextView : public UIView + { + private: + static const int default_font_size = 55; + + static sf::Font font_bubble_bobble; + static sf::Font font_DS_DIGIB; + + sf::Text text; + + static void loadFont(); + + void setFont(FontType font_type); + void setFontSize(int font_size); + void setTextPosition(sf::Vector2f position); + void setTextColor(sf::Color color); + + public: + TextView(); + virtual ~TextView(); + + static void initializeTextView(); + + virtual void initialize(sf::String text_value, sf::Vector2f position, FontType font_type = FontType::BUBBLE_BOBBLE, int font_size = default_font_size, sf::Color color = sf::Color::White); + virtual void update() override; + virtual void render() override; + + void setText(sf::String text_value); + void setTextCentreAligned(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/UIView.h b/Space-Invaders/Header/UI/UIElement/UIView.h new file mode 100644 index 000000000..8f92966e7 --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/UIView.h @@ -0,0 +1,32 @@ +#pragma once +#include + +namespace UI +{ + namespace UIElement + { + enum class UIState + { + VISIBLE, + HIDDEN, + }; + + class UIView + { + protected: + sf::RenderWindow* game_window; + UIState ui_state; + + public: + UIView(); + virtual ~UIView(); + + virtual void initialize(); + virtual void update(); + virtual void render(); + + virtual void show(); + virtual void hide(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIService.h b/Space-Invaders/Header/UI/UIService.h new file mode 100644 index 000000000..693151f26 --- /dev/null +++ b/Space-Invaders/Header/UI/UIService.h @@ -0,0 +1,30 @@ +#pragma once +#include "../../Header/UI/MainMenu/MainMenuUIContoller.h" +#include"../../Header/UI/Interface/IUIController.h" + +namespace UI +{ + using namespace MainMenu; + using namespace Interface; + class UIService + { + private: + MainMenuUIController* main_menu_controller; + + + void createControllers(); + void initializeControllers(); + void destroy(); + + public: + UIService(); + ~UIService(); + + void initialize(); + void update(); + void render(); + void showScreen(); + /*void show();*/ + IUIController* getCurrentUIController(); + }; +} diff --git a/Space-Invaders/Source/Bullet/BulletController.cpp b/Space-Invaders/Source/Bullet/BulletController.cpp new file mode 100644 index 000000000..f95ae6ec3 --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletController.cpp @@ -0,0 +1,92 @@ +#include "../../Header/Bullet/BulletController.h" +#include "../../Header/Bullet/BulletView.h" +#include "../../Header/Bullet/BulletModel.h" +#include "../../Header/Bullet/BulletConfig.h" +#include "../../Header/Global/ServiceLocator.h" + +namespace Bullet +{ + using namespace Global; + BulletController::BulletController(BulletType type) + { + bullet_view = new BulletView(); + bullet_model = new BulletModel(type); + } + + BulletController::~BulletController() + { + delete (bullet_view); + delete (bullet_model); + } + + void BulletController::initialize(sf::Vector2f position, MovementDirection direction) + { + bullet_view->initialize(this); + bullet_model->initialize(position, direction); + } + + void BulletController::update() + { + updateProjectilePosition(); + bullet_view->update(); + handleOutOfBounds(); + } + + void BulletController::render() + { + bullet_view->render(); + } + + void BulletController::updateProjectilePosition() + { + switch (bullet_model->getMovementDirection()) + { + case::Bullet::MovementDirection::UP: + moveUp(); + break; + + case::Bullet::MovementDirection::DOWN: + moveDown(); + break; + } + } + + void BulletController::moveUp() + { + sf::Vector2f currentPosition = bullet_model->getBulletPosition(); + currentPosition.y -= bullet_model->getMovementSpeed() * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + bullet_model->setBulletPosition(currentPosition); + } + + void BulletController::moveDown() + { + sf::Vector2f currentPosition = bullet_model->getBulletPosition(); + + currentPosition.y += bullet_model->getMovementSpeed() * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + bullet_model->setBulletPosition(currentPosition); + } + + void BulletController::handleOutOfBounds() + { + sf::Vector2f bulletPosition = getProjectilePosition(); + sf::Vector2u windowSize = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow()->getSize(); + + if (bulletPosition.x < 0 || bulletPosition.x > windowSize.x || + bulletPosition.y < 0 || bulletPosition.y > windowSize.y) + { + ServiceLocator::getInstance()->getBulletService()->destroyBullet(this); + } + } + + sf::Vector2f BulletController::getProjectilePosition() + { + return bullet_model->getBulletPosition(); + } + + BulletType BulletController::getBulletType() + { + return bullet_model->getBulletType(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletModel.cpp b/Space-Invaders/Source/Bullet/BulletModel.cpp new file mode 100644 index 000000000..d036b115a --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletModel.cpp @@ -0,0 +1,57 @@ +#include "../../Header/Bullet/BulletModel.h" + +namespace Bullet +{ + BulletModel::BulletModel(BulletType type) + { + bullet_type = type; + } + + BulletModel::~BulletModel() { } + + void BulletModel::initialize(sf::Vector2f position, MovementDirection direction) + { + movement_direction = direction; + bullet_position = position; + } + + sf::Vector2f BulletModel::getBulletPosition() + { + return bullet_position; + } + + void BulletModel::setBulletPosition(sf::Vector2f position) + { + bullet_position = position; + } + + BulletType BulletModel::getBulletType() + { + return bullet_type; + } + + void BulletModel::setBulletType(BulletType type) + { + bullet_type = type; + } + + MovementDirection BulletModel::getMovementDirection() + { + return movement_direction; + } + + void BulletModel::setMovementDirection(MovementDirection direction) + { + movement_direction = direction; + } + + float BulletModel::getMovementSpeed() + { + return movement_speed; + } + + void BulletModel::setMovementSpeed(float speed) + { + movement_speed = speed; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletService.cpp b/Space-Invaders/Source/Bullet/BulletService.cpp new file mode 100644 index 000000000..401906ed2 --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletService.cpp @@ -0,0 +1,63 @@ +#include "../../Header/Bullet/BulletService.h" +#include "../../Header/Bullet/BulletController.h" +#include "../../Header/Bullet/BulletConfig.h" +#include "../../Header/Bullet/Controllers/FrostBulletController.h" +#include "../../Header/Bullet/Controllers/LaserBulletController.h" +#include "../../Header/Bullet/Controllers/TorpedoController.h" + +namespace Bullet +{ + using namespace Controller; + using namespace Projectile; + + BulletService::BulletService() { } + + BulletService::~BulletService() { destroy(); } + + void BulletService::initialize() { } + + void BulletService::update() + { + for (int i = 0; i < bullet_list.size(); i++) bullet_list[i]->update(); + } + + void BulletService::render() + { + for (int i = 0; i < bullet_list.size(); i++) bullet_list[i]->render(); + } + + BulletController* BulletService::createBullet(BulletType bullet_type) + { + switch (bullet_type) + { + case::Bullet::BulletType::LASER_BULLET: + return new LaserBulletController(Bullet::BulletType::LASER_BULLET); + + case::Bullet::BulletType::FROST_BULLET: + return new FrostBulletController(Bullet::BulletType::FROST_BULLET); + + case::Bullet::BulletType::TORPEDO: + return new TorpedoController(Bullet::BulletType::TORPEDO); + } + } + + void BulletService::destroy() + { + for (int i = 0; i < bullet_list.size(); i++) delete (bullet_list[i]); + } + + BulletController* BulletService::spawnBullet(BulletType bullet_type, sf::Vector2f position, MovementDirection direction) + { + BulletController* bullet_controller = createBullet(bullet_type); + + bullet_controller->initialize(position, direction); + bullet_list.push_back(bullet_controller); + return bullet_controller; + } + + void BulletService::destroyBullet(BulletController* bullet_controller) + { + bullet_list.erase(std::remove(bullet_list.begin(), bullet_list.end(), bullet_controller), bullet_list.end()); + delete(bullet_controller); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletView.cpp b/Space-Invaders/Source/Bullet/BulletView.cpp new file mode 100644 index 000000000..7958fb28b --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletView.cpp @@ -0,0 +1,68 @@ +#include "../../Header/Bullet/BulletView.h" +#include "../../Header/Bullet/BulletController.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Global/Config.h" +#include "../../Header/Bullet/BulletConfig.h" + +namespace Bullet +{ + using namespace Global; + + BulletView::BulletView() { } + + BulletView::~BulletView() { } + + void BulletView::initialize(BulletController* controller) + { + bullet_controller = controller; + game_window = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow(); + initializeImage(bullet_controller->getBulletType()); + } + + void BulletView::initializeImage(BulletType type) + { + switch (type) + { + case::Bullet::BulletType::LASER_BULLET: + if (bullet_texture.loadFromFile(Config::laser_bullet_texture_path)) + { + bullet_sprite.setTexture(bullet_texture); + scaleImage(); + } + break; + case::Bullet::BulletType::FROST_BULLET: + if (bullet_texture.loadFromFile(Config::frost_beam_texture_path)) + { + bullet_sprite.setTexture(bullet_texture); + scaleImage(); + } + break; + case::Bullet::BulletType::TORPEDO: + if (bullet_texture.loadFromFile(Config::torpedoe_texture_path)) + { + bullet_sprite.setTexture(bullet_texture); + scaleImage(); + } + break; + } + } + + void BulletView::scaleImage() + { + bullet_sprite.setScale( + static_cast(bullet_sprite_width) / bullet_sprite.getTexture()->getSize().x, + static_cast(bullet_sprite_height) / bullet_sprite.getTexture()->getSize().y + ); + } + + void BulletView::update() + { + bullet_sprite.setPosition(bullet_controller->getProjectilePosition()); + } + + void BulletView::render() + { + game_window->draw(bullet_sprite); + } + +} diff --git a/Space-Invaders/Source/Bullet/Controllers/FrostBulletController.cpp b/Space-Invaders/Source/Bullet/Controllers/FrostBulletController.cpp new file mode 100644 index 000000000..ee4000353 --- /dev/null +++ b/Space-Invaders/Source/Bullet/Controllers/FrostBulletController.cpp @@ -0,0 +1,18 @@ +#include "../../Header/Bullet/Controllers/FrostBulletController.h" +#include "../../Header/Bullet/BulletModel.h" + +namespace Bullet +{ + namespace Controller + { + FrostBulletController::FrostBulletController(BulletType type) : BulletController(type) { } + + FrostBulletController::~FrostBulletController() { } + + void FrostBulletController::initialize(sf::Vector2f position, MovementDirection direction) + { + BulletController::initialize(position, direction); + bullet_model->setMovementSpeed(torpedo_movement_speed); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/Controllers/LaserBulletController.cpp b/Space-Invaders/Source/Bullet/Controllers/LaserBulletController.cpp new file mode 100644 index 000000000..fcb34d90c --- /dev/null +++ b/Space-Invaders/Source/Bullet/Controllers/LaserBulletController.cpp @@ -0,0 +1,17 @@ +#include "../../Header/Bullet/Controllers/LaserBulletController.h" +#include "../../Header/Bullet/BulletModel.h" + +namespace Bullet +{ + namespace Controller + { + LaserBulletController::LaserBulletController(BulletType type) : BulletController(type) { } + + LaserBulletController::~LaserBulletController() { } + + void LaserBulletController::initialize(sf::Vector2f position, MovementDirection direction) + { + BulletController::initialize(position, direction); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/Controllers/TorpedoController.cpp b/Space-Invaders/Source/Bullet/Controllers/TorpedoController.cpp new file mode 100644 index 000000000..89f0acdf7 --- /dev/null +++ b/Space-Invaders/Source/Bullet/Controllers/TorpedoController.cpp @@ -0,0 +1,18 @@ +#include "../../Header/Bullet/Controllers/TorpedoController.h" +#include "../../Header/Bullet/BulletModel.h" + +namespace Bullet +{ + namespace Controller + { + TorpedoController::TorpedoController(BulletType type) : BulletController(type) { } + + TorpedoController::~TorpedoController() { } + + void TorpedoController::initialize(sf::Vector2f position, MovementDirection direction) + { + BulletController::initialize(position, direction); + bullet_model->setMovementSpeed(torpedo_movement_speed); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Element/Bunker/BunkerController.cpp b/Space-Invaders/Source/Element/Bunker/BunkerController.cpp new file mode 100644 index 000000000..b8e8954b2 --- /dev/null +++ b/Space-Invaders/Source/Element/Bunker/BunkerController.cpp @@ -0,0 +1,24 @@ +#include "../../Header/Element/Bunker/BunkerController.h" +#include "../../Header/Element/Bunker/BunkerView.h" + +namespace Element +{ + namespace Bunker + { + BunkerController::BunkerController() { bunker_view = new BunkerView(); } + + BunkerController::~BunkerController() { delete(bunker_view); } + + void BunkerController::initialize(BunkerData data) + { + bunker_data = data; + bunker_view->initialize(this); + } + + void BunkerController::update() { bunker_view->update(); } + + void BunkerController::render() { bunker_view->render(); } + + sf::Vector2f BunkerController::getBunkerPosition() { return bunker_data.position; } + } +} diff --git a/Space-Invaders/Source/Element/Bunker/BunkerModel.cpp b/Space-Invaders/Source/Element/Bunker/BunkerModel.cpp new file mode 100644 index 000000000..80a9226a8 --- /dev/null +++ b/Space-Invaders/Source/Element/Bunker/BunkerModel.cpp @@ -0,0 +1,14 @@ +#include "../../Header/Element/Bunker/BunkerModel.h" + +namespace Element +{ + namespace Bunker + { + BunkerData::BunkerData() { }; + + BunkerData::BunkerData(sf::Vector2f position) + { + this->position = position; + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Element/Bunker/BunkerView.cpp b/Space-Invaders/Source/Element/Bunker/BunkerView.cpp new file mode 100644 index 000000000..3c0dac34f --- /dev/null +++ b/Space-Invaders/Source/Element/Bunker/BunkerView.cpp @@ -0,0 +1,52 @@ +#include "../../Header/Element/Bunker/BunkerView.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Element/Bunker/BunkerController.h" + +namespace Element +{ + namespace Bunker + { + using namespace Global; + + BunkerView::BunkerView() { } + + BunkerView::~BunkerView() { } + + void BunkerView::initialize(BunkerController* controller) + { + bunker_controller = controller; + game_window = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow(); + initializeImage(); + } + + void BunkerView::initializeImage() + { + if (bunker_texture.loadFromFile(bunker_texture_path)) + { + bunker_sprite.setTexture(bunker_texture); + scaleSprite(); + } + } + + + void BunkerView::scaleSprite() + { + bunker_sprite.setScale( + static_cast(bunker_sprite_width) / bunker_sprite.getTexture()->getSize().x, + static_cast(bunker_sprite_height) / bunker_sprite.getTexture()->getSize().y + ); + } + + + void BunkerView::update() + { + bunker_sprite.setPosition(bunker_controller->getBunkerPosition()); + } + + void BunkerView::render() + { + game_window->draw(bunker_sprite); + } + + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Element/ElementService.cpp b/Space-Invaders/Source/Element/ElementService.cpp new file mode 100644 index 000000000..b6abd5ea1 --- /dev/null +++ b/Space-Invaders/Source/Element/ElementService.cpp @@ -0,0 +1,33 @@ +#include"../../Header/Element/ElementService.h" +namespace Element +{ + ElementService::ElementService() { } + + ElementService::~ElementService() { destroy(); } + + void ElementService::initialize() + { + for (int i = 0; i < bunker_data_list.size(); i++) + { + Bunker::BunkerController* bunker_controller = new Bunker::BunkerController(); + + bunker_controller->initialize(bunker_data_list[i]); + bunker_list.push_back(bunker_controller); + } + } + + void ElementService::update() + { + for (int i = 0; i < bunker_list.size(); i++) bunker_list[i]->update(); + } + + void ElementService::render() + { + for (int i = 0; i < bunker_list.size(); i++) bunker_list[i]->render(); + } + + void ElementService::destroy() + { + for (int i = 0; i < bunker_list.size(); i++) delete(bunker_list[i]); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/Controllers/SubZeroController.cpp b/Space-Invaders/Source/Enemy/Controllers/SubZeroController.cpp new file mode 100644 index 000000000..4767904b1 --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/SubZeroController.cpp @@ -0,0 +1,50 @@ +#include "../../Header/Enemy/Controllers/SubZeroController.h" +#include "../../Header/Enemy/EnemyModel.h" +#include "../../header/Enemy/EnemyConfig.h" +#include "../../Header/Global/ServiceLocator.h" +#include + +namespace Enemy +{ + using namespace Global; + using namespace Bullet; + + namespace Controller + { + SubzeroController::SubzeroController(EnemyType type) : EnemyController(EnemyType::SUBZERO) { } + + SubzeroController::~SubzeroController() { } + + void SubzeroController::initialize() + { + EnemyController::initialize(); + enemy_model->setMovementDirection(MovementDirection::DOWN); + rate_of_fire = subzero_rate_of_fire; + } + + void SubzeroController::fireBullet() + { + ServiceLocator::getInstance()->getBulletService()->spawnBullet(BulletType::FROST_BULLET, + enemy_model->getEnemyPosition() + enemy_model->barrel_position_offset, + Bullet::MovementDirection::DOWN); + } + + void SubzeroController::move() + { + switch (enemy_model->getMovementDirection()) + { + case::Enemy::MovementDirection::DOWN: + moveDown(); + break; + } + } + + void SubzeroController::moveDown() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + currentPosition.y += vertical_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + enemy_model->setEnemyPosition(currentPosition); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/Controllers/UFOController.cpp b/Space-Invaders/Source/Enemy/Controllers/UFOController.cpp new file mode 100644 index 000000000..a39d88900 --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/UFOController.cpp @@ -0,0 +1,83 @@ +#include "../../Header/Enemy/Controllers/UFOController.h" +#include "../../Header/Enemy/EnemyModel.h" +#include "../../Header/Enemy/EnemyConfig.h" +#include "../../Header/Global/ServiceLocator.h" + +namespace Enemy +{ + using namespace Global; + using namespace Bullet; + + namespace Controller + { + UFOController::UFOController(EnemyType type) : EnemyController(EnemyType::UFO) { } + + UFOController::~UFOController() { } + + void UFOController::initialize() + { + EnemyController::initialize(); + } + + void UFOController::fireBullet() + { + + } + + Powerup::PowerupType UFOController::getRandomPowerupType() + { + std::srand(static_cast(std::time(nullptr))); + + int random_value = std::rand() % (static_cast(Powerup::PowerupType::OUTSCAL_BOMB) + 1); + return static_cast(random_value); + } + + void UFOController::move() + { + switch (enemy_model->getMovementDirection()) + { + case::Enemy::MovementDirection::LEFT: + moveLeft(); + break; + + case::Enemy::MovementDirection::RIGHT: + moveRight(); + break; + } + } + + void UFOController::moveLeft() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + currentPosition.x -= enemy_model->enemyMoveSpeed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentPosition.x <= enemy_model->left_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::DOWN); + enemy_model->setReferencePosition(currentPosition); + } + else + { + enemy_model->setEnemyPosition(currentPosition); + } + } + + void UFOController::moveRight() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + currentPosition.x += enemy_model->enemyMoveSpeed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentPosition.x >= enemy_model->right_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::DOWN); + enemy_model->setReferencePosition(currentPosition); + } + else + { + enemy_model->setEnemyPosition(currentPosition); + } + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/Controllers/ZapperController.cpp b/Space-Invaders/Source/Enemy/Controllers/ZapperController.cpp new file mode 100644 index 000000000..358f7e7c5 --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/ZapperController.cpp @@ -0,0 +1,105 @@ +#include "../../Header/Enemy/Controllers/ZapperController.h" +#include "../../Header/Enemy/EnemyModel.h" +#include "../../Header/Enemy/EnemyConfig.h" +#include "../../Header/Global/ServiceLocator.h" + +namespace Enemy +{ + using namespace Global; + using namespace Bullet; + + namespace Controller + { + ZapperController::ZapperController(EnemyType type) : EnemyController(EnemyType::ZAPPER) { } + + ZapperController::~ZapperController() { } + + void ZapperController::initialize() + { + EnemyController::initialize(); + rate_of_fire = zapper_rate_of_fire; + } + + void ZapperController::fireBullet() + { + ServiceLocator::getInstance()->getBulletService()->spawnBullet(BulletType::LASER_BULLET, + enemy_model->getEnemyPosition() + enemy_model->barrel_position_offset, + Bullet::MovementDirection::DOWN); + } + + void ZapperController::move() + { + switch (enemy_model->getMovementDirection()) + { + case::Enemy::MovementDirection::LEFT: + moveLeft(); + break; + + case::Enemy::MovementDirection::RIGHT: + moveRight(); + break; + + case::Enemy::MovementDirection::DOWN: + moveDown(); + break; + } + } + + void ZapperController::moveLeft() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + currentPosition.x -= enemy_model->enemyMoveSpeed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentPosition.x <= enemy_model->left_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::DOWN); + enemy_model->setReferencePosition(currentPosition); + } + else + { + enemy_model->setEnemyPosition(currentPosition); + } + } + + void ZapperController::moveRight() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + currentPosition.x += enemy_model->enemyMoveSpeed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentPosition.x >= enemy_model->right_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::DOWN); + enemy_model->setReferencePosition(currentPosition); + } + else + { + enemy_model->setEnemyPosition(currentPosition); + } + } + + void ZapperController::moveDown() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + currentPosition.y += enemy_model->enemyMoveSpeed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentPosition.y >= enemy_model->getReferencePosition().y + vertical_travel_distance) + { + if (enemy_model->getReferencePosition().x <= enemy_model->left_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::RIGHT); + } + else + { + enemy_model->setMovementDirection(MovementDirection::LEFT); + } + } + else + { + enemy_model->setEnemyPosition(currentPosition); + } + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyController.cpp b/Space-Invaders/Source/Enemy/EnemyController.cpp new file mode 100644 index 000000000..f1c608b56 --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyController.cpp @@ -0,0 +1,94 @@ +#include "../../Header/Enemy/EnemyController.h" +#include "../../Header/Enemy/EnemyView.h" +#include "../../Header/Enemy/EnemyModel.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Enemy/EnemyConfig.h" + +namespace Enemy +{ + using namespace Global; + + EnemyController::EnemyController(EnemyType type) + { + enemy_view = new EnemyView(); + enemy_model = new EnemyModel(type); + } + + EnemyController::~EnemyController() + { + delete (enemy_view); + delete (enemy_model); + } + + void EnemyController::initialize() + { + enemy_model->initialize(); + enemy_view->initialize(this); + } + + void EnemyController::updateFireTimer() + { + elapsed_fire_duration += ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + } + + void EnemyController::processBulletFire() + { + if (elapsed_fire_duration >= rate_of_fire) + { + fireBullet(); + elapsed_fire_duration = 0.f; + } + } + + sf::Vector2f EnemyController::getRandomInitialPosition() + { + float x_offset_distance = (std::rand() % static_cast(enemy_model->right_most_position.x - enemy_model->left_most_position.x)); + + float x_position = enemy_model->left_most_position.x + x_offset_distance; + + float y_position = enemy_model->left_most_position.y; + + return sf::Vector2f(x_position, y_position); + } + + void EnemyController::handleOutOfBounds() + { + sf::Vector2f enemyPosition = getEnemyPosition(); + sf::Vector2u windowSize = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow()->getSize(); + + if (enemyPosition.x < 0 || enemyPosition.x > windowSize.x || + enemyPosition.y < 0 || enemyPosition.y > windowSize.y) + { + ServiceLocator::getInstance()->getEnemyService()->destroyEnemy(this); + } + } + + void EnemyController::update() + { + updateFireTimer(); + processBulletFire(); + enemy_view->update(); + handleOutOfBounds(); + move(); + } + + void EnemyController::render() + { + enemy_view->render(); + } + + sf::Vector2f EnemyController::getEnemyPosition() + { + return enemy_model->getEnemyPosition(); + } + + EnemyType EnemyController::getEnemyType() + { + return enemy_model->getEnemyType(); + } + + EnemyState EnemyController::getEnemyState() + { + return enemy_model->getEnemyState(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyModel.cpp b/Space-Invaders/Source/Enemy/EnemyModel.cpp new file mode 100644 index 000000000..ce76f104e --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyModel.cpp @@ -0,0 +1,70 @@ +#include "../../Header/Enemy/EnemyModel.h" +#include"../../Header/Enemy/EnemyConfig.h" + +namespace Enemy +{ + EnemyModel::EnemyModel(EnemyType type) + { + enemy_type = type; + } + + EnemyModel::~EnemyModel() {} + + void EnemyModel::initialize() + { + enemy_state = EnemyState::PATROLLING; + movement_direction = MovementDirection::RIGHT; + enemy_position = reference_position; + } + + void EnemyModel::setMovementDirection(MovementDirection direction) + { + movement_direction = direction; + } + + sf::Vector2f EnemyModel::getEnemyPosition() + { + return enemy_position; + } + + void EnemyModel::setEnemyPosition(sf::Vector2f position) + { + enemy_position = position; + } + + sf::Vector2f EnemyModel::getReferencePosition() + { + return reference_position; + } + + void EnemyModel::setReferencePosition(sf::Vector2f position) + { + reference_position = position; + } + + EnemyState EnemyModel::getEnemyState() + { + return enemy_state; + } + + void EnemyModel::setEnemyState(EnemyState state) + { + enemy_state = state; + } + + EnemyType EnemyModel::getEnemyType() + { + return enemy_type; + } + + void EnemyModel::setEnemyType(EnemyType type) + { + enemy_type = type; + } + + + MovementDirection EnemyModel::getMovementDirection() + { + return movement_direction; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyService.cpp b/Space-Invaders/Source/Enemy/EnemyService.cpp new file mode 100644 index 000000000..8ad9f1dc1 --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyService.cpp @@ -0,0 +1,94 @@ +#include"../../Header/Enemy/EnemyController.h" +#include"../../Header/Enemy/EnemyService.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Enemy/EnemyConfig.h" +#include"../../Header/Enemy/Controllers/SubZeroController.h" +#include"../../Header/Enemy/Controllers/ZapperController.h" +#include"../../Header/Enemy/Controllers/UFOController.h" +#include + +namespace Enemy +{ + using namespace Global; + using namespace TimeSpace; + + EnemyService::EnemyService() { } + EnemyService::~EnemyService() { destroy(); } + + void EnemyService::initialize() + { + spawn_time = spawn_intreval; + } + + void EnemyService::update() + { + updateSpawnTime(); + processEnemySpawn(); + + for (int i = 0; i < enemy_list.size(); i++) enemy_list[i]->update(); + } + + void EnemyService::render() + { + for (int i = 0; i < enemy_list.size(); i++) enemy_list[i]->render(); + } + + void EnemyService::updateSpawnTime() + { + spawn_time += ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + } + + void EnemyService::processEnemySpawn() + { + if (spawn_time >= spawn_intreval) + { + spawnEnemy(); + spawn_time = 0.0f; + } + } + EnemyController* EnemyService::createEnemy(EnemyType enemy_type) + { + switch (enemy_type) + { + case::Enemy::EnemyType::ZAPPER: + return new Enemy::Controller::ZapperController(Enemy::EnemyType::ZAPPER); + + /*case::Enemy::EnemyType::THUNDER_SNAKE: + return new ThunderSnakeController(Enemy::EnemyType::THUNDER_SNAKE);*/ + + case::Enemy::EnemyType::SUBZERO: + return new Enemy::Controller::SubzeroController(Enemy::EnemyType::SUBZERO); + + case::Enemy::EnemyType::UFO: + return new Enemy::Controller::UFOController(Enemy::EnemyType::UFO); + } + } + + EnemyController* EnemyService::spawnEnemy() + { + EnemyController* enemy_controller = createEnemy(getRandomEnemyType()); + enemy_controller->initialize(); + + enemy_list.push_back(enemy_controller); + + return enemy_controller; + } + + EnemyType EnemyService::getRandomEnemyType() + { + int randomType = std::rand() % 4; + std::cout << randomType<<"\n"; + return static_cast(randomType); + } + + void EnemyService::destroyEnemy(EnemyController* enemy_controller) + { + enemy_list.erase(std::remove(enemy_list.begin(), enemy_list.end(), enemy_controller), enemy_list.end()); + delete (enemy_controller); + } + + void EnemyService::destroy() + { + for (int i = 0; i < enemy_list.size(); i++) delete(enemy_list[i]); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyView.cpp b/Space-Invaders/Source/Enemy/EnemyView.cpp new file mode 100644 index 000000000..5cf569821 --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyView.cpp @@ -0,0 +1,68 @@ +#include "../../Header/Enemy/EnemyView.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Graphic/GraphicsServices.h" +#include "../../Header/Enemy/EnemyController.h" +#include"../../Header/Enemy/EnemyConfig.h" + +namespace Enemy +{ + using namespace Global; + using namespace Graphic; + + EnemyView::EnemyView() { } + + EnemyView::~EnemyView() { } + + void EnemyView::initialize(EnemyController* controller) + { + enemy_controller = controller; + game_window = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow(); + initializeEnemySprite(enemy_controller->getEnemyType()); + } + + void EnemyView::initializeEnemySprite(EnemyType type) + { + switch (type) + { + case::Enemy::EnemyType::SUBZERO: + if (Enemy_texture.loadFromFile(subzero_texture_path)) + { + Enemy_sprite.setTexture(Enemy_texture); + scaleEnemySprite(); + } + break; + case::Enemy::EnemyType::ZAPPER: + if (Enemy_texture.loadFromFile(zapper_texture_path)) + { + Enemy_sprite.setTexture(Enemy_texture); + scaleEnemySprite(); + } + break; + case::Enemy::EnemyType::UFO: + if (Enemy_texture.loadFromFile(ufo_texture_path)) + { + Enemy_sprite.setTexture(Enemy_texture); + scaleEnemySprite(); + } + break; + } + } + + void EnemyView::scaleEnemySprite() + { + Enemy_sprite.setScale( + static_cast(Enemy_sprite_width) / Enemy_sprite.getTexture()->getSize().x, + static_cast(Enemy_sprite_height) / Enemy_sprite.getTexture()->getSize().y + ); + } + + void EnemyView::update() + { + Enemy_sprite.setPosition(enemy_controller->getEnemyPosition()); + } + + void EnemyView::render() + { + game_window->draw(Enemy_sprite); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Event/EvnetService.cpp b/Space-Invaders/Source/Event/EvnetService.cpp new file mode 100644 index 000000000..a8ed9ddee --- /dev/null +++ b/Space-Invaders/Source/Event/EvnetService.cpp @@ -0,0 +1,138 @@ +#include "../../Header/Event/EventService.h"//event +#include "../../Header/Main/GameServices.h" +#include "../../Header/Graphic/GraphicsServices.h" + +namespace EventSpace +{ + using namespace Global; + EventService::EventService() + { + game_window = nullptr; + } + + EventService::~EventService() = default; + + void EventService::initialize() + { + game_window = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow(); + } + + void EventService::update() + { + updateMouseButtonsState(left_mouse_button_state, sf::Mouse::Left); + updateMouseButtonsState(right_mouse_button_state, sf::Mouse::Right); + updateKeyboardButtonsState(left_arrow_button_state, sf::Keyboard::Left); + updateKeyboardButtonsState(right_arrow_button_state, sf::Keyboard::Right); + updateKeyboardButtonsState(A_button_state, sf::Keyboard::A); + updateKeyboardButtonsState(D_button_state, sf::Keyboard::D); + } + + void EventService::updateMouseButtonsState(ButtonState& current_button_state, sf::Mouse::Button mouse_button) + { + if (sf::Mouse::isButtonPressed(mouse_button)) + { + switch (current_button_state) + { + case ButtonState::RELEASED: + current_button_state = ButtonState::PRESSED; + break; + case ButtonState::PRESSED: + current_button_state = ButtonState::HELD; + break; + } + } + else + { + current_button_state = ButtonState::RELEASED; + } + } + + void EventService::updateKeyboardButtonsState(ButtonState& current_button_state, sf::Keyboard::Key keyboard_button) + { + if (sf::Keyboard::isKeyPressed(keyboard_button)) + { + switch (current_button_state) + { + case ButtonState::RELEASED: + current_button_state = ButtonState::PRESSED; + break; + case ButtonState::PRESSED: + current_button_state = ButtonState::HELD; + break; + } + } + else + { + current_button_state = ButtonState::RELEASED; + } + } + + bool EventService::pressedLeftKey() + { + return left_arrow_button_state == ButtonState::HELD; + } + + bool EventService::pressedRightKey() + { + return right_arrow_button_state == ButtonState::HELD; + } + + bool EventService::pressedAKey() + { + return A_button_state == ButtonState::HELD; + } + + bool EventService::pressedDKey() + { + return D_button_state == ButtonState::HELD; + } + + bool EventService::pressedLeftMouseButton() + { + return left_mouse_button_state == ButtonState::PRESSED; + } + + bool EventService::pressedRightMouseButton() + { + return right_mouse_button_state == ButtonState::PRESSED; + } + + void EventService::processEvents() + { + if (isGameWindowOpen()) + { + while (game_window->pollEvent(game_event)) + { + if (gameWindowWasClosed() || hasQuitGame()) + { + game_window->close(); + } + } + } + } + + bool EventService::hasQuitGame() + { + return (isKeyboardEvent() && pressedEscapeKey()); + } + + bool EventService::isKeyboardEvent() + { + return game_event.type == sf::Event::KeyPressed; + } + + bool EventService::pressedEscapeKey() + { + return game_event.key.code == sf::Keyboard::Escape; + } + + bool EventService::isGameWindowOpen() + { + return game_window != nullptr; + } + + bool EventService::gameWindowWasClosed() + { + return game_event.type == sf::Event::Closed; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Gameplay/GameplayController.cpp b/Space-Invaders/Source/Gameplay/GameplayController.cpp new file mode 100644 index 000000000..e8be5544c --- /dev/null +++ b/Space-Invaders/Source/Gameplay/GameplayController.cpp @@ -0,0 +1,15 @@ +#include "../../header/Gameplay/GameplayController.h" +#include "../../header/Gameplay/GameplayView.h" + +namespace Gameplay +{ + GameplayController::GameplayController() { gameplay_view = new GameplayView(); } + + GameplayController::~GameplayController() { delete (gameplay_view); } + + void GameplayController::initialize() { gameplay_view->initialize(); } + + void GameplayController::update() { gameplay_view->update(); } + + void GameplayController::render() { gameplay_view->render(); } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Gameplay/GameplayService.cpp b/Space-Invaders/Source/Gameplay/GameplayService.cpp new file mode 100644 index 000000000..3ed71ed1e --- /dev/null +++ b/Space-Invaders/Source/Gameplay/GameplayService.cpp @@ -0,0 +1,15 @@ +#include "../../header/Gameplay/GameplayService.h" +#include "../../header/Gameplay/GameplayController.h" + +namespace Gameplay +{ + GameplayService::GameplayService() { gameplay_controller = new GameplayController(); } + + GameplayService::~GameplayService() { delete (gameplay_controller); } + + void GameplayService::initialize() { gameplay_controller->initialize(); } + + void GameplayService::update() { gameplay_controller->update(); } + + void GameplayService::render() { gameplay_controller->render(); } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Gameplay/GameplayView.cpp b/Space-Invaders/Source/Gameplay/GameplayView.cpp new file mode 100644 index 000000000..0318b9c3d --- /dev/null +++ b/Space-Invaders/Source/Gameplay/GameplayView.cpp @@ -0,0 +1,40 @@ +#include "../../header/Gameplay/GameplayView.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/Graphic/GraphicsServices.h" + +namespace Gameplay +{ + using namespace Global; + using namespace Graphic; + + GameplayView::GameplayView() { } + + GameplayView::~GameplayView() { } + + void GameplayView::initialize() + { + game_window = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow(); + initializeBackgroundSprite(); + } + + void GameplayView::initializeBackgroundSprite() + { + if (background_texture.loadFromFile(background_texture_path)) + { + background_sprite.setTexture(background_texture); + scaleBackgroundSprite(); + } + } + + void GameplayView::scaleBackgroundSprite() + { + background_sprite.setScale( + static_cast(game_window->getSize().x) / background_sprite.getTexture()->getSize().x, + static_cast(game_window->getSize().y) / background_sprite.getTexture()->getSize().y + ); + } + + void GameplayView::update() { } + + void GameplayView::render() { game_window->draw(background_sprite); } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Global/Config.cpp b/Space-Invaders/Source/Global/Config.cpp new file mode 100644 index 000000000..dc1e1d0d6 --- /dev/null +++ b/Space-Invaders/Source/Global/Config.cpp @@ -0,0 +1,56 @@ +#include "../../Header/Global/Config.h" + +namespace Global +{ + const sf::String Config::outscal_logo_texture_path = "assets/textures/outscal_logo.png"; + + const sf::String Config::background_texture_path = "assets/textures/space_invaders_bg.png"; + + const sf::String Config::player_texture_path = "assets/textures/player_ship.png"; + + + const sf::String Config::zapper_texture_path = "assets/textures/zapper.png"; + + const sf::String Config::thunder_snake_texture_path = "assets/textures/thunder_snake.png"; + + const sf::String Config::subzero_texture_path = "assets/textures/subzero.png"; + + const sf::String Config::ufo_texture_path = "assets/textures/ufo.png"; + + const sf::String Config::bunker_texture_path = "assets/textures/bunker.png"; + + + const sf::String Config::shield_texture_path = "assets/textures/shield.png"; + + const sf::String Config::tripple_laser_texture_path = "assets/textures/tripple_laser.png"; + + const sf::String Config::rapid_fire_texture_path = "assets/textures/rapid_fire.png"; + + const sf::String Config::outscal_bomb_texture_path = "assets/textures/outscal_bomb.png"; + + + const sf::String Config::laser_bullet_texture_path = "assets/textures/laser_bullet.png"; + + const sf::String Config::torpedoe_texture_path = "assets/textures/torpedoe.png"; + + const sf::String Config::frost_beam_texture_path = "assets/textures/frost_beam.png"; + + + const sf::String Config::play_button_texture_path = "assets/textures/play_button.png"; + + const sf::String Config::instructions_button_texture_path = "assets/textures/instructions_button.png"; + + const sf::String Config::quit_button_texture_path = "assets/textures/quit_button.png"; + + const sf::String Config::menu_button_texture_path = "assets/textures/menu_button.png"; + + + const sf::String Config::bubble_bobble_font_path = "assets/fonts/bubbleBobble.ttf"; + + const sf::String Config::DS_DIGIB_font_path = "assets/fonts/DS_DIGIB.ttf"; + + + const sf::String Config::background_music_path = "assets/sounds/background_music.mp3"; + + const sf::String Config::button_click_sound_path = "assets/sounds/button_click_sound.wav"; +} \ No newline at end of file diff --git a/Space-Invaders/Source/Global/ServiceLocator.cpp b/Space-Invaders/Source/Global/ServiceLocator.cpp new file mode 100644 index 000000000..833784085 --- /dev/null +++ b/Space-Invaders/Source/Global/ServiceLocator.cpp @@ -0,0 +1,182 @@ +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Graphic/GraphicsServices.h" +#include"../../Header/Main/GameServices.h" + +namespace Global +{ + ServiceLocator::ServiceLocator() + { + graphics_service = nullptr; + event_service = nullptr; + player_service = nullptr; + time_service = nullptr; + ui_service = nullptr; + enemy_service = nullptr; + gameplay_service = nullptr; + element_service = nullptr; + sound_service = nullptr; + bullet_service = nullptr; + powerup_service = nullptr; + + createServices(); + } + + ServiceLocator::~ServiceLocator() + { + clearAllServices(); + } + + void ServiceLocator::createServices() + { + graphics_service = new Graphic::GraphicsService(); + event_service = new EventSpace::EventService(); + player_service = new Player::PlayerService(); + time_service = new TimeSpace::TimeService(); + ui_service = new UI::UIService(); + enemy_service = new Enemy::EnemyService(); + gameplay_service = new Gameplay::GameplayService(); + element_service = new Element::ElementService(); + sound_service = new SoundSpace::SoundService(); + bullet_service = new Bullet::BulletService(); + powerup_service = new Powerup::PowerupService(); + } + + void ServiceLocator::clearAllServices() + { + delete(graphics_service); + delete(event_service); + delete(player_service); + delete(time_service); + delete(ui_service); + delete(enemy_service); + delete(gameplay_service); + delete(element_service); + delete(sound_service); + delete(bullet_service); + delete(powerup_service); + graphics_service = nullptr; + event_service = nullptr; + player_service = nullptr; + time_service = nullptr; + ui_service = nullptr; + enemy_service = nullptr; + gameplay_service = nullptr; + element_service = nullptr; + sound_service = nullptr; + bullet_service = nullptr; + powerup_service = nullptr; + } + + ServiceLocator* ServiceLocator::getInstance() + { + static ServiceLocator instance; + return &instance; + } + + void ServiceLocator::initialize() + { + graphics_service->initialize(); + event_service->initialize(); + player_service->initialize(); + time_service->initialize(); + ui_service->initialize(); + enemy_service->initialize(); + gameplay_service->initialize(); + element_service->initialize(); + sound_service->initialize(); + bullet_service->initialize(); + } + + void ServiceLocator::update() + { + graphics_service->update(); + event_service->update(); + time_service->update(); + ui_service->update(); + + if (Main::GameService::getGameState() == Main::GameState::GAMEPLAY) + { + player_service->update(); + enemy_service->update(); + gameplay_service->update(); + element_service->update(); + bullet_service->update(); + } + } + + void ServiceLocator::render() + { + graphics_service->render(); + ui_service->render(); + + if (Main::GameService::getGameState() == Main::GameState::GAMEPLAY) + { + gameplay_service->render(); + player_service->render(); + enemy_service->render(); + element_service->render(); + bullet_service->render(); + } + } + + Graphic::GraphicsService* ServiceLocator::getGraphicsService() + { + return graphics_service; + } + + EventSpace::EventService* ServiceLocator::getEventService() + { + return event_service; + } + + Player::PlayerService* ServiceLocator::getPlayerService() + { + return player_service; + } + + TimeSpace::TimeService* ServiceLocator::getTimeService() + { + return time_service; + } + + UI::UIService* ServiceLocator::getUIService() + { + return ui_service; + } + + Enemy::EnemyService* ServiceLocator::getEnemyService() + { + return enemy_service; + } + Gameplay::GameplayService* ServiceLocator::getGameplayService() + { + return gameplay_service; + } + + Element::ElementService* ServiceLocator::getElementService() + { + return element_service; + } + + SoundSpace::SoundService* ServiceLocator::getSoundService() + { + return sound_service; + } + + Bullet::BulletService* ServiceLocator::getBulletService() + { + return bullet_service; + } + + Powerup::PowerupService* ServiceLocator::getPowerupService() + { + return powerup_service; + } + + + + void ServiceLocator::deleteServiceLocator() + { + delete(this); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Graphic/GraphicsServices.cpp b/Space-Invaders/Source/Graphic/GraphicsServices.cpp new file mode 100644 index 000000000..bbc729063 --- /dev/null +++ b/Space-Invaders/Source/Graphic/GraphicsServices.cpp @@ -0,0 +1,68 @@ +#include "../../Header/Graphic/GraphicsServices.h" +#include"../../Header/Player/PlayerView.h" +#include +#include + + +namespace Graphic +{ + using namespace sf; + + GraphicsService::GraphicsService() + { + video_mode = nullptr; + gameWindow = nullptr; + } + + GraphicsService::~GraphicsService() + { + onDestroy(); + } + + void GraphicsService::initialize() + { + gameWindow = createGameWindow(); + } + + RenderWindow* GraphicsService::createGameWindow() + { + setVideoMode(); + return new RenderWindow(*video_mode, gameWindowTitle, Style::Fullscreen); + } + + void GraphicsService::setVideoMode() + { + video_mode = new VideoMode(windowWidth, windowHight, VideoMode::getDesktopMode().bitsPerPixel); + } + + void GraphicsService::onDestroy() + { + delete(video_mode); + delete(gameWindow); + } + + void GraphicsService::render() + { + + } + + void GraphicsService::update() + { + + } + + RenderWindow* GraphicsService::getGameWindow() + { + return gameWindow; + } + + bool GraphicsService::isGameWindowOpen() + { + return gameWindow->isOpen(); + } + + Color GraphicsService::getWindowColor() + { + return windowColor; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Main/GameServices.cpp b/Space-Invaders/Source/Main/GameServices.cpp new file mode 100644 index 000000000..d11d76d22 --- /dev/null +++ b/Space-Invaders/Source/Main/GameServices.cpp @@ -0,0 +1,74 @@ +#include"../../Header/Main/GameServices.h" +#include"../../Header/Graphic/GraphicsServices.h" +#include"../../Header/Global/ServiceLocator.h" + +namespace Main +{ + GameState GameService::current_state = GameState::BOOT; + + GameService::GameService() + { + service_locator = nullptr; + game_window = nullptr; + } + + GameService::~GameService() + { + destroy(); + } + + void GameService::start() + { + service_locator = Global::ServiceLocator::getInstance(); + initialize(); + } + + void GameService::initialize() + { + service_locator->initialize(); + initializeVariables(); + showMainMenu(); + } + + void GameService::initializeVariables() + { + game_window = service_locator->getGraphicsService()->getGameWindow(); + } + + void GameService::destroy() + { + + } + + void GameService::showMainMenu() + { + setGameState(GameState::MAIN_MENU); + } + + void GameService::update() + { + service_locator->getEventService()->processEvents(); + + service_locator->update(); + } + + void GameService::render() + { + game_window->clear(service_locator->getGraphicsService()->getWindowColor()); + service_locator->render(); + game_window->display(); + } + bool GameService::isRunning() + { + return service_locator->getGraphicsService()->isGameWindowOpen(); + } + void GameService::setGameState(GameState new_state) + { + current_state = new_state; + } + + GameState GameService::getGameState() + { + return current_state; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Player/PlayerController.cpp b/Space-Invaders/Source/Player/PlayerController.cpp new file mode 100644 index 000000000..d1f7a3518 --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerController.cpp @@ -0,0 +1,91 @@ +#include "../../Header/Player/PlayerController.h" +#include "../../Header/Event/EventService.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Player/PlayerModel.h" +#include "../../Header/Player/PlayerView.h" +#include"../../Header/Bullet/BulletConfig.h" +#include + +namespace Player +{ + using namespace Global; + using namespace EventSpace; + using namespace Bullet; + PlayerController::PlayerController() + { + player_view = new PlayerView(); + player_model = new PlayerModel(); + } + + PlayerController::~PlayerController() + { + delete (player_view); + delete (player_model); + } + + void PlayerController::processPlayerInput() + { + EventService* event_service = ServiceLocator::getInstance()->getEventService(); + + if (event_service->pressedLeftKey() || event_service->pressedAKey()) + { + moveLeft(); + } + + if (event_service->pressedRightKey() || event_service->pressedDKey()) + { + moveRight(); + } + + if (event_service->pressedLeftMouseButton()) fireBullet(); + } + + void PlayerController::fireBullet() + { + ServiceLocator::getInstance()->getBulletService()->spawnBullet(BulletType::LASER_BULLET, + player_model->getPlayerPosition() + player_model->barrel_position_offset, + Bullet::MovementDirection::UP); + } + + void PlayerController::initialize() + { + player_model->initialize(); + + + player_view->initialize(this); + } + + void PlayerController::update() + { + processPlayerInput(); + player_view->update(); + } + + void PlayerController::render() + { + player_view->render(); + } + + sf::Vector2f PlayerController::getPlayerPosition() + { + return player_model->getPlayerPosition(); + } + + void PlayerController::moveLeft() + { + sf::Vector2f currentPosition = player_model->getPlayerPosition(); + currentPosition.x -= player_model->playerMoveSpeed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + currentPosition.x = std::max(currentPosition.x, player_model->left_most_position.x); + player_model->setPlayerPosition(currentPosition); + } + + void PlayerController::moveRight() + { + sf::Vector2f currentPosition = player_model->getPlayerPosition(); + currentPosition.x += player_model->playerMoveSpeed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + currentPosition.x = std::min(currentPosition.x, player_model->right_most_position.x); + player_model->setPlayerPosition(currentPosition); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Player/PlayerModel.cpp b/Space-Invaders/Source/Player/PlayerModel.cpp new file mode 100644 index 000000000..08128e3d4 --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerModel.cpp @@ -0,0 +1,57 @@ +#include "../../Header/Player/PlayerModel.h" + +namespace Player +{ + PlayerModel::PlayerModel() { } + + PlayerModel::~PlayerModel() { } + + void PlayerModel::initialize() { reset(); } + + void PlayerModel::reset() + { + playerAlive = true; + currentPosition = initialPostion; + playerScore = 0; + } + + sf::Vector2f PlayerModel::getPlayerPosition() + { + return currentPosition; + } + + void PlayerModel::setPlayerPosition(sf::Vector2f position) + { + currentPosition = position; + } + + bool PlayerModel::isPlayerAlive() + { + return playerAlive; + } + + void PlayerModel::setPlayerAlive(bool alive) + { + playerAlive = alive; + } + + int PlayerModel::getPlayerScore() + { + return playerScore; + } + + void PlayerModel::setPlayerScore(int score) + { + playerScore = score; + } + + PlayerState PlayerModel::getPlayerState() + { + return player_state; + } + + void PlayerModel::setPlayerState(PlayerState state) + { + player_state = state; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Player/PlayerService.cpp b/Space-Invaders/Source/Player/PlayerService.cpp new file mode 100644 index 000000000..8094b48f9 --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerService.cpp @@ -0,0 +1,31 @@ +#include "../../Header/Player/PlayerService.h" +#include "../../Header/Player/PlayerController.h" +#include "../../Header/Player/PlayerController.h" + +namespace Player +{ + PlayerService::PlayerService() + { + player_controller = new PlayerController(); + } + + PlayerService::~PlayerService() + { + delete (player_controller); + } + + void PlayerService::initialize() + { + player_controller->initialize(); + } + + void PlayerService::update() + { + player_controller->update(); + } + + void PlayerService::render() + { + player_controller->render(); + } +} diff --git a/Space-Invaders/Source/Player/PlayerView.cpp b/Space-Invaders/Source/Player/PlayerView.cpp new file mode 100644 index 000000000..c1020a4bd --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerView.cpp @@ -0,0 +1,52 @@ +#include "../../Header/Player/PlayerView.h" +#include "../../Header/Global/ServiceLocator.h" + +namespace Player +{ + using namespace Global; + PlayerView::PlayerView() { } + + PlayerView::~PlayerView() { } + + void PlayerView::initialize() + { + + game_window = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow(); + initializePlayerSprite(); + } + + void PlayerView::initializePlayerSprite() + { + if (player_texture.loadFromFile(player_texture_path)) + { + player_sprite.setTexture(player_texture); + scalePlayerSprite(); + } + } + + void PlayerView::scalePlayerSprite() + { + player_sprite.setScale( + static_cast(player_sprite_width) / player_sprite.getTexture()->getSize().x, + static_cast(player_sprite_height) / player_sprite.getTexture()->getSize().y + ); + } + + void PlayerView::update() + { + player_sprite.setPosition(player_controller->getPlayerPosition()); + } + + void PlayerView::render() + { + game_window->draw(player_sprite); + } + + void PlayerView::initialize(PlayerController* controller) + { + player_controller = controller; //to later use it for setting position + game_window = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow(); + initializePlayerSprite(); + } + +} diff --git a/Space-Invaders/Source/Powerup/Controllers/OutscalBombController.cpp b/Space-Invaders/Source/Powerup/Controllers/OutscalBombController.cpp new file mode 100644 index 000000000..f9fc0d728 --- /dev/null +++ b/Space-Invaders/Source/Powerup/Controllers/OutscalBombController.cpp @@ -0,0 +1,13 @@ +#include "../../header/Powerup/Controllers/OutscalBombController.h" + +namespace Powerup +{ + namespace Controller + { + OutscalBombController::OutscalBombController(PowerupType type) : PowerupController(type) {} + + OutscalBombController::~OutscalBombController() {} + + void OutscalBombController::onCollected() {}; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/Controllers/RapidFireController.cpp b/Space-Invaders/Source/Powerup/Controllers/RapidFireController.cpp new file mode 100644 index 000000000..e69de29bb diff --git a/Space-Invaders/Source/Powerup/Controllers/ShieldController.cpp b/Space-Invaders/Source/Powerup/Controllers/ShieldController.cpp new file mode 100644 index 000000000..e69de29bb diff --git a/Space-Invaders/Source/Powerup/Controllers/TrippleLaserController.cpp b/Space-Invaders/Source/Powerup/Controllers/TrippleLaserController.cpp new file mode 100644 index 000000000..e69de29bb diff --git a/Space-Invaders/Source/Powerup/PowerupController.cpp b/Space-Invaders/Source/Powerup/PowerupController.cpp new file mode 100644 index 000000000..31eee1f27 --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupController.cpp @@ -0,0 +1,72 @@ +#include "../../header/Powerup/PowerupController.h" +#include "../../header/Powerup/PowerupView.h" +#include "../../header/Powerup/PowerupModel.h" +#include "../../header/Global/ServiceLocator.h" + +namespace Powerup +{ + using namespace Global; + + PowerupController::PowerupController(PowerupType type) + { + powerup_view = new PowerupView(); + powerup_model = new PowerupModel(type); + } + + PowerupController::~PowerupController() + { + delete (powerup_view); + delete (powerup_model); + } + + void PowerupController::initialize(sf::Vector2f position) + { + powerup_model->initialize(position); + powerup_view->initialize(this); + } + + void PowerupController::update() + { + updatePowerupPosition(); + powerup_view->update(); + } + + void PowerupController::render() + { + powerup_view->render(); + } + + void PowerupController::onCollected() + { + } + + void PowerupController::updatePowerupPosition() + { + sf::Vector2f currentPosition = powerup_model->getPowerupPosition(); + currentPosition.y += powerup_model->getMovementSpeed() * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + powerup_model->setPowerupPosition(currentPosition); + } + + void PowerupController::handleOutOfBounds() + { + sf::Vector2f powerupPosition = getCollectiblePosition(); + sf::Vector2u windowSize = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow()->getSize(); + + if (powerupPosition.x < 0 || powerupPosition.x > windowSize.x || + powerupPosition.y < 0 || powerupPosition.y > windowSize.y) + { + ServiceLocator::getInstance()->getPowerupService()->destroyPowerup(this); + } + } + + sf::Vector2f PowerupController::getCollectiblePosition() + { + return powerup_model->getPowerupPosition(); + } + + PowerupType PowerupController::getPowerupType() + { + return powerup_model->getPowerupType(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/PowerupModel.cpp b/Space-Invaders/Source/Powerup/PowerupModel.cpp new file mode 100644 index 000000000..e9f5640de --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupModel.cpp @@ -0,0 +1,46 @@ +#include "../../header/Powerup/PowerupModel.h" + +namespace Powerup +{ + PowerupModel::PowerupModel(PowerupType type) + { + powerup_type = type; + } + + PowerupModel::~PowerupModel() { } + + void PowerupModel::initialize(sf::Vector2f position) + { + powerup_position = position; + } + + sf::Vector2f PowerupModel::getPowerupPosition() + { + return powerup_position; + } + + void PowerupModel::setPowerupPosition(sf::Vector2f position) + { + powerup_position = position; + } + + PowerupType PowerupModel::getPowerupType() + { + return powerup_type; + } + + void PowerupModel::setPowerupType(PowerupType type) + { + powerup_type = type; + } + + float PowerupModel::getMovementSpeed() + { + return movement_speed; + } + + void PowerupModel::setMovementSpeed(float speed) + { + movement_speed = speed; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/PowerupService.cpp b/Space-Invaders/Source/Powerup/PowerupService.cpp new file mode 100644 index 000000000..f8dbe8178 --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupService.cpp @@ -0,0 +1,69 @@ +#include "../../header/Powerup/PowerupService.h" +#include "../../header/Powerup/PowerupController.h" +#include "../../header/Powerup/PowerupConfig.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/Powerup/Controllers/OutscalBombController.h" +#include "../../header/Powerup/Controllers/RapidFireController.h" +#include "../../header/Powerup/Controllers/ShieldController.h" +#include "../../header/Powerup/Controllers/TrippleLaserController.h" + +namespace Powerup +{ + using namespace Global; + using namespace Controller; + using namespace Collectible; + + PowerupService::PowerupService() { } + + PowerupService::~PowerupService() { destroy(); } + + void PowerupService::initialize() { } + + void PowerupService::update() + { + for (int i = 0; i < powerup_list.size(); i++) powerup_list[i]->update(); + } + + void PowerupService::render() + { + for (int i = 0; i < powerup_list.size(); i++) powerup_list[i]->render(); + } + + PowerupController* PowerupService::createPowerup(PowerupType powerup_type) + { + switch (powerup_type) + { + case::Powerup::PowerupType::SHIELD: + return new ShieldController(Powerup::PowerupType::SHIELD); + + case::Powerup::PowerupType::RAPID_FIRE: + return new RapidFireController(Powerup::PowerupType::RAPID_FIRE); + + case::Powerup::PowerupType::TRIPPLE_LASER: + return new TrippleLaserController(Powerup::PowerupType::TRIPPLE_LASER); + + case::Powerup::PowerupType::OUTSCAL_BOMB: + return new OutscalBombController(Powerup::PowerupType::OUTSCAL_BOMB); + } + } + + PowerupController* PowerupService::spawnPowerup(PowerupType powerup_type, sf::Vector2f position) + { + PowerupController* powerup_controller = createPowerup(powerup_type); + + powerup_controller->initialize(position); + powerup_list.push_back(powerup_controller); + return powerup_controller; + } + + void PowerupService::destroyPowerup(PowerupController* powerup_controller) + { + powerup_list.erase(std::remove(powerup_list.begin(), powerup_list.end(), powerup_controller), powerup_list.end()); + delete(powerup_controller); + } + + void PowerupService::destroy() + { + for (int i = 0; i < powerup_list.size(); i++) delete (powerup_list[i]); + } +} diff --git a/Space-Invaders/Source/Powerup/PowerupView.cpp b/Space-Invaders/Source/Powerup/PowerupView.cpp new file mode 100644 index 000000000..addfac729 --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupView.cpp @@ -0,0 +1,73 @@ +#include "../../header/Powerup/PowerupView.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/Global/Config.h" +#include "../../header/Bullet/BulletConfig.h" +#include "../../header/Powerup/PowerupController.h" +#include "../../header/Powerup/PowerupConfig.h" + +namespace Powerup +{ + using namespace Global; + using namespace UI::UIElement; + + PowerupView::PowerupView() { createUIElements(); } + + PowerupView::~PowerupView() { destroy(); } + + void PowerupView::initialize(PowerupController* controller) + { + powerup_controller = controller; + initializeImage(); + } + + void PowerupView::createUIElements() + { + powerup_image = new ImageView(); + } + + void PowerupView::initializeImage() + { + powerup_image->initialize(getPowerupTexturePath(), powerup_sprite_width, powerup_sprite_height, powerup_controller->getCollectiblePosition()); + } + + /*void PowerupView::scaleImage() + { + powerup_sprite.setScale( + static_cast(powerup_sprite_width) / powerup_sprite.getTexture()->getSize().x, + static_cast(powerup_sprite_height) / powerup_sprite.getTexture()->getSize().y + ); + }*/ + + void PowerupView::update() + { + powerup_image->setPosition(powerup_controller->getCollectiblePosition()); + } + + void PowerupView::render() + { + powerup_image->render(); + } + + sf::String PowerupView::getPowerupTexturePath() + { + switch (powerup_controller->getPowerupType()) + { + case::Powerup::PowerupType::SHIELD: + return Config::shield_texture_path; + + case::Powerup::PowerupType::TRIPPLE_LASER: + return Config::tripple_laser_texture_path; + + case::Powerup::PowerupType::RAPID_FIRE: + return Config::rapid_fire_texture_path; + + case::Powerup::PowerupType::OUTSCAL_BOMB: + return Config::outscal_bomb_texture_path; + } + } + + void PowerupView::destroy() + { + delete(powerup_image); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Sound/SoundService.cpp b/Space-Invaders/Source/Sound/SoundService.cpp new file mode 100644 index 000000000..920dde525 --- /dev/null +++ b/Space-Invaders/Source/Sound/SoundService.cpp @@ -0,0 +1,47 @@ +#include "../../Header/Sound/SoundService.h" +#include "../../Header/Global/Config.h" + +namespace SoundSpace +{ + using namespace Global; + + void SoundService::initialize() + { + loadBackgroundMusicFromFile(); + loadSoundFromFile(); + } + + void SoundService::loadBackgroundMusicFromFile() + { + if (!background_music.openFromFile(Config::background_music_path)) + printf("Error loading background music file"); + } + + void SoundService::loadSoundFromFile() + { + if (!buffer_button_click.loadFromFile(Config::button_click_sound_path)) + printf("Error loading background music file"); + } + + void SoundService::playSound(SoundType soundType) + { + switch (soundType) + { + case SoundType::BUTTON_CLICK: + sound_effect.setBuffer(buffer_button_click); + break; + default: + printf("Invalid sound type"); + return; + } + + sound_effect.play(); + } + + void SoundService::playBackgroundMusic() + { + background_music.setLoop(true); + background_music.setVolume(background_music_volume); + background_music.play(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Time/TimeService.cpp b/Space-Invaders/Source/Time/TimeService.cpp new file mode 100644 index 000000000..df2d497f2 --- /dev/null +++ b/Space-Invaders/Source/Time/TimeService.cpp @@ -0,0 +1,39 @@ +#include"../../Header/Time/TimeService.h" +using namespace std; + +namespace TimeSpace +{ + void TimeService::initialize() + { + previous_time = chrono::steady_clock::now(); + delta_time = 0; + } + + void TimeService::update() + { + updateDeltaTime(); + } + + float TimeService::getDeltaTime() + { + return delta_time; + } + + void TimeService::updateDeltaTime() + { + delta_time = calculateDeltaTime(); + updatePreviousTime(); + } + + float TimeService::calculateDeltaTime() + { + int delta = chrono::duration_cast(chrono::steady_clock::now() - previous_time).count(); + + return static_cast(delta) / static_cast(1000000); + } + + void TimeService::updatePreviousTime() + { + previous_time = chrono::steady_clock::now(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/MainMenu/MainMenuUIController.cpp b/Space-Invaders/Source/UI/MainMenu/MainMenuUIController.cpp new file mode 100644 index 000000000..8a0dab785 --- /dev/null +++ b/Space-Invaders/Source/UI/MainMenu/MainMenuUIController.cpp @@ -0,0 +1,134 @@ +#include "../../Header/UI/MainMenu/MainMenuUIContoller.h" +#include "../../Header/Main/GameServices.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Graphic/GraphicsServices.h" +#include "../../Header/Global/Config.h" +#include"../../Header/Sound/SoundService.h" +#include "../../Header/Event/EventService.h" + +namespace UI +{ + namespace MainMenu + { + using namespace Global; + using namespace Main; + using namespace Graphic; + using namespace EventSpace; + using namespace SoundSpace; + using namespace UIElement; + + MainMenuUIController::MainMenuUIController() + { + createImage(); + createButtons(); + } + + MainMenuUIController::~MainMenuUIController() + { + destroy(); + } + + void MainMenuUIController::initialize() + { + registerButtonCallback(); + initializeBackgroundImage(); + initializeButtons(); + } + + void MainMenuUIController::createImage() + { + background_image = new ImageView(); + } + + void MainMenuUIController::initializeBackgroundImage() + { + sf::RenderWindow* game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + + background_image->initialize(Config::background_texture_path, game_window->getSize().x, game_window->getSize().y, sf::Vector2f(0, 0)); + background_image->setImageAlpha(background_alpha); + } + + void MainMenuUIController::scaleBackgroundImage() + { + background_sprite.setScale( + static_cast(game_window->getSize().x) / background_sprite.getTexture()->getSize().x, + static_cast(game_window->getSize().y) / background_sprite.getTexture()->getSize().y + ); + } + + void MainMenuUIController::registerButtonCallback() + { + play_button->registerCallbackFuntion(std::bind(&MainMenuUIController::playButtonCallback, this)); + instructions_button->registerCallbackFuntion(std::bind(&MainMenuUIController::instructionsButtonCallback, this)); + quit_button->registerCallbackFuntion(std::bind(&MainMenuUIController::quitButtonCallback, this)); + } + + void MainMenuUIController::playButtonCallback() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::BUTTON_CLICK); + GameService::setGameState(GameState::GAMEPLAY); + } + + void MainMenuUIController::initializeButtons() + { + play_button->initialize("Play Button", Config::play_button_texture_path, button_width, button_height, sf::Vector2f(0, play_button_y_position)); + instructions_button->initialize("Instructions Button", Config::instructions_button_texture_path, button_width, button_height, sf::Vector2f(0, instructions_button_y_position)); + quit_button->initialize("Quit Button", Config::quit_button_texture_path, button_width, button_height, sf::Vector2f(0, quit_button_y_position)); + + play_button->setCentreAlinged(); + instructions_button->setCentreAlinged(); + quit_button->setCentreAlinged(); + } + + void MainMenuUIController::instructionsButtonCallback() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::BUTTON_CLICK); + } + + void MainMenuUIController::quitButtonCallback() + { + ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->close(); + } + + bool MainMenuUIController::loadButtonTexturesFromFile() + { + return play_button_texture.loadFromFile(play_button_texture_path) && + instructions_button_texture.loadFromFile(instructions_button_texture_path) && + quit_button_texture.loadFromFile(quit_button_texture_path); + } + + void MainMenuUIController::update() + { + background_image->update(); + play_button->update(); + instructions_button->update(); + quit_button->update + } + + void MainMenuUIController::render() + { + background_image->render(); + play_button->render(); + instructions_button->render(); + quit_button->render(); + } + + void MainMenuUIController::show() + { + background_image->show(); + play_button->show(); + instructions_button->show(); + quit_button->show(); + + ServiceLocator::getInstance()->getSoundService()->playBackgroundMusic(); + } + + void MainMenuUIController::destroy() + { + delete (play_button); + delete (instructions_button); + delete (quit_button); + delete (background_image); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/ButtonView.cpp b/Space-Invaders/Source/UI/UIElement/ButtonView.cpp new file mode 100644 index 000000000..9f48fb75c --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/ButtonView.cpp @@ -0,0 +1,64 @@ +#include "../../header/UI/UIElement/ButtonView.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/Event/EventService.h" +#include "../../header/Sound/SoundService.h" + +namespace UI +{ + namespace UIElement + { + using namespace EventSpace; + using namespace Global; + + ButtonView::ButtonView() = default; + + ButtonView::~ButtonView() = default; + + void ButtonView::initialize(sf::String title, sf::String texture_path, float button_width, float button_height, sf::Vector2f position) + { + ImageView::initialize(texture_path, button_width, button_height, position); + button_title = title; + } + + void ButtonView::registerCallbackFuntion(CallbackFunction button_callback) + { + callback_function = button_callback; + } + + void ButtonView::update() + { + ImageView::update(); + + if (ui_state == UIState::VISIBLE) + { + handleButtonInteraction(); + } + } + + void ButtonView::render() + { + ImageView::render(); + } + + void ButtonView::handleButtonInteraction() + { + sf::Vector2f mouse_position = sf::Vector2f(sf::Mouse::getPosition(*game_window)); + + if (clickedButton(&image_sprite, mouse_position)) + { + if (callback_function) callback_function(); + } + } + + bool ButtonView::clickedButton(sf::Sprite* button_sprite, sf::Vector2f mouse_position) + { + return ServiceLocator::getInstance()->getEventService()->pressedLeftMouseButton() && + button_sprite->getGlobalBounds().contains(mouse_position); + } + + void ButtonView::printButtonClicked() + { + printf("Clicked %s\n", button_title.toAnsiString().c_str()); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/ImageView.cpp b/Space-Invaders/Source/UI/UIElement/ImageView.cpp new file mode 100644 index 000000000..e19b770dd --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/ImageView.cpp @@ -0,0 +1,80 @@ +#include "../../header/UI/UIElement/ImageView.h" + +namespace UI +{ + namespace UIElement + { + ImageView::ImageView() = default; + + ImageView::~ImageView() = default; + + void ImageView::initialize(sf::String texture_path, float image_width, float image_height, sf::Vector2f position) + { + UIView::initialize(); + setTexture(texture_path); + setScale(image_width, image_height); + setPosition(position); + } + + void ImageView::update() + { + UIView::update(); + } + + void ImageView::render() + { + UIView::render(); + + if (ui_state == UIState::VISIBLE) + { + game_window->draw(image_sprite); + } + } + + void ImageView::setTexture(sf::String texture_path) + { + if (image_texture.loadFromFile(texture_path)) + { + image_sprite.setTexture(image_texture); + } + } + + void ImageView::setScale(float width, float height) + { + float scale_x = width / image_sprite.getTexture()->getSize().x; + float scale_y = height / image_sprite.getTexture()->getSize().y; + + image_sprite.setScale(scale_x, scale_y); + } + + void ImageView::setPosition(sf::Vector2f position) + { + image_sprite.setPosition(position); + } + + void ImageView::setRotation(float rotation_angle) + { + image_sprite.setRotation(rotation_angle); + } + + void ImageView::setOriginAtCentre() + { + image_sprite.setOrigin(image_sprite.getLocalBounds().width / 2, image_sprite.getLocalBounds().height / 2); + } + + void ImageView::setImageAlpha(float alpha) + { + sf::Color color = image_sprite.getColor(); + color.a = alpha; + image_sprite.setColor(color); + } + + void ImageView::setCentreAlinged() + { + float x_position = (game_window->getSize().x / 2) - (image_sprite.getGlobalBounds().width / 2); + float y_position = image_sprite.getGlobalBounds().getPosition().y; + + image_sprite.setPosition(x_position, y_position); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/TextView.cpp b/Space-Invaders/Source/UI/UIElement/TextView.cpp new file mode 100644 index 000000000..ade1cbc4d --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/TextView.cpp @@ -0,0 +1,95 @@ +#include "../../header/UI/UIElement/TextView.h" +#include "../../header/Global/Config.h" + +namespace UI +{ + namespace UIElement + { + using namespace Global; + + sf::Font TextView::font_bubble_bobble; + sf::Font TextView::font_DS_DIGIB; + + TextView::TextView() = default; + + TextView::~TextView() = default; + + void TextView::initialize(sf::String text_value, sf::Vector2f position, FontType font_type, int font_size, sf::Color color) + { + UIView::initialize(); + + setText(text_value); + setTextPosition(position); + setFont(font_type); + setFontSize(font_size); + setTextColor(color); + } + + void TextView::update() + { + UIView::update(); + } + + void TextView::render() + { + UIView::render(); + + if (ui_state == UIState::VISIBLE) + { + game_window->draw(text); + } + } + + void TextView::initializeTextView() + { + loadFont(); + } + + void TextView::loadFont() + { + font_bubble_bobble.loadFromFile(Config::bubble_bobble_font_path); + font_DS_DIGIB.loadFromFile(Config::DS_DIGIB_font_path); + } + + void TextView::setText(sf::String text_value) + { + text.setString(text_value); + } + + void TextView::setFont(FontType font_type) + { + switch (font_type) + { + case FontType::BUBBLE_BOBBLE: + text.setFont(font_bubble_bobble); + break; + case FontType::DS_DIGIB: + text.setFont(font_DS_DIGIB); + break; + } + } + + void TextView::setFontSize(int font_size) + { + text.setCharacterSize(font_size); + } + + void TextView::setTextPosition(sf::Vector2f position) + { + text.setPosition(position); + } + + void TextView::setTextColor(sf::Color color) + { + text.setFillColor(color); + } + + void TextView::setTextCentreAligned() + { + float x_position = (game_window->getSize().x - text.getLocalBounds().width) / 2; + float y_position = text.getGlobalBounds().getPosition().y; + + text.setPosition(sf::Vector2f(x_position, y_position)); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/UIView.cpp b/Space-Invaders/Source/UI/UIElement/UIView.cpp new file mode 100644 index 000000000..b5ff8896c --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/UIView.cpp @@ -0,0 +1,36 @@ +#include "../../Header/UI/UIElement/UIView.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Graphic/GraphicsServices.h" + +namespace UI +{ + namespace UIElement + { + using namespace Global; + using namespace Graphic; + + UIView::UIView() = default; + + UIView::~UIView() = default; + + void UIView::initialize() + { + game_window = ServiceLocator::getInstance()->getGraphicsService()->getGameWindow(); + ui_state = UIState::VISIBLE; + } + + void UIView::update() { } + + void UIView::render() { } + + void UIView::show() + { + ui_state = UIState::VISIBLE; + } + + void UIView::hide() + { + ui_state = UIState::HIDDEN; + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIService.cpp b/Space-Invaders/Source/UI/UIService.cpp new file mode 100644 index 000000000..ae231a8bf --- /dev/null +++ b/Space-Invaders/Source/UI/UIService.cpp @@ -0,0 +1,86 @@ +#include "../../Header/UI/UIService.h" +#include "../../Header/Main/GameServices.h" +#include "../../Header/UI/UIElement/TextView.h" + +namespace UI +{ + using namespace Main; + using namespace MainMenu; + using namespace UIElement; + using namespace Interface; + + UIService::UIService() + { + main_menu_controller = nullptr; + + createControllers(); + } + + void UIService::createControllers() + { + main_menu_controller = new MainMenuUIController(); + } + + UIService::~UIService() + { + destroy(); + } + + void UIService::initialize() + { + TextView::initializeTextView(); + initializeControllers(); + } + + void UIService::update() + { + IUIController* ui_controller = getCurrentUIController(); + if (ui_controller) ui_controller->update(); + /*switch (GameService::getGameState()) + { + case GameState::MAIN_MENU: + return main_menu_controller->update();; + break; + }*/ + } + + void UIService::render() + { + IUIController* ui_controller = getCurrentUIController(); + if (ui_controller) ui_controller->render(); + /*switch (GameService::getGameState()) + { + case GameState::MAIN_MENU: + return main_menu_controller->render(); + break; + }*/ + } + + void UIService::showScreen() + { + IUIController* ui_controller = getCurrentUIController(); + if (ui_controller) ui_controller->show(); + } + + IUIController* UIService::getCurrentUIController() + { + switch (GameService::getGameState()) + { + case GameState::MAIN_MENU: + return main_menu_controller; + + default: + return nullptr; + } + } + + void UIService::initializeControllers() + { + main_menu_controller->initialize(); + } + + void UIService::destroy() + { + delete(main_menu_controller); + } +} \ No newline at end of file diff --git a/Space-Invaders/Space-Invaders.vcxproj b/Space-Invaders/Space-Invaders.vcxproj index 6f7fa388d..e6e15d2a6 100644 --- a/Space-Invaders/Space-Invaders.vcxproj +++ b/Space-Invaders/Space-Invaders.vcxproj @@ -132,7 +132,107 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Space-Invaders/Space-Invaders.vcxproj.filters b/Space-Invaders/Space-Invaders.vcxproj.filters index ce0c35ccf..ed7d62341 100644 --- a/Space-Invaders/Space-Invaders.vcxproj.filters +++ b/Space-Invaders/Space-Invaders.vcxproj.filters @@ -18,5 +18,301 @@ Source Files + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + \ No newline at end of file diff --git a/Space-Invaders/main.cpp b/Space-Invaders/main.cpp index 7d5f90dff..445d1a9c3 100644 --- a/Space-Invaders/main.cpp +++ b/Space-Invaders/main.cpp @@ -1,5 +1,118 @@ +#include +#include +#include "Header/Main/GameServices.h" +using namespace std; +using namespace sf; + + +/* +class player +{ + int health = 3, playerScore = 0; + + Vector2f position = Vector2f(350.0f, 500.0f); + + float moveSpeed = 5; + +public: + + Texture playerTexture; + + Sprite playerSprite; + + void setScore(int newScore) + { + playerScore += newScore; + } + + int getHealth() + { + return health; + } + + int getMoveSpeed() + { + return moveSpeed; + } + + int getPlayerScore() + { + return playerScore; + } + + Vector2f getPlayerPosition() + { + return position; + } + + void takeDamage() + { + cout << "player takes damage\n"; + } + void move(float offsetX) + { + position.x += offsetX; + cout << "player moved"; + } + void shootBullets() + { + cout << "player shoots bullets\n"; + } +}; +*/ int main() { + /* + VideoMode videoMode = sf::VideoMode(800, 600); + + RenderWindow window(videoMode, "Player 1"); + + player player; + + int speed = player.getMoveSpeed(); + + Vector2f pos = player.getPlayerPosition(); + + player.playerTexture.loadFromFile("assets/textures/player_ship.png"); + + player.playerSprite.setTexture(player.playerTexture); + + while (window.isOpen()) { + sf::Event event; + while (window.pollEvent(event)) { + if (event.type == sf::Event::Closed) + window.close(); + if (Keyboard::isKeyPressed(Keyboard::Left)) + { + player.move(-1.0f * player.getMoveSpeed()); + cout << " left\n"; + } + if (Keyboard::isKeyPressed(Keyboard::Right)) + { + player.move(1.0f * player.getMoveSpeed()); + cout << " Right\n"; + } + } + + + window.clear(sf::Color::Blue); + + player.playerSprite.setPosition(player.getPlayerPosition()); + + window.draw(player.playerSprite); + + window.display(); + } + */ + Main::GameService* gs = new Main::GameService(); + + gs->start(); + + while (gs->isRunning()) + { + gs->update(); + gs->render(); + } return 0; -} \ No newline at end of file +} diff --git a/Space-Invaders/sfml/doc/SFML.tag b/Space-Invaders/sfml/doc/SFML.tag new file mode 100644 index 000000000..4bd407d82 --- /dev/null +++ b/Space-Invaders/sfml/doc/SFML.tag @@ -0,0 +1,17560 @@ + + + + GpuPreference.hpp + include/SFML/ + GpuPreference_8hpp.html + + #define + SFML_DEFINE_DISCRETE_GPU_PREFERENCE + GpuPreference_8hpp.html + ab0233c2d867cbd561036ed2440a4fec0 + + + + + sf::AlResource + classsf_1_1AlResource.html + + + AlResource + classsf_1_1AlResource.html + a51b4f3a825c5d68386f8683e3e1053d7 + () + + + + ~AlResource + classsf_1_1AlResource.html + a74ad78198cddcb6e5d847177364049db + () + + + + sf::BlendMode + structsf_1_1BlendMode.html + + + Factor + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbb + + + + Zero + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbafda2d66c3c3da15cd3b42338fbf6d2ba + + + + One + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbaa2d3ba8b8bb2233c9d357cbb94bf4181 + + + + SrcColor + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbad679bb0ecaf15c188d7f2e1fab572188 + + + + OneMinusSrcColor + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbba5971ffdbca63382058ccba76bfce219e + + + + DstColor + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbba3d85281c3eab7153f2bd9faae3e7523a + + + + OneMinusDstColor + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbac8198db20d14506a841d1091ced1cae2 + + + + SrcAlpha + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbaac0ae68df2930b4d616c3e7abeec7d41 + + + + OneMinusSrcAlpha + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbaab57e8616bf4c21d8ee923178acdf2c8 + + + + DstAlpha + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbba5e3dc9a6f117aaa5f7433e1f4662a5f7 + + + + OneMinusDstAlpha + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbab4e5c63f189f26075e5939ad1a2ce4e4 + + + + + Equation + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32 + + + + Add + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32a50c081d8f36cf7b77632966e15d38966 + + + + Subtract + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32a14c825be24f8412fc5ed5b49f19bc0d0 + + + + ReverseSubtract + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32a2d04acf59e91811128e7d0ef076f65f0 + + + + Min + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32aaaac595afe61d785aa8fd4b401acffc5 + + + + Max + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32a40ddfddfaafccc8b58478eeef52e4281 + + + + Zero + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbafda2d66c3c3da15cd3b42338fbf6d2ba + + + + One + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbaa2d3ba8b8bb2233c9d357cbb94bf4181 + + + + SrcColor + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbad679bb0ecaf15c188d7f2e1fab572188 + + + + OneMinusSrcColor + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbba5971ffdbca63382058ccba76bfce219e + + + + DstColor + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbba3d85281c3eab7153f2bd9faae3e7523a + + + + OneMinusDstColor + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbac8198db20d14506a841d1091ced1cae2 + + + + SrcAlpha + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbaac0ae68df2930b4d616c3e7abeec7d41 + + + + OneMinusSrcAlpha + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbaab57e8616bf4c21d8ee923178acdf2c8 + + + + DstAlpha + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbba5e3dc9a6f117aaa5f7433e1f4662a5f7 + + + + OneMinusDstAlpha + structsf_1_1BlendMode.html + afb9852caf356b53bb0de460c58a9ebbbab4e5c63f189f26075e5939ad1a2ce4e4 + + + + Add + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32a50c081d8f36cf7b77632966e15d38966 + + + + Subtract + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32a14c825be24f8412fc5ed5b49f19bc0d0 + + + + ReverseSubtract + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32a2d04acf59e91811128e7d0ef076f65f0 + + + + Min + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32aaaac595afe61d785aa8fd4b401acffc5 + + + + Max + structsf_1_1BlendMode.html + a7bce470e2e384c4f9c8d9595faef7c32a40ddfddfaafccc8b58478eeef52e4281 + + + + + BlendMode + structsf_1_1BlendMode.html + a7faef75eae1fb47bbe93f45f38e3d345 + () + + + + BlendMode + structsf_1_1BlendMode.html + a23c7452cc8e9eb943c3aea6234ce4297 + (Factor sourceFactor, Factor destinationFactor, Equation blendEquation=Add) + + + + BlendMode + structsf_1_1BlendMode.html + a69a12c596114e77126616e7e0f7d798b + (Factor colorSourceFactor, Factor colorDestinationFactor, Equation colorBlendEquation, Factor alphaSourceFactor, Factor alphaDestinationFactor, Equation alphaBlendEquation) + + + Factor + colorSrcFactor + structsf_1_1BlendMode.html + a32d1a55dbfada86a06d9b881dc8ccf7b + + + + Factor + colorDstFactor + structsf_1_1BlendMode.html + adee68ee59e7f1bf71d12db03d251104d + + + + Equation + colorEquation + structsf_1_1BlendMode.html + aed12f06eb7f50a1b95b892b0964857b1 + + + + Factor + alphaSrcFactor + structsf_1_1BlendMode.html + aa94e44f8e1042a7357e8eff78c61a1be + + + + Factor + alphaDstFactor + structsf_1_1BlendMode.html + aaf85b6b7943181cc81745569c4851e4e + + + + Equation + alphaEquation + structsf_1_1BlendMode.html + a68f5a305e0912946f39ba6c9265710c4 + + + + bool + operator== + structsf_1_1BlendMode.html + a20d1be06061109c3cef58e0cc38729ea + (const BlendMode &left, const BlendMode &right) + + + bool + operator!= + structsf_1_1BlendMode.html + aee6169f8983f5e92298c4ad6829563ba + (const BlendMode &left, const BlendMode &right) + + + + sf::SoundStream::Chunk + structsf_1_1SoundStream_1_1Chunk.html + + const Int16 * + samples + structsf_1_1SoundStream_1_1Chunk.html + aa3b84d69adbe663a17a7671626076df4 + + + + std::size_t + sampleCount + structsf_1_1SoundStream_1_1Chunk.html + af47f5d94012acf8b11f056ba77aff97a + + + + + sf::CircleShape + classsf_1_1CircleShape.html + sf::Shape + + + CircleShape + classsf_1_1CircleShape.html + aaebe705e7180cd55588eb19488af3af1 + (float radius=0, std::size_t pointCount=30) + + + void + setRadius + classsf_1_1CircleShape.html + a21cdf85fc2f201e10222a241af864be0 + (float radius) + + + float + getRadius + classsf_1_1CircleShape.html + aa3dd5a1b5031486ce5b6f09d43674aa3 + () const + + + void + setPointCount + classsf_1_1CircleShape.html + a16590ee7bdf5c9f752275468a4997bed + (std::size_t count) + + + virtual std::size_t + getPointCount + classsf_1_1CircleShape.html + a014d29ec11e8afa4dce50e7047d99601 + () const + + + virtual Vector2f + getPoint + classsf_1_1CircleShape.html + a2d7f9715502b960b92387102fddb8736 + (std::size_t index) const + + + void + setTexture + classsf_1_1Shape.html + af8fb22bab1956325be5d62282711e3b6 + (const Texture *texture, bool resetRect=false) + + + void + setTextureRect + classsf_1_1Shape.html + a2029cc820d1740d14ac794b82525e157 + (const IntRect &rect) + + + void + setFillColor + classsf_1_1Shape.html + a3506f9b5d916fec14d583d16f23c2485 + (const Color &color) + + + void + setOutlineColor + classsf_1_1Shape.html + a5978f41ee349ac3c52942996dcb184f7 + (const Color &color) + + + void + setOutlineThickness + classsf_1_1Shape.html + a5ad336ad74fc1f567fce3b7e44cf87dc + (float thickness) + + + const Texture * + getTexture + classsf_1_1Shape.html + af4c345931cd651ffb8f7a177446e28f7 + () const + + + const IntRect & + getTextureRect + classsf_1_1Shape.html + ad8adbb54823c8eff1830a938e164daa4 + () const + + + const Color & + getFillColor + classsf_1_1Shape.html + aa5da23e522d2dd11e3e7661c26164c78 + () const + + + const Color & + getOutlineColor + classsf_1_1Shape.html + a4aa05b59851468e948ac9682b9c71abb + () const + + + float + getOutlineThickness + classsf_1_1Shape.html + a1d4d5299c573a905e5833fc4dce783a7 + () const + + + FloatRect + getLocalBounds + classsf_1_1Shape.html + ae3294bcdf8713d33a862242ecf706443 + () const + + + FloatRect + getGlobalBounds + classsf_1_1Shape.html + ac0e29425d908d5442060cc44790fe4da + () const + + + void + setPosition + classsf_1_1Transformable.html + a4dbfb1a7c80688b0b4c477d706550208 + (float x, float y) + + + void + setPosition + classsf_1_1Transformable.html + af1a42209ce2b5d3f07b00f917bcd8015 + (const Vector2f &position) + + + void + setRotation + classsf_1_1Transformable.html + a32baf2bf1a74699b03bf8c95030a38ed + (float angle) + + + void + setScale + classsf_1_1Transformable.html + aaec50b46b3f41b054763304d1e727471 + (float factorX, float factorY) + + + void + setScale + classsf_1_1Transformable.html + a4c48a87f1626047e448f9c1a68ff167e + (const Vector2f &factors) + + + void + setOrigin + classsf_1_1Transformable.html + a56c67bd80aae8418d13fb96c034d25ec + (float x, float y) + + + void + setOrigin + classsf_1_1Transformable.html + aa93a835ffbf3bee2098dfbbc695a7f05 + (const Vector2f &origin) + + + const Vector2f & + getPosition + classsf_1_1Transformable.html + aea8b18e91a7bf7be589851bb9dd11241 + () const + + + float + getRotation + classsf_1_1Transformable.html + aa00b5c5d4a06ac24a94dd72c56931d3a + () const + + + const Vector2f & + getScale + classsf_1_1Transformable.html + a7bcae0e924213f2e89edd8926f2453af + () const + + + const Vector2f & + getOrigin + classsf_1_1Transformable.html + a898b33eb6513161eb5c747a072364f15 + () const + + + void + move + classsf_1_1Transformable.html + a86b461d6a941ad390c2ad8b6a4a20391 + (float offsetX, float offsetY) + + + void + move + classsf_1_1Transformable.html + ab9ca691522f6ddc1a40406849b87c469 + (const Vector2f &offset) + + + void + rotate + classsf_1_1Transformable.html + af8a5ffddc0d93f238fee3bf8efe1ebda + (float angle) + + + void + scale + classsf_1_1Transformable.html + a3de0c6d8957f3cf318092f3f60656391 + (float factorX, float factorY) + + + void + scale + classsf_1_1Transformable.html + adecaa6c69b1f27dd5194b067d96bb694 + (const Vector2f &factor) + + + const Transform & + getTransform + classsf_1_1Transformable.html + a3e1b4772a451ec66ac7e6af655726154 + () const + + + const Transform & + getInverseTransform + classsf_1_1Transformable.html + ac5e75d724436069d2268791c6b486916 + () const + + + void + update + classsf_1_1Shape.html + adfb2bd966c8edbc5d6c92ebc375e4ac1 + () + + + + sf::Clipboard + classsf_1_1Clipboard.html + + static String + getString + classsf_1_1Clipboard.html + a3c385cc2b6d78a3d0cfa29928a7d6eb8 + () + + + static void + setString + classsf_1_1Clipboard.html + a29c597c2165d3ca3a89c17f31ff7413d + (const String &text) + + + + sf::Clock + classsf_1_1Clock.html + + + Clock + classsf_1_1Clock.html + abbc959c7830ca7c3a4da133cb506d3fd + () + + + Time + getElapsedTime + classsf_1_1Clock.html + abe889b42a65bcd8eefc16419645d08a7 + () const + + + Time + restart + classsf_1_1Clock.html + a123e2627f2943e5ecaa1db0c7df3231b + () + + + + sf::Color + classsf_1_1Color.html + + + Color + classsf_1_1Color.html + ac2eb4393fb11ad3fa3ccf34e92fe08e4 + () + + + + Color + classsf_1_1Color.html + ac791dc61be4c60baac50fe700f1c9850 + (Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha=255) + + + + Color + classsf_1_1Color.html + a5449f4b2b9a78230d40ce2c223c9ab2e + (Uint32 color) + + + Uint32 + toInteger + classsf_1_1Color.html + abb46e6942c4fe0d221574a46e642caa9 + () const + + + Uint8 + r + classsf_1_1Color.html + a6a5256ca24a4f9f0e0808f6fc23e01e1 + + + + Uint8 + g + classsf_1_1Color.html + a591daf9c3c55dea830c76c962d6ba1a5 + + + + Uint8 + b + classsf_1_1Color.html + a6707aedd0609c8920e12df5d7abc53cb + + + + Uint8 + a + classsf_1_1Color.html + a56dbdb47d5f040d9b78ac6a0b8b3a831 + + + + static const Color + Black + classsf_1_1Color.html + a77c688197b981338f0b19dc58bd2facd + + + + static const Color + White + classsf_1_1Color.html + a4fd874712178d9e206f53226002aa4ca + + + + static const Color + Red + classsf_1_1Color.html + a127dbf55db9c07d0fa8f4bfcbb97594a + + + + static const Color + Green + classsf_1_1Color.html + a95629b30de8c6856aa7d3afed12eb865 + + + + static const Color + Blue + classsf_1_1Color.html + ab03770d4817426b2614cfc33cf0e245c + + + + static const Color + Yellow + classsf_1_1Color.html + af8896b5f56650935f5b9d72d528802c7 + + + + static const Color + Magenta + classsf_1_1Color.html + a6fe70d90b65b2163dd066a84ac00426c + + + + static const Color + Cyan + classsf_1_1Color.html + a64ae9beb0b9a5865dd811cda4bb18340 + + + + static const Color + Transparent + classsf_1_1Color.html + a569b45471737f770656f50ae7bbac292 + + + + bool + operator== + classsf_1_1Color.html + a2adc3f68860f7aa5e4d7c79dcbb31d30 + (const Color &left, const Color &right) + + + bool + operator!= + classsf_1_1Color.html + a394c3495753c4b17f9cd45556ef00b8c + (const Color &left, const Color &right) + + + Color + operator+ + classsf_1_1Color.html + a0355ba6bfd2f83ffd8f8fafdca26cdd0 + (const Color &left, const Color &right) + + + Color + operator- + classsf_1_1Color.html + a4586e31d668f183fc46576511169bf2c + (const Color &left, const Color &right) + + + Color + operator* + classsf_1_1Color.html + a1bae779fb49bb92dbf820a65e45a6602 + (const Color &left, const Color &right) + + + Color & + operator+= + classsf_1_1Color.html + af39790b2e677c9ab418787f5ff4583ef + (Color &left, const Color &right) + + + Color & + operator-= + classsf_1_1Color.html + a6927a7dba8b0d330f912fefb43b0c148 + (Color &left, const Color &right) + + + Color & + operator*= + classsf_1_1Color.html + a7d1ea2b9bd5dbe29bb2e54feba9b4b38 + (Color &left, const Color &right) + + + + sf::Context + classsf_1_1Context.html + sf::GlResource + sf::NonCopyable + + + Context + classsf_1_1Context.html + aba22797a790706ca2c5c04ee39f2b555 + () + + + + ~Context + classsf_1_1Context.html + a805b1bbdb3e52b1fda7c9bf2cd6ca86b + () + + + bool + setActive + classsf_1_1Context.html + a0806f915ea81ae1f4e8135a7a3696562 + (bool active) + + + const ContextSettings & + getSettings + classsf_1_1Context.html + a5aace0ecfcf9552e97eed9ae88d01f71 + () const + + + + Context + classsf_1_1Context.html + a2a9e3529e48919120e6b6fc10bad296c + (const ContextSettings &settings, unsigned int width, unsigned int height) + + + static bool + isExtensionAvailable + classsf_1_1Context.html + a163c7f72c0c20133606657d895faa147 + (const char *name) + + + static GlFunctionPointer + getFunction + classsf_1_1Context.html + a998980d311effdf6223ce40d934c23c3 + (const char *name) + + + static const Context * + getActiveContext + classsf_1_1Context.html + a31bc6509779067b21d13208ffe85d5ca + () + + + static Uint64 + getActiveContextId + classsf_1_1Context.html + a61b1cb0a99b8e3ce56579d70aa41fb70 + () + + + + sf::ContextSettings + structsf_1_1ContextSettings.html + + + Attribute + structsf_1_1ContextSettings.html + af2e91e57e8d26c40afe2ec8efaa32a2c + + + + Default + structsf_1_1ContextSettings.html + af2e91e57e8d26c40afe2ec8efaa32a2cabf868dcb751b909bf031484ed42a93bb + + + + Core + structsf_1_1ContextSettings.html + af2e91e57e8d26c40afe2ec8efaa32a2cacb581130734cbd87cbbc9438429f4a8b + + + + Debug + structsf_1_1ContextSettings.html + af2e91e57e8d26c40afe2ec8efaa32a2ca6043f67afb3d48918d5336474eabaafc + + + + Default + structsf_1_1ContextSettings.html + af2e91e57e8d26c40afe2ec8efaa32a2cabf868dcb751b909bf031484ed42a93bb + + + + Core + structsf_1_1ContextSettings.html + af2e91e57e8d26c40afe2ec8efaa32a2cacb581130734cbd87cbbc9438429f4a8b + + + + Debug + structsf_1_1ContextSettings.html + af2e91e57e8d26c40afe2ec8efaa32a2ca6043f67afb3d48918d5336474eabaafc + + + + + ContextSettings + structsf_1_1ContextSettings.html + ac56869ccbb6bf0df48b88880754e12b7 + (unsigned int depth=0, unsigned int stencil=0, unsigned int antialiasing=0, unsigned int major=1, unsigned int minor=1, unsigned int attributes=Default, bool sRgb=false) + + + unsigned int + depthBits + structsf_1_1ContextSettings.html + a4809e22089c2af7276b8809b5aede7bb + + + + unsigned int + stencilBits + structsf_1_1ContextSettings.html + ac2e788c201ca20e84fd38a28071abd29 + + + + unsigned int + antialiasingLevel + structsf_1_1ContextSettings.html + ac4a097be18994dba38d73f36b0418bdc + + + + unsigned int + majorVersion + structsf_1_1ContextSettings.html + a99a680d5c15a7e34c935654155dd5166 + + + + unsigned int + minorVersion + structsf_1_1ContextSettings.html + aaeb0efe9d2658b840da93b30554b100f + + + + Uint32 + attributeFlags + structsf_1_1ContextSettings.html + a0ef3fc53802bc0197d2739466915ada5 + + + + bool + sRgbCapable + structsf_1_1ContextSettings.html + ac93b041bfb6cbd36034997797708a0a3 + + + + + sf::ConvexShape + classsf_1_1ConvexShape.html + sf::Shape + + + ConvexShape + classsf_1_1ConvexShape.html + af9981b8909569b381b3fccf32fc69856 + (std::size_t pointCount=0) + + + void + setPointCount + classsf_1_1ConvexShape.html + a56e6e79ade6dd651cc1a0e39cb68deae + (std::size_t count) + + + virtual std::size_t + getPointCount + classsf_1_1ConvexShape.html + a0c54b8d48fe4e13414f6e667dbfc22a3 + () const + + + void + setPoint + classsf_1_1ConvexShape.html + a5929e0ab0ba5ca1f102b40c234a8e92d + (std::size_t index, const Vector2f &point) + + + virtual Vector2f + getPoint + classsf_1_1ConvexShape.html + a72a97bc426d8daf4d682a20fcb7f3fe7 + (std::size_t index) const + + + void + setTexture + classsf_1_1Shape.html + af8fb22bab1956325be5d62282711e3b6 + (const Texture *texture, bool resetRect=false) + + + void + setTextureRect + classsf_1_1Shape.html + a2029cc820d1740d14ac794b82525e157 + (const IntRect &rect) + + + void + setFillColor + classsf_1_1Shape.html + a3506f9b5d916fec14d583d16f23c2485 + (const Color &color) + + + void + setOutlineColor + classsf_1_1Shape.html + a5978f41ee349ac3c52942996dcb184f7 + (const Color &color) + + + void + setOutlineThickness + classsf_1_1Shape.html + a5ad336ad74fc1f567fce3b7e44cf87dc + (float thickness) + + + const Texture * + getTexture + classsf_1_1Shape.html + af4c345931cd651ffb8f7a177446e28f7 + () const + + + const IntRect & + getTextureRect + classsf_1_1Shape.html + ad8adbb54823c8eff1830a938e164daa4 + () const + + + const Color & + getFillColor + classsf_1_1Shape.html + aa5da23e522d2dd11e3e7661c26164c78 + () const + + + const Color & + getOutlineColor + classsf_1_1Shape.html + a4aa05b59851468e948ac9682b9c71abb + () const + + + float + getOutlineThickness + classsf_1_1Shape.html + a1d4d5299c573a905e5833fc4dce783a7 + () const + + + FloatRect + getLocalBounds + classsf_1_1Shape.html + ae3294bcdf8713d33a862242ecf706443 + () const + + + FloatRect + getGlobalBounds + classsf_1_1Shape.html + ac0e29425d908d5442060cc44790fe4da + () const + + + void + setPosition + classsf_1_1Transformable.html + a4dbfb1a7c80688b0b4c477d706550208 + (float x, float y) + + + void + setPosition + classsf_1_1Transformable.html + af1a42209ce2b5d3f07b00f917bcd8015 + (const Vector2f &position) + + + void + setRotation + classsf_1_1Transformable.html + a32baf2bf1a74699b03bf8c95030a38ed + (float angle) + + + void + setScale + classsf_1_1Transformable.html + aaec50b46b3f41b054763304d1e727471 + (float factorX, float factorY) + + + void + setScale + classsf_1_1Transformable.html + a4c48a87f1626047e448f9c1a68ff167e + (const Vector2f &factors) + + + void + setOrigin + classsf_1_1Transformable.html + a56c67bd80aae8418d13fb96c034d25ec + (float x, float y) + + + void + setOrigin + classsf_1_1Transformable.html + aa93a835ffbf3bee2098dfbbc695a7f05 + (const Vector2f &origin) + + + const Vector2f & + getPosition + classsf_1_1Transformable.html + aea8b18e91a7bf7be589851bb9dd11241 + () const + + + float + getRotation + classsf_1_1Transformable.html + aa00b5c5d4a06ac24a94dd72c56931d3a + () const + + + const Vector2f & + getScale + classsf_1_1Transformable.html + a7bcae0e924213f2e89edd8926f2453af + () const + + + const Vector2f & + getOrigin + classsf_1_1Transformable.html + a898b33eb6513161eb5c747a072364f15 + () const + + + void + move + classsf_1_1Transformable.html + a86b461d6a941ad390c2ad8b6a4a20391 + (float offsetX, float offsetY) + + + void + move + classsf_1_1Transformable.html + ab9ca691522f6ddc1a40406849b87c469 + (const Vector2f &offset) + + + void + rotate + classsf_1_1Transformable.html + af8a5ffddc0d93f238fee3bf8efe1ebda + (float angle) + + + void + scale + classsf_1_1Transformable.html + a3de0c6d8957f3cf318092f3f60656391 + (float factorX, float factorY) + + + void + scale + classsf_1_1Transformable.html + adecaa6c69b1f27dd5194b067d96bb694 + (const Vector2f &factor) + + + const Transform & + getTransform + classsf_1_1Transformable.html + a3e1b4772a451ec66ac7e6af655726154 + () const + + + const Transform & + getInverseTransform + classsf_1_1Transformable.html + ac5e75d724436069d2268791c6b486916 + () const + + + void + update + classsf_1_1Shape.html + adfb2bd966c8edbc5d6c92ebc375e4ac1 + () + + + + sf::Shader::CurrentTextureType + structsf_1_1Shader_1_1CurrentTextureType.html + + + sf::Cursor + classsf_1_1Cursor.html + sf::NonCopyable + + + Type + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930a + + + + Arrow + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa8d9a9cd284dabb4246ab4f147ba779a3 + + + + ArrowWait + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa16c3acb967f2175434d6bbad7f1300bf + + + + Wait + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aabeb51ea58e48e4477ab802d46ad2cbdd + + + + Text + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa1a9979392de58ff11d5b4ab330e6393d + + + + Hand + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aae826935374aa0414723918ba79f13368 + + + + SizeHorizontal + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa0131508eaa8802dba34b8c9b41aec6e9 + + + + SizeVertical + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aab3cefa56d3a0fe9fe64680c7ec11eab5 + + + + SizeTopLeftBottomRight + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa934ddc380262a94358ccb5a4ab7bbe1c + + + + SizeBottomLeftTopRight + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aac047cea5795b6074fbb4d6479452e8ef + + + + SizeLeft + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa4725e9d5f8117997732f8dcccce45be4 + + + + SizeRight + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aaebc3670bd27360a7de429daa07921a4d + + + + SizeTop + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa605e36bf335a0d801b4e7d67995a9e85 + + + + SizeBottom + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aaafd57cfee8747f202db04a549057e185 + + + + SizeTopLeft + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa2cc42c06dd701af7211f351333b629ca + + + + SizeBottomRight + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa581edf98abd0b4905329b516a45eeef8 + + + + SizeBottomLeft + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa62fb130f4aa6ecf39c8366e0de549cc2 + + + + SizeTopRight + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa84d9478fdeef2f727f06f3fe5bdb1be6 + + + + SizeAll + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa256a64be04f0347e6a44cbf84e5410bd + + + + Cross + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aaf3b3213aad68863c7dec96587681fecd + + + + Help + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aaf2c0ed3674b334ebf8365aee243186f5 + + + + NotAllowed + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aadb1ec726725dd81ec9906cbe06fec805 + + + + Arrow + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa8d9a9cd284dabb4246ab4f147ba779a3 + + + + ArrowWait + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa16c3acb967f2175434d6bbad7f1300bf + + + + Wait + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aabeb51ea58e48e4477ab802d46ad2cbdd + + + + Text + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa1a9979392de58ff11d5b4ab330e6393d + + + + Hand + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aae826935374aa0414723918ba79f13368 + + + + SizeHorizontal + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa0131508eaa8802dba34b8c9b41aec6e9 + + + + SizeVertical + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aab3cefa56d3a0fe9fe64680c7ec11eab5 + + + + SizeTopLeftBottomRight + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa934ddc380262a94358ccb5a4ab7bbe1c + + + + SizeBottomLeftTopRight + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aac047cea5795b6074fbb4d6479452e8ef + + + + SizeLeft + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa4725e9d5f8117997732f8dcccce45be4 + + + + SizeRight + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aaebc3670bd27360a7de429daa07921a4d + + + + SizeTop + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa605e36bf335a0d801b4e7d67995a9e85 + + + + SizeBottom + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aaafd57cfee8747f202db04a549057e185 + + + + SizeTopLeft + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa2cc42c06dd701af7211f351333b629ca + + + + SizeBottomRight + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa581edf98abd0b4905329b516a45eeef8 + + + + SizeBottomLeft + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa62fb130f4aa6ecf39c8366e0de549cc2 + + + + SizeTopRight + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa84d9478fdeef2f727f06f3fe5bdb1be6 + + + + SizeAll + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aa256a64be04f0347e6a44cbf84e5410bd + + + + Cross + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aaf3b3213aad68863c7dec96587681fecd + + + + Help + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aaf2c0ed3674b334ebf8365aee243186f5 + + + + NotAllowed + classsf_1_1Cursor.html + ab9ab152aec1f8a4955e34ccae08f930aadb1ec726725dd81ec9906cbe06fec805 + + + + + Cursor + classsf_1_1Cursor.html + a6a36a0a5943b22b77b00cac839dd715c + () + + + + ~Cursor + classsf_1_1Cursor.html + a777ba6a1d0d68f8eb9dc85976a5b9727 + () + + + bool + loadFromPixels + classsf_1_1Cursor.html + ac24ecf82ac7d9ba6703389397f948b3a + (const Uint8 *pixels, Vector2u size, Vector2u hotspot) + + + bool + loadFromSystem + classsf_1_1Cursor.html + ad41999c8633c2fbaa2364e379c1ab25b + (Type type) + + + + sf::Ftp::DirectoryResponse + classsf_1_1Ftp_1_1DirectoryResponse.html + sf::Ftp::Response + + + Status + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3b + + + + RestartMarkerReply + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba07e06d3326ba2d078583bef93930d909 + + + + ServiceReadySoon + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba22413357ade6b586f6ceb0d704f35075 + + + + DataConnectionAlreadyOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafa52d19bc813d69055f4cc390d4a76ca + + + + OpeningDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba794ebe743688be611447638bf9e49d86 + + + + Ok + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baa956e229ba6c0cdf0d88b0e05b286210 + + + + PointlessCommand + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba38adc424f1adcd332745de8cd3b7737a + + + + SystemStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9bdd02ae119b8be639e778859ee74060 + + + + DirectoryStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8729460a695013cc96330e2fced0ae1f + + + + FileStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baebddfc7997dca289c83068dff3f47dce + + + + HelpMessage + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba840fd2a1872fd4310b046541f57fdeb7 + + + + SystemType + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba78391f73aa11f07f1514c7d070b93c08 + + + + ServiceReady + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baea2ee2007d7843c21108bb686ef03757 + + + + ClosingConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bab23931490fc2d1df3081d651fe0f4d6e + + + + DataConnectionOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3badc78ed87d5bddb174fa3c16707ac2f2d + + + + ClosingDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bac723ebc8a38913bbf0d9504556cbaaa6 + + + + EnteringPassiveMode + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba48314fc47a72ad0aacdea93b91756f6e + + + + LoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba54a88210386cb72e35d737813a221754 + + + + FileActionOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf988b69b0a5f55f8122da5ba001932e0 + + + + DirectoryOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba06d26e95a170fc422af13def415e0437 + + + + NeedPassword + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9249e3fe9818eb93f181fbbf3ae3bc56 + + + + NeedAccountToLogIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9e048185f253f6eb6f5ff9e063b712fa + + + + NeedInformation + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba02e6f05964ecb829e9b6fb6020d6528a + + + + ServiceUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba43022ddf49b68a4f5aff0bea7e09e89f + + + + DataConnectionUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba757b89ff1f236941f7759b0ed0c28b88 + + + + TransferAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba7cfefcc586c12ba70f752353fde7126e + + + + FileActionAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf822d1b0abf3e9ae7dd44684549d512d + + + + LocalError + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bae54e84baaca95a7b36271ca3f3fdb900 + + + + InsufficientStorageSpace + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba5d9f3666222c808553c27e4e099c7c6d + + + + CommandUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba75bdf0b6844fa9c07b3c25647d22c269 + + + + ParametersUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf4c7c88815981bbb7c3a3461f9f48b67 + + + + CommandNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba2ca4834c756c81b924ebed696fcba0a8 + + + + BadCommandSequence + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad0c7ab07f01c1f7af16a1852650d7c47 + + + + ParameterNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8807473b8590e1debfb3740b7a3d081c + + + + NotLoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafcfbaff2c6fed941b6bcbc0999db764e + + + + NeedAccountToStore + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba1af0f173062a471739b50d8e0f40d5f7 + + + + FileUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba3f8f931e499936fde6b750d81f5ecfef + + + + PageTypeUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad220bc12dc45593af6e5079ea6c532c3 + + + + NotEnoughMemory + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf418e54753e0b8f9cb0325dd618acd14 + + + + FilenameNotAllowed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba03254aba823298179a98056e15568c5b + + + + InvalidResponse + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba59e041e4ef186e8ae8d6035973fc46bd + + + + ConnectionFailed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba51aa367cc1e85a45ea3c7be48730e990 + + + + ConnectionClosed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad1e5dcf298ce30c528261435f1a2eb53 + + + + InvalidFile + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baed2c74a9f335dee1463ca1a4f41c6478 + + + + RestartMarkerReply + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba07e06d3326ba2d078583bef93930d909 + + + + ServiceReadySoon + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba22413357ade6b586f6ceb0d704f35075 + + + + DataConnectionAlreadyOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafa52d19bc813d69055f4cc390d4a76ca + + + + OpeningDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba794ebe743688be611447638bf9e49d86 + + + + Ok + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baa956e229ba6c0cdf0d88b0e05b286210 + + + + PointlessCommand + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba38adc424f1adcd332745de8cd3b7737a + + + + SystemStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9bdd02ae119b8be639e778859ee74060 + + + + DirectoryStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8729460a695013cc96330e2fced0ae1f + + + + FileStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baebddfc7997dca289c83068dff3f47dce + + + + HelpMessage + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba840fd2a1872fd4310b046541f57fdeb7 + + + + SystemType + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba78391f73aa11f07f1514c7d070b93c08 + + + + ServiceReady + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baea2ee2007d7843c21108bb686ef03757 + + + + ClosingConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bab23931490fc2d1df3081d651fe0f4d6e + + + + DataConnectionOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3badc78ed87d5bddb174fa3c16707ac2f2d + + + + ClosingDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bac723ebc8a38913bbf0d9504556cbaaa6 + + + + EnteringPassiveMode + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba48314fc47a72ad0aacdea93b91756f6e + + + + LoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba54a88210386cb72e35d737813a221754 + + + + FileActionOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf988b69b0a5f55f8122da5ba001932e0 + + + + DirectoryOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba06d26e95a170fc422af13def415e0437 + + + + NeedPassword + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9249e3fe9818eb93f181fbbf3ae3bc56 + + + + NeedAccountToLogIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9e048185f253f6eb6f5ff9e063b712fa + + + + NeedInformation + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba02e6f05964ecb829e9b6fb6020d6528a + + + + ServiceUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba43022ddf49b68a4f5aff0bea7e09e89f + + + + DataConnectionUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba757b89ff1f236941f7759b0ed0c28b88 + + + + TransferAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba7cfefcc586c12ba70f752353fde7126e + + + + FileActionAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf822d1b0abf3e9ae7dd44684549d512d + + + + LocalError + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bae54e84baaca95a7b36271ca3f3fdb900 + + + + InsufficientStorageSpace + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba5d9f3666222c808553c27e4e099c7c6d + + + + CommandUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba75bdf0b6844fa9c07b3c25647d22c269 + + + + ParametersUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf4c7c88815981bbb7c3a3461f9f48b67 + + + + CommandNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba2ca4834c756c81b924ebed696fcba0a8 + + + + BadCommandSequence + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad0c7ab07f01c1f7af16a1852650d7c47 + + + + ParameterNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8807473b8590e1debfb3740b7a3d081c + + + + NotLoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafcfbaff2c6fed941b6bcbc0999db764e + + + + NeedAccountToStore + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba1af0f173062a471739b50d8e0f40d5f7 + + + + FileUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba3f8f931e499936fde6b750d81f5ecfef + + + + PageTypeUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad220bc12dc45593af6e5079ea6c532c3 + + + + NotEnoughMemory + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf418e54753e0b8f9cb0325dd618acd14 + + + + FilenameNotAllowed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba03254aba823298179a98056e15568c5b + + + + InvalidResponse + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba59e041e4ef186e8ae8d6035973fc46bd + + + + ConnectionFailed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba51aa367cc1e85a45ea3c7be48730e990 + + + + ConnectionClosed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad1e5dcf298ce30c528261435f1a2eb53 + + + + InvalidFile + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baed2c74a9f335dee1463ca1a4f41c6478 + + + + + DirectoryResponse + classsf_1_1Ftp_1_1DirectoryResponse.html + a36b6d2728fa53c4ad37b7a6307f4d388 + (const Response &response) + + + const std::string & + getDirectory + classsf_1_1Ftp_1_1DirectoryResponse.html + a983b0ce3d99c687e0862212040158d67 + () const + + + bool + isOk + classsf_1_1Ftp_1_1Response.html + a5102552955a2652c1a39e9046e617b36 + () const + + + Status + getStatus + classsf_1_1Ftp_1_1Response.html + a52bbca9fbf5451157bc055e3d8430c25 + () const + + + const std::string & + getMessage + classsf_1_1Ftp_1_1Response.html + adc2890c93c9f8ee997b828fcbef82c97 + () const + + + + sf::Drawable + classsf_1_1Drawable.html + + virtual + ~Drawable + classsf_1_1Drawable.html + a906002f2df7beb5edbddf5bbef96f120 + () + + + virtual void + draw + classsf_1_1Drawable.html + a90d2c88bba9b035a0844eccb380ef631 + (RenderTarget &target, RenderStates states) const =0 + + + + sf::Event + classsf_1_1Event.html + sf::Event::JoystickButtonEvent + sf::Event::JoystickConnectEvent + sf::Event::JoystickMoveEvent + sf::Event::KeyEvent + sf::Event::MouseButtonEvent + sf::Event::MouseMoveEvent + sf::Event::MouseWheelEvent + sf::Event::MouseWheelScrollEvent + sf::Event::SensorEvent + sf::Event::SizeEvent + sf::Event::TextEvent + sf::Event::TouchEvent + + + EventType + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4a + + + + Closed + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa316e4212e083f1dce79efd8d9e9c0a95 + + + + Resized + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa67fd26d7e520bc6722db3ff47ef24941 + + + + LostFocus + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aabd7877b5011a337268357c973e8347bd + + + + GainedFocus + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa8c5003ced508499933d540df8a6023ec + + + + TextEntered + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa7e09871dc984080ff528e4f7e073e874 + + + + KeyPressed + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aac3c7abfaa98c73bfe6be0b57df09c71b + + + + KeyReleased + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aaa5bcc1e603d5a6f4c137af39558bd5d1 + + + + MouseWheelMoved + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa5cc9d3941af2a36049f4f9922c934a80 + + + + MouseWheelScrolled + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa2fb6925eb3e7f3d468faf639dbd129ad + + + + MouseButtonPressed + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa55a3dcc8bf6c40e37f9ff2cdf606481f + + + + MouseButtonReleased + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa9be69ecc07e484467ebbb133182fe5c1 + + + + MouseMoved + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa4ff4fc3b3dc857e3617a63feb54be209 + + + + MouseEntered + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa50d98590a953e74c7ccf3dabadb22067 + + + + MouseLeft + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aaa90b8526b328e0246d04b026de17c6e7 + + + + JoystickButtonPressed + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa6d46855f0253f065689b69cd09437222 + + + + JoystickButtonReleased + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa2246ef5ee33f7fa4b2a53f042ceeac3d + + + + JoystickMoved + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa4d6ad228485c135967831be16ec074dd + + + + JoystickConnected + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aaabb8877ec2f0c92904170deded09321e + + + + JoystickDisconnected + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aab6e161dab7abaf154cc1c7b554558cb6 + + + + TouchBegan + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aae6f8231ad6013d063929a09b6c28f515 + + + + TouchMoved + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa9524b7d7665212c6d56f623b5b8311a9 + + + + TouchEnded + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aabc7123492dbca320da5c03fea1a141e5 + + + + SensorChanged + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aaadf9a44c788eb9467a83c074fbf12613 + + + + Count + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aae51749211243cab2ab270b29cdc32a70 + + + + Closed + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa316e4212e083f1dce79efd8d9e9c0a95 + + + + Resized + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa67fd26d7e520bc6722db3ff47ef24941 + + + + LostFocus + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aabd7877b5011a337268357c973e8347bd + + + + GainedFocus + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa8c5003ced508499933d540df8a6023ec + + + + TextEntered + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa7e09871dc984080ff528e4f7e073e874 + + + + KeyPressed + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aac3c7abfaa98c73bfe6be0b57df09c71b + + + + KeyReleased + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aaa5bcc1e603d5a6f4c137af39558bd5d1 + + + + MouseWheelMoved + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa5cc9d3941af2a36049f4f9922c934a80 + + + + MouseWheelScrolled + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa2fb6925eb3e7f3d468faf639dbd129ad + + + + MouseButtonPressed + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa55a3dcc8bf6c40e37f9ff2cdf606481f + + + + MouseButtonReleased + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa9be69ecc07e484467ebbb133182fe5c1 + + + + MouseMoved + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa4ff4fc3b3dc857e3617a63feb54be209 + + + + MouseEntered + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa50d98590a953e74c7ccf3dabadb22067 + + + + MouseLeft + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aaa90b8526b328e0246d04b026de17c6e7 + + + + JoystickButtonPressed + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa6d46855f0253f065689b69cd09437222 + + + + JoystickButtonReleased + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa2246ef5ee33f7fa4b2a53f042ceeac3d + + + + JoystickMoved + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa4d6ad228485c135967831be16ec074dd + + + + JoystickConnected + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aaabb8877ec2f0c92904170deded09321e + + + + JoystickDisconnected + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aab6e161dab7abaf154cc1c7b554558cb6 + + + + TouchBegan + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aae6f8231ad6013d063929a09b6c28f515 + + + + TouchMoved + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aa9524b7d7665212c6d56f623b5b8311a9 + + + + TouchEnded + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aabc7123492dbca320da5c03fea1a141e5 + + + + SensorChanged + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aaadf9a44c788eb9467a83c074fbf12613 + + + + Count + classsf_1_1Event.html + af41fa9ed45c02449030699f671331d4aae51749211243cab2ab270b29cdc32a70 + + + + EventType + type + classsf_1_1Event.html + adf2f8044f713fd9d6019077b0d1ffe0a + + + + SizeEvent + size + classsf_1_1Event.html + a85dae56a377eeffd39183c3f6fc96cb9 + + + + KeyEvent + key + classsf_1_1Event.html + a45b92fc6757ca7c193f06b302e424ab0 + + + + TextEvent + text + classsf_1_1Event.html + a00c7bba6bee892791847ec22440e0a83 + + + + MouseMoveEvent + mouseMove + classsf_1_1Event.html + a786620ec4315d40c7c4cf4ddf3a1881f + + + + MouseButtonEvent + mouseButton + classsf_1_1Event.html + a20886a16ab7624de070b97145bb1dcac + + + + MouseWheelEvent + mouseWheel + classsf_1_1Event.html + a8758c6d7998757978fd9146099a02a1e + + + + MouseWheelScrollEvent + mouseWheelScroll + classsf_1_1Event.html + a5fd91c82198a31a0cd3dc93c4d1ae4c6 + + + + JoystickMoveEvent + joystickMove + classsf_1_1Event.html + ac479e8351cc2024d5c1094dc33970f7f + + + + JoystickButtonEvent + joystickButton + classsf_1_1Event.html + a42aad27a054c1c05bd5c3d020e1db174 + + + + JoystickConnectEvent + joystickConnect + classsf_1_1Event.html + aa354335c9ad73362442bc54ffe81118f + + + + TouchEvent + touch + classsf_1_1Event.html + a5f6ed8e499a4c3d171ff1baab469b2ee + + + + SensorEvent + sensor + classsf_1_1Event.html + acdeacbb321655b962e27d08eeec5a190 + + + + + sf::FileInputStream + classsf_1_1FileInputStream.html + sf::InputStream + sf::NonCopyable + + + FileInputStream + classsf_1_1FileInputStream.html + a9a321e273f41ff7f187899061fcae9be + () + + + virtual + ~FileInputStream + classsf_1_1FileInputStream.html + ad49ae2025ff2183f80067943a7d0276d + () + + + bool + open + classsf_1_1FileInputStream.html + a87a95dc3a71746097a99c86ee58bb353 + (const std::string &filename) + + + virtual Int64 + read + classsf_1_1FileInputStream.html + ad1e94c4152429f485db224c44ee1eb50 + (void *data, Int64 size) + + + virtual Int64 + seek + classsf_1_1FileInputStream.html + abdaf5700d4e1de07568e7829106b4eb9 + (Int64 position) + + + virtual Int64 + tell + classsf_1_1FileInputStream.html + a768c5fdb3be79e2d71d1bce911f8741c + () + + + virtual Int64 + getSize + classsf_1_1FileInputStream.html + aabdcaa315e088e008eeb9711ecc796e8 + () + + + + sf::Font + classsf_1_1Font.html + sf::Font::Info + + + Font + classsf_1_1Font.html + a506404655b8869ed60d1e7709812f583 + () + + + + Font + classsf_1_1Font.html + a72d7322b355ee2f1be4500f530e98081 + (const Font &copy) + + + + ~Font + classsf_1_1Font.html + aa18a3c62e6e01e9a21c531b5cad4b7f2 + () + + + bool + loadFromFile + classsf_1_1Font.html + ab020052ef4e01f6c749a85571c0f3fd1 + (const std::string &filename) + + + bool + loadFromMemory + classsf_1_1Font.html + abf2f8d6de31eb4e1db02e061c323e346 + (const void *data, std::size_t sizeInBytes) + + + bool + loadFromStream + classsf_1_1Font.html + abc3f37a354ce8b9a21f8eb93bd9fdafb + (InputStream &stream) + + + const Info & + getInfo + classsf_1_1Font.html + a86f7a72943c428cac8fa6adaaa69c722 + () const + + + const Glyph & + getGlyph + classsf_1_1Font.html + a4fa68953025b5357b5683297a3104070 + (Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness=0) const + + + bool + hasGlyph + classsf_1_1Font.html + ae577efa14d9f538208c98ded59a3f68e + (Uint32 codePoint) const + + + float + getKerning + classsf_1_1Font.html + ab357e3e0e158f1dfc454a78e111cb5d6 + (Uint32 first, Uint32 second, unsigned int characterSize, bool bold=false) const + + + float + getLineSpacing + classsf_1_1Font.html + a4538cc8af337393208a87675fe1c3e59 + (unsigned int characterSize) const + + + float + getUnderlinePosition + classsf_1_1Font.html + a726a55f40c19ac108e348b103190caad + (unsigned int characterSize) const + + + float + getUnderlineThickness + classsf_1_1Font.html + ad6d0a5bc6c026fe85c239f1f822b54e6 + (unsigned int characterSize) const + + + const Texture & + getTexture + classsf_1_1Font.html + a649982b4d0928d76a6f45b21719a6601 + (unsigned int characterSize) const + + + void + setSmooth + classsf_1_1Font.html + a77b66551a75fbaf2e831571535b774aa + (bool smooth) + + + bool + isSmooth + classsf_1_1Font.html + ae5b59162507d5dd35f3ea0ee91e322ca + () const + + + Font & + operator= + classsf_1_1Font.html + af9be4336df9121ec1b6f14fa9063e46e + (const Font &right) + + + + sf::Ftp + classsf_1_1Ftp.html + sf::NonCopyable + sf::Ftp::DirectoryResponse + sf::Ftp::ListingResponse + sf::Ftp::Response + + + TransferMode + classsf_1_1Ftp.html + a1cd6b89ad23253f6d97e6d4ca4d558cb + + + + Binary + classsf_1_1Ftp.html + a1cd6b89ad23253f6d97e6d4ca4d558cba6f253b362639fb5e059dc292762a21ee + + + + Ascii + classsf_1_1Ftp.html + a1cd6b89ad23253f6d97e6d4ca4d558cbac9e544a22dce8ef3177449cb235d15c2 + + + + Ebcdic + classsf_1_1Ftp.html + a1cd6b89ad23253f6d97e6d4ca4d558cbabb1e34435231e73c96534c71090be7f4 + + + + Binary + classsf_1_1Ftp.html + a1cd6b89ad23253f6d97e6d4ca4d558cba6f253b362639fb5e059dc292762a21ee + + + + Ascii + classsf_1_1Ftp.html + a1cd6b89ad23253f6d97e6d4ca4d558cbac9e544a22dce8ef3177449cb235d15c2 + + + + Ebcdic + classsf_1_1Ftp.html + a1cd6b89ad23253f6d97e6d4ca4d558cbabb1e34435231e73c96534c71090be7f4 + + + + + ~Ftp + classsf_1_1Ftp.html + a2edfa8e9009caf27bce74459ae76dc52 + () + + + Response + connect + classsf_1_1Ftp.html + af02fb3de3f450a50a27981961c69c860 + (const IpAddress &server, unsigned short port=21, Time timeout=Time::Zero) + + + Response + disconnect + classsf_1_1Ftp.html + acf7459926f3391cd06bf84337ed6a0f4 + () + + + Response + login + classsf_1_1Ftp.html + a686262bc377584cd50e52e1576aa3a9b + () + + + Response + login + classsf_1_1Ftp.html + a99d8114793c1659e9d51d45cecdcd965 + (const std::string &name, const std::string &password) + + + Response + keepAlive + classsf_1_1Ftp.html + aa1127d442b4acb2105aa8060a39d04fc + () + + + DirectoryResponse + getWorkingDirectory + classsf_1_1Ftp.html + a79c654fcdd0c81e68c4fa29af3b45e0c + () + + + ListingResponse + getDirectoryListing + classsf_1_1Ftp.html + a8f37258e461fcb9e2a0655e9df0be4a0 + (const std::string &directory="") + + + Response + changeDirectory + classsf_1_1Ftp.html + a7e93488ea6330dd4dd76e428da9bb6d3 + (const std::string &directory) + + + Response + parentDirectory + classsf_1_1Ftp.html + ad295cf77f30f9ad07b5c401fd9849189 + () + + + Response + createDirectory + classsf_1_1Ftp.html + a247b84c4b25da37804218c2b748c4787 + (const std::string &name) + + + Response + deleteDirectory + classsf_1_1Ftp.html + a2a8a7ef9144204b5b319c9a4be8806c2 + (const std::string &name) + + + Response + renameFile + classsf_1_1Ftp.html + a8f99251d7153e1dc26723e4006deb764 + (const std::string &file, const std::string &newName) + + + Response + deleteFile + classsf_1_1Ftp.html + a8aa272b0eb7769a850006e70fcad370f + (const std::string &name) + + + Response + download + classsf_1_1Ftp.html + a20c1600ec5fd6f5a2ad1429ab8aa5df4 + (const std::string &remoteFile, const std::string &localPath, TransferMode mode=Binary) + + + Response + upload + classsf_1_1Ftp.html + a0402d2cec27a197ffba34c88ffaddeac + (const std::string &localFile, const std::string &remotePath, TransferMode mode=Binary, bool append=false) + + + Response + sendCommand + classsf_1_1Ftp.html + a44e095103ecbce175a33eaf0820440ff + (const std::string &command, const std::string &parameter="") + + + + sf::GlResource + classsf_1_1GlResource.html + sf::GlResource::TransientContextLock + + + GlResource + classsf_1_1GlResource.html + ad8fb7a0674f0f77e530dacc2a3b0dc6a + () + + + + ~GlResource + classsf_1_1GlResource.html + ab99035b67052331d1e8cf67abd93de98 + () + + + static void + registerContextDestroyCallback + classsf_1_1GlResource.html + ab171bdaf5eb36789da14b30a846db471 + (ContextDestroyCallback callback, void *arg) + + + + sf::Glyph + classsf_1_1Glyph.html + + + Glyph + classsf_1_1Glyph.html + ab15cfc37eb7b40a94b3b3aedf934010b + () + + + float + advance + classsf_1_1Glyph.html + aeac19b97ec11409147191606b784deda + + + + int + lsbDelta + classsf_1_1Glyph.html + ab82761e8995ebd05c03d47ff0e064100 + + + + int + rsbDelta + classsf_1_1Glyph.html + affcf288079ac470f2d88765bbfef93fa + + + + FloatRect + bounds + classsf_1_1Glyph.html + a6f3c892093167914adc31e52e5923f4b + + + + IntRect + textureRect + classsf_1_1Glyph.html + a0d502d326449f8c49011ed91d2805f5b + + + + + sf::Http + classsf_1_1Http.html + sf::NonCopyable + sf::Http::Request + sf::Http::Response + + + Http + classsf_1_1Http.html + abe2360194f99bdde402c9f97a85cf067 + () + + + + Http + classsf_1_1Http.html + a79efd844a735f083fcce0edbf1092385 + (const std::string &host, unsigned short port=0) + + + void + setHost + classsf_1_1Http.html + a55121d543b61c41cf20b885a97b04e65 + (const std::string &host, unsigned short port=0) + + + Response + sendRequest + classsf_1_1Http.html + aaf09ebfb5e00dcc82e0d494d5c6a9e2a + (const Request &request, Time timeout=Time::Zero) + + + + sf::Joystick::Identification + structsf_1_1Joystick_1_1Identification.html + + String + name + structsf_1_1Joystick_1_1Identification.html + a135a9a3a4dc11c2b5cde51159b4d136d + + + + unsigned int + vendorId + structsf_1_1Joystick_1_1Identification.html + a827caf37a56492e3430e5ca6b15b5e9f + + + + unsigned int + productId + structsf_1_1Joystick_1_1Identification.html + a18c21317789f51f9a5f132677727ff77 + + + + + sf::Image + classsf_1_1Image.html + + + Image + classsf_1_1Image.html + abb4caf3cb167b613345ebe36fc883f12 + () + + + + ~Image + classsf_1_1Image.html + a0ba22a38e6c96e3b37dd88198046de83 + () + + + void + create + classsf_1_1Image.html + a2a67930e2fd9ad97cf004e918cf5832b + (unsigned int width, unsigned int height, const Color &color=Color(0, 0, 0)) + + + void + create + classsf_1_1Image.html + a1c2b960ea12bdbb29e80934ce5268ebf + (unsigned int width, unsigned int height, const Uint8 *pixels) + + + bool + loadFromFile + classsf_1_1Image.html + a9e4f2aa8e36d0cabde5ed5a4ef80290b + (const std::string &filename) + + + bool + loadFromMemory + classsf_1_1Image.html + aaa6c7afa5851a51cec6ab438faa7354c + (const void *data, std::size_t size) + + + bool + loadFromStream + classsf_1_1Image.html + a21122ded0e8368bb06ed3b9acfbfb501 + (InputStream &stream) + + + bool + saveToFile + classsf_1_1Image.html + a51537fb667f47cbe80395cfd7f9e72a4 + (const std::string &filename) const + + + bool + saveToMemory + classsf_1_1Image.html + ae33432a31031ee501674efa9b6dc3f40 + (std::vector< sf::Uint8 > &output, const std::string &format) const + + + Vector2u + getSize + classsf_1_1Image.html + a85409951b05369813069ed64393391ce + () const + + + void + createMaskFromColor + classsf_1_1Image.html + a22f13f8c242a6b38eb73cc176b37ae34 + (const Color &color, Uint8 alpha=0) + + + void + copy + classsf_1_1Image.html + ab2fa337c956f85f93377dcb52153a45a + (const Image &source, unsigned int destX, unsigned int destY, const IntRect &sourceRect=IntRect(0, 0, 0, 0), bool applyAlpha=false) + + + void + setPixel + classsf_1_1Image.html + a9fd329b8cd7d4439e07fb5d3bb2d9744 + (unsigned int x, unsigned int y, const Color &color) + + + Color + getPixel + classsf_1_1Image.html + acf278760458433b2c3626a6980388a95 + (unsigned int x, unsigned int y) const + + + const Uint8 * + getPixelsPtr + classsf_1_1Image.html + a2f49e69b6c6257b19b4d911993075c40 + () const + + + void + flipHorizontally + classsf_1_1Image.html + a57168e7bc29190e08bbd6c9c19f4bb2c + () + + + void + flipVertically + classsf_1_1Image.html + a78a702a7e49d1de2dec9894da99d279c + () + + + + sf::Font::Info + structsf_1_1Font_1_1Info.html + + std::string + family + structsf_1_1Font_1_1Info.html + a008413b4b6cf621eb92668a11098a519 + + + + + sf::SoundFileReader::Info + structsf_1_1SoundFileReader_1_1Info.html + + Uint64 + sampleCount + structsf_1_1SoundFileReader_1_1Info.html + a74b40b4693d7000571484736d1367167 + + + + unsigned int + channelCount + structsf_1_1SoundFileReader_1_1Info.html + ac748bb30768d1a3caf329e95d31d6d2a + + + + unsigned int + sampleRate + structsf_1_1SoundFileReader_1_1Info.html + a06ef71c19e7de190b294ae02c361f752 + + + + + sf::InputSoundFile + classsf_1_1InputSoundFile.html + sf::NonCopyable + + + InputSoundFile + classsf_1_1InputSoundFile.html + a3b95347de25d1d93a3230287cf47a077 + () + + + + ~InputSoundFile + classsf_1_1InputSoundFile.html + a326a1a486587038123de0c187bf5c635 + () + + + bool + openFromFile + classsf_1_1InputSoundFile.html + af68e54bc9bfac19554c84601156fe93f + (const std::string &filename) + + + bool + openFromMemory + classsf_1_1InputSoundFile.html + a4e034a8e9e69ca3c33a3f11180250400 + (const void *data, std::size_t sizeInBytes) + + + bool + openFromStream + classsf_1_1InputSoundFile.html + a32b76497aeb088a2b46dc6efd819b909 + (InputStream &stream) + + + Uint64 + getSampleCount + classsf_1_1InputSoundFile.html + a665b7fed6cdca3e0c622909e5a6655e4 + () const + + + unsigned int + getChannelCount + classsf_1_1InputSoundFile.html + a54307c308ba05dea63aba54a29c804a4 + () const + + + unsigned int + getSampleRate + classsf_1_1InputSoundFile.html + a6b8177e40dd8020752f6d52f96b774c3 + () const + + + Time + getDuration + classsf_1_1InputSoundFile.html + aa081bd4d9732408d10b48227a360778e + () const + + + Time + getTimeOffset + classsf_1_1InputSoundFile.html + ad1a2238acb734d8b1144ecd75cccc2e7 + () const + + + Uint64 + getSampleOffset + classsf_1_1InputSoundFile.html + a73a99f159e8aca6e39478f6cf686d7ad + () const + + + void + seek + classsf_1_1InputSoundFile.html + aaf97be15020a42e159ff88f76f22af20 + (Uint64 sampleOffset) + + + void + seek + classsf_1_1InputSoundFile.html + a8eee7af58ad75ddc61f93ad72e2d66c1 + (Time timeOffset) + + + Uint64 + read + classsf_1_1InputSoundFile.html + a83d6f64617456601edeb0daf9d14a17f + (Int16 *samples, Uint64 maxCount) + + + void + close + classsf_1_1InputSoundFile.html + ad28182aea9dc9f7d0dfc7f78691825b4 + () + + + + sf::InputStream + classsf_1_1InputStream.html + + virtual + ~InputStream + classsf_1_1InputStream.html + a4b2eb0f92323e630bd0542bc6191682e + () + + + virtual Int64 + read + classsf_1_1InputStream.html + a8dd89c74c1acb693203f50e750c6ae53 + (void *data, Int64 size)=0 + + + virtual Int64 + seek + classsf_1_1InputStream.html + a76aba8e5d5cf9b1c5902d5e04f7864fc + (Int64 position)=0 + + + virtual Int64 + tell + classsf_1_1InputStream.html + a599515b9ccdbddb6fef5a98424fd559c + ()=0 + + + virtual Int64 + getSize + classsf_1_1InputStream.html + a311eaaaa65d636728e5153b574b72d5d + ()=0 + + + + sf::IpAddress + classsf_1_1IpAddress.html + + + IpAddress + classsf_1_1IpAddress.html + af32a0574baa0f46e48deb2d83ca7658b + () + + + + IpAddress + classsf_1_1IpAddress.html + a656b7445ab04cabaa7398685bc09c3f7 + (const std::string &address) + + + + IpAddress + classsf_1_1IpAddress.html + a92f2a9be74334a61b96c2fc79fe6eb78 + (const char *address) + + + + IpAddress + classsf_1_1IpAddress.html + a1d289dcb9ce7a64c600c6f84cba88cc6 + (Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3) + + + + IpAddress + classsf_1_1IpAddress.html + a8ed34ba3a40d70eb9f09ac5ae779a162 + (Uint32 address) + + + std::string + toString + classsf_1_1IpAddress.html + a88507954142d7fc2176cce7f36422340 + () const + + + Uint32 + toInteger + classsf_1_1IpAddress.html + ae7911c5ea9562f9602c3e29cd54b15e9 + () const + + + static IpAddress + getLocalAddress + classsf_1_1IpAddress.html + a4c31622ad87edca48adbb8e8ed00ee4a + () + + + static IpAddress + getPublicAddress + classsf_1_1IpAddress.html + a5c5cbf67e4aacf23c24f2ad991df4c55 + (Time timeout=Time::Zero) + + + static const IpAddress + None + classsf_1_1IpAddress.html + a4619b4abbe3c8fef056e7299db967404 + + + + static const IpAddress + Any + classsf_1_1IpAddress.html + a3dbc10b0dc6804cc69e29342f7406907 + + + + static const IpAddress + LocalHost + classsf_1_1IpAddress.html + a594d3a8e2559f8fa8ab0a96fa597333b + + + + static const IpAddress + Broadcast + classsf_1_1IpAddress.html + aa93d1d57b65d243f2baf804b6035465c + + + + friend bool + operator< + classsf_1_1IpAddress.html + a4886da3f195b8c30d415a94a7009fdd7 + (const IpAddress &left, const IpAddress &right) + + + + sf::Joystick + classsf_1_1Joystick.html + sf::Joystick::Identification + + Count + classsf_1_1Joystick.html + aee00dd432eacd8369d279b47c3ab4cc5a6e0a2a95bc1da277610c04d80f52715e + + + + ButtonCount + classsf_1_1Joystick.html + aee00dd432eacd8369d279b47c3ab4cc5a2f1b8a0a59f2c12a4775c0e1e69e1816 + + + + AxisCount + classsf_1_1Joystick.html + aee00dd432eacd8369d279b47c3ab4cc5accf3e487c9f6ee2f384351323626a42c + + + + + Axis + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7 + + + + X + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a95dc8b9bf7b0a2157fc67891c54c401e + + + + Y + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a51ef1455f7511ad4a78ba241d66593ce + + + + Z + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a7c37a1240b2dafbbfc5c1a0e23911315 + + + + R + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7aeebbcdb0828850f4d69e6a084801fab8 + + + + U + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a0a901f61e75292dd2f642b6e4f33a214 + + + + V + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7aa2e2c8ffa1837e7911ee0c7d045bf8f4 + + + + PovX + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a06420f7714e4dfd8b841885a0b5f3954 + + + + PovY + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a0f8ffb2dcddf91b98ab910a4f8327ad9 + + + + Count + classsf_1_1Joystick.html + aee00dd432eacd8369d279b47c3ab4cc5a6e0a2a95bc1da277610c04d80f52715e + + + + ButtonCount + classsf_1_1Joystick.html + aee00dd432eacd8369d279b47c3ab4cc5a2f1b8a0a59f2c12a4775c0e1e69e1816 + + + + AxisCount + classsf_1_1Joystick.html + aee00dd432eacd8369d279b47c3ab4cc5accf3e487c9f6ee2f384351323626a42c + + + + X + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a95dc8b9bf7b0a2157fc67891c54c401e + + + + Y + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a51ef1455f7511ad4a78ba241d66593ce + + + + Z + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a7c37a1240b2dafbbfc5c1a0e23911315 + + + + R + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7aeebbcdb0828850f4d69e6a084801fab8 + + + + U + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a0a901f61e75292dd2f642b6e4f33a214 + + + + V + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7aa2e2c8ffa1837e7911ee0c7d045bf8f4 + + + + PovX + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a06420f7714e4dfd8b841885a0b5f3954 + + + + PovY + classsf_1_1Joystick.html + a48db337092c2e263774f94de6d50baa7a0f8ffb2dcddf91b98ab910a4f8327ad9 + + + + static bool + isConnected + classsf_1_1Joystick.html + ac7d4e1923e9f9420174f26703ea63d6c + (unsigned int joystick) + + + static unsigned int + getButtonCount + classsf_1_1Joystick.html + a4de9f445c6582bfe9f0873f695682885 + (unsigned int joystick) + + + static bool + hasAxis + classsf_1_1Joystick.html + a268e8f2a11ae6af4a47c727cb4ab4d95 + (unsigned int joystick, Axis axis) + + + static bool + isButtonPressed + classsf_1_1Joystick.html + ae0d97a4b84268cbe6a7078e1b2717835 + (unsigned int joystick, unsigned int button) + + + static float + getAxisPosition + classsf_1_1Joystick.html + aea4930193331df1851b709f3060ba58b + (unsigned int joystick, Axis axis) + + + static Identification + getIdentification + classsf_1_1Joystick.html + aa917c9435330e6e0368d3893672d1b74 + (unsigned int joystick) + + + static void + update + classsf_1_1Joystick.html + ab85fa9175b4edd3e5a07ee3cde0b0f48 + () + + + + sf::Event::JoystickButtonEvent + structsf_1_1Event_1_1JoystickButtonEvent.html + + unsigned int + joystickId + structsf_1_1Event_1_1JoystickButtonEvent.html + a2f80ecdb964a5ae0fc30726a404c41ec + + + + unsigned int + button + structsf_1_1Event_1_1JoystickButtonEvent.html + a6412e698a2f7904c5aa875a0d1b34da4 + + + + + sf::Event::JoystickConnectEvent + structsf_1_1Event_1_1JoystickConnectEvent.html + + unsigned int + joystickId + structsf_1_1Event_1_1JoystickConnectEvent.html + a08e58e8559d3e4fe4654855fec79194b + + + + + sf::Event::JoystickMoveEvent + structsf_1_1Event_1_1JoystickMoveEvent.html + + unsigned int + joystickId + structsf_1_1Event_1_1JoystickMoveEvent.html + a7bf2b2f2941a21ed26a67c95f5e4232f + + + + Joystick::Axis + axis + structsf_1_1Event_1_1JoystickMoveEvent.html + add22e8126b7974271991dc6380cbdee3 + + + + float + position + structsf_1_1Event_1_1JoystickMoveEvent.html + aba5a70815420161375fd2e756689c32a + + + + + sf::Keyboard + classsf_1_1Keyboard.html + sf::Keyboard::Scan + + + Key + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142 + + + + Unknown + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a840c43fa8e05ff854f6fe9a86c7c939e + + + + A + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a9d06fa7ac9af597034ea724fb08b991e + + + + B + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aca3142235e5c4199f0b8b45d8368ef94 + + + + C + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a0d586c4ec0cd6b537cb6f49180fedecc + + + + D + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ae778600bd3e878b59df1dbdd5877ba7a + + + + E + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a0e027c08438a8bf77e2e1e5d5d75bd84 + + + + F + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab8021fbbe5483bc98f124df6f7090002 + + + + G + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aafb9e3d7679d88d86afc608d79c251f7 + + + + H + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142adfa19328304890e17f4a3f4263eed04d + + + + I + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142abaef09665b4d94ebbed50345cab3981e + + + + J + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a948c634009beacdab42c3419253a5e85 + + + + K + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a25beb62393ff666a4bec18ea2a66f3f2 + + + + L + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a5ef1839ffe19b7e9c24f2ca017614ff9 + + + + M + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a9718de9940f723c956587dcb90450a0a + + + + N + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab652ed6b308db95a74dc4ff5229ac9c8 + + + + O + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a7739288cc628dfa8c50ba712be7c03e1 + + + + P + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aaeac1db209a64a0221277a835de986e6 + + + + Q + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a27e3d50587c9789d2592d275d22fbada + + + + R + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142add852cadaa6fff2d982bbab3551c31d0 + + + + S + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aca13014bf9ed5887d347060a0334ea5a + + + + T + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a19f59109111fc5271d3581bcd0c43187 + + + + U + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab4f30ae34848ee934dd4f5496a8fb4a1 + + + + V + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aec9074abd2d41628d1ecdc14e1b2cd96 + + + + W + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a258aa89e9c6c9aad1ccbaeb41839c5e0 + + + + X + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a012f5ee9d518e9e24caa087fbddc0594 + + + + Y + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a5d877e63d1353e0fc0a0757a87a7bd0e + + + + Z + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a4e12efd6478a2d174264f29b0b41ab43 + + + + Num0 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af026fd133ee93a0bd8c70762cc3be4bc + + + + Num1 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a506bd962cab80722a8c5a4b178912c59 + + + + Num2 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a2d6eb5118179bb140fdb3485bb08c182 + + + + Num3 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aee78e5ed27d31598fc285400166c0dd5 + + + + Num4 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a5fbd8a089460dc33c22f68b36e1fdc98 + + + + Num5 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a1dc7e87810b8d4b7039e202b0adcc4ee + + + + Num6 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af86dafb69d922ad2b0f4bd4c37696575 + + + + Num7 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a8fa0056a0a6f5a7d9fcef3402c9c916d + + + + Num8 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142adb9f2549fd57bfd99d4713ff1845c530 + + + + Num9 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a9bc0d0727958bef97e2b6a58e23743db + + + + Escape + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a64b7ecb543c5d03bec8383dde123c95d + + + + LControl + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142acc76c9dec76d8ae806ae9d6515066e53 + + + + LShift + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a270db49f76cb4dbe72da36153d3aa45c + + + + LAlt + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a000ecf5145296d7d52b6871c54e6718d + + + + LSystem + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a718171426307a0f5f26b4ae82a322b24 + + + + RControl + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a275d3fd207a9c0b22ce404012c71dc17 + + + + RShift + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a5be69e3b2f25bd5f4eed75d063f42b90 + + + + RAlt + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a21dcf098233296462bc7c632b93369cc + + + + RSystem + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac1b3fd7424feeda242cedbb64f3f5a7f + + + + Menu + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a4aac50ce7c4923f96323fe84d592b139 + + + + LBracket + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142afbe21cad5f264d685cf7f25060004184 + + + + RBracket + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a578253a70b48e61830aa08292d44680f + + + + Semicolon + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab50635b9c913837d1bd4453eec7cb506 + + + + Comma + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab7374f48cc79e3085739160b8e3ef2f9 + + + + Period + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac72ba959ab1946957e8dfd4f81ea811d + + + + Apostrophe + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a77b44e1f040360d71126fa1c4ad12bec + + + + Slash + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a7424bf901434a587a6c202c423e6786c + + + + Backslash + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142adbd7d6f90a1009e91acf7bb1dc068512 + + + + Grave + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a2da2429e6db8efbf923151f00a9b21e0 + + + + Equal + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ae55c35f6b6417e1dbbfa351c64dfc743 + + + + Hyphen + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a5bde2cf47e6182e6f45d0d2197223c35 + + + + Space + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a6fdaa93b6b8d1a2b73bc239e9ada94ef + + + + Enter + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a59e26db0965305492875d7da68f6a990 + + + + Backspace + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aa7c1581bac0f20164512572e6c60e98e + + + + Tab + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a20c552c39c8356b1078f1cfff7936b4a + + + + PageUp + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aa24fe33bba1c3639c3aeaa317bd89d7e + + + + PageDown + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a21c73323d9a8b6017f3bac0cb8c8ac1a + + + + End + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a4478343b2b7efc310f995fd4251a264d + + + + Home + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af41ae7c3927cc5ea8b43ee2fefe890e8 + + + + Insert + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a616c8cae362d229155c5c6e10b969943 + + + + Delete + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab66187002fc7f6695ef3d05237b93a38 + + + + Add + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a158c586cbe8609031d1a7932e1a8dba2 + + + + Subtract + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a68983f67bd30d27b27c90d6794c78aa2 + + + + Multiply + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a10623ae71db8a6b5d97189fc21fb91ae + + + + Divide + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142afae3dc28752954f0bfe298ac52f58cb6 + + + + Left + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac3fe5df11d15b57317c053a2ae13d9a9 + + + + Right + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a2aeb083dea103a8e36b6850b51ef3632 + + + + Up + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac4cf6ef2d2632445e9e26c8f2b70e82d + + + + Down + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a33dd676edbdf0817d7a65b21df3d0dca + + + + Numpad0 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af0b2af83a7a8c358f7b8f7c403089a4e + + + + Numpad1 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a03536d369ae55cc18024f7e4a341a5ac + + + + Numpad2 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a8ad9ccf62631d583f44f06aebd662093 + + + + Numpad3 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab63ae26e90126b1842bde25d6dedb205 + + + + Numpad4 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a65336d823bd823a0d246a872ff90e08a + + + + Numpad5 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a8bc5041f12fdfbefba1dbd823c7e1054 + + + + Numpad6 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aaf28fdf0d3da6a18030e685478e3a713 + + + + Numpad7 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a3f9bf9835d65a0df5cce2d3842a40541 + + + + Numpad8 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a25dcd4e4183ceceb3ac06c72995bae49 + + + + Numpad9 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a365eb80f54003670a78e3b850c28df21 + + + + F1 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ae59c7e28858e970c9d4f0e418179b632 + + + + F2 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a6a2faa5f876a1e75f24a596b658ff413 + + + + F3 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a1fb58d66f9c0183db3e70b2b0576074e + + + + F4 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a71311e21238cf2c0df1bbf096bba68f2 + + + + F5 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a01fd2f93eddf2887186ea91180a789a8 + + + + F6 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac756a19b31eb28cd2c35c29d8e54ea04 + + + + F7 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a060d30d36a3e08208b2bc46d0f549b6c + + + + F8 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ade468cd27716b9c2a0d0158afa2f8621 + + + + F9 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a3c5c2342003a7191de6636b5ef44e1b9 + + + + F10 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aec695ecf296e7084a8f7f3ec408e16ac + + + + F11 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af9a8de90d90a7a7582269bc5c41f5afd + + + + F12 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af9d8807117d946de5e403bcbd4d7161d + + + + F13 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a9e28e971941ca2900c1eea17cda50a04 + + + + F14 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a9a0327a4ef876338d5f3c34c514f190c + + + + F15 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a8949ce79077cc8bf64f4fa42bb6a2808 + + + + Pause + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a95daf340fcc3d5c2846f69d184170d9b + + + + KeyCount + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a93e6ffa0320fe9b2f29aec14a58be36b + + + + Tilde + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a90be0882086bccb516e3afc5c7fb82eb + + + + Dash + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a401a183dcfde0a06cb60fe6c91fa1e39 + + + + BackSpace + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a33aeaab900abcd01eebf2fcc4f6d97e2 + + + + BackSlash + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a536df84e73859aa44e11e192459470b6 + + + + SemiColon + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a460ab09a36f9ed230504b89b9815de88 + + + + Return + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac291de81bdee518d636bc359f2ca77de + + + + Quote + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af031edb6bcf319734a6664388958c475 + + + + Unknown + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a840c43fa8e05ff854f6fe9a86c7c939e + + + + A + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a9d06fa7ac9af597034ea724fb08b991e + + + + B + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aca3142235e5c4199f0b8b45d8368ef94 + + + + C + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a0d586c4ec0cd6b537cb6f49180fedecc + + + + D + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ae778600bd3e878b59df1dbdd5877ba7a + + + + E + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a0e027c08438a8bf77e2e1e5d5d75bd84 + + + + F + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab8021fbbe5483bc98f124df6f7090002 + + + + G + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aafb9e3d7679d88d86afc608d79c251f7 + + + + H + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142adfa19328304890e17f4a3f4263eed04d + + + + I + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142abaef09665b4d94ebbed50345cab3981e + + + + J + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a948c634009beacdab42c3419253a5e85 + + + + K + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a25beb62393ff666a4bec18ea2a66f3f2 + + + + L + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a5ef1839ffe19b7e9c24f2ca017614ff9 + + + + M + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a9718de9940f723c956587dcb90450a0a + + + + N + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab652ed6b308db95a74dc4ff5229ac9c8 + + + + O + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a7739288cc628dfa8c50ba712be7c03e1 + + + + P + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aaeac1db209a64a0221277a835de986e6 + + + + Q + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a27e3d50587c9789d2592d275d22fbada + + + + R + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142add852cadaa6fff2d982bbab3551c31d0 + + + + S + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aca13014bf9ed5887d347060a0334ea5a + + + + T + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a19f59109111fc5271d3581bcd0c43187 + + + + U + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab4f30ae34848ee934dd4f5496a8fb4a1 + + + + V + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aec9074abd2d41628d1ecdc14e1b2cd96 + + + + W + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a258aa89e9c6c9aad1ccbaeb41839c5e0 + + + + X + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a012f5ee9d518e9e24caa087fbddc0594 + + + + Y + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a5d877e63d1353e0fc0a0757a87a7bd0e + + + + Z + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a4e12efd6478a2d174264f29b0b41ab43 + + + + Num0 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af026fd133ee93a0bd8c70762cc3be4bc + + + + Num1 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a506bd962cab80722a8c5a4b178912c59 + + + + Num2 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a2d6eb5118179bb140fdb3485bb08c182 + + + + Num3 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aee78e5ed27d31598fc285400166c0dd5 + + + + Num4 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a5fbd8a089460dc33c22f68b36e1fdc98 + + + + Num5 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a1dc7e87810b8d4b7039e202b0adcc4ee + + + + Num6 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af86dafb69d922ad2b0f4bd4c37696575 + + + + Num7 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a8fa0056a0a6f5a7d9fcef3402c9c916d + + + + Num8 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142adb9f2549fd57bfd99d4713ff1845c530 + + + + Num9 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a9bc0d0727958bef97e2b6a58e23743db + + + + Escape + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a64b7ecb543c5d03bec8383dde123c95d + + + + LControl + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142acc76c9dec76d8ae806ae9d6515066e53 + + + + LShift + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a270db49f76cb4dbe72da36153d3aa45c + + + + LAlt + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a000ecf5145296d7d52b6871c54e6718d + + + + LSystem + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a718171426307a0f5f26b4ae82a322b24 + + + + RControl + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a275d3fd207a9c0b22ce404012c71dc17 + + + + RShift + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a5be69e3b2f25bd5f4eed75d063f42b90 + + + + RAlt + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a21dcf098233296462bc7c632b93369cc + + + + RSystem + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac1b3fd7424feeda242cedbb64f3f5a7f + + + + Menu + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a4aac50ce7c4923f96323fe84d592b139 + + + + LBracket + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142afbe21cad5f264d685cf7f25060004184 + + + + RBracket + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a578253a70b48e61830aa08292d44680f + + + + Semicolon + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab50635b9c913837d1bd4453eec7cb506 + + + + Comma + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab7374f48cc79e3085739160b8e3ef2f9 + + + + Period + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac72ba959ab1946957e8dfd4f81ea811d + + + + Apostrophe + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a77b44e1f040360d71126fa1c4ad12bec + + + + Slash + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a7424bf901434a587a6c202c423e6786c + + + + Backslash + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142adbd7d6f90a1009e91acf7bb1dc068512 + + + + Grave + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a2da2429e6db8efbf923151f00a9b21e0 + + + + Equal + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ae55c35f6b6417e1dbbfa351c64dfc743 + + + + Hyphen + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a5bde2cf47e6182e6f45d0d2197223c35 + + + + Space + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a6fdaa93b6b8d1a2b73bc239e9ada94ef + + + + Enter + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a59e26db0965305492875d7da68f6a990 + + + + Backspace + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aa7c1581bac0f20164512572e6c60e98e + + + + Tab + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a20c552c39c8356b1078f1cfff7936b4a + + + + PageUp + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aa24fe33bba1c3639c3aeaa317bd89d7e + + + + PageDown + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a21c73323d9a8b6017f3bac0cb8c8ac1a + + + + End + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a4478343b2b7efc310f995fd4251a264d + + + + Home + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af41ae7c3927cc5ea8b43ee2fefe890e8 + + + + Insert + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a616c8cae362d229155c5c6e10b969943 + + + + Delete + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab66187002fc7f6695ef3d05237b93a38 + + + + Add + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a158c586cbe8609031d1a7932e1a8dba2 + + + + Subtract + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a68983f67bd30d27b27c90d6794c78aa2 + + + + Multiply + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a10623ae71db8a6b5d97189fc21fb91ae + + + + Divide + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142afae3dc28752954f0bfe298ac52f58cb6 + + + + Left + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac3fe5df11d15b57317c053a2ae13d9a9 + + + + Right + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a2aeb083dea103a8e36b6850b51ef3632 + + + + Up + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac4cf6ef2d2632445e9e26c8f2b70e82d + + + + Down + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a33dd676edbdf0817d7a65b21df3d0dca + + + + Numpad0 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af0b2af83a7a8c358f7b8f7c403089a4e + + + + Numpad1 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a03536d369ae55cc18024f7e4a341a5ac + + + + Numpad2 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a8ad9ccf62631d583f44f06aebd662093 + + + + Numpad3 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ab63ae26e90126b1842bde25d6dedb205 + + + + Numpad4 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a65336d823bd823a0d246a872ff90e08a + + + + Numpad5 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a8bc5041f12fdfbefba1dbd823c7e1054 + + + + Numpad6 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aaf28fdf0d3da6a18030e685478e3a713 + + + + Numpad7 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a3f9bf9835d65a0df5cce2d3842a40541 + + + + Numpad8 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a25dcd4e4183ceceb3ac06c72995bae49 + + + + Numpad9 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a365eb80f54003670a78e3b850c28df21 + + + + F1 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ae59c7e28858e970c9d4f0e418179b632 + + + + F2 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a6a2faa5f876a1e75f24a596b658ff413 + + + + F3 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a1fb58d66f9c0183db3e70b2b0576074e + + + + F4 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a71311e21238cf2c0df1bbf096bba68f2 + + + + F5 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a01fd2f93eddf2887186ea91180a789a8 + + + + F6 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac756a19b31eb28cd2c35c29d8e54ea04 + + + + F7 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a060d30d36a3e08208b2bc46d0f549b6c + + + + F8 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ade468cd27716b9c2a0d0158afa2f8621 + + + + F9 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a3c5c2342003a7191de6636b5ef44e1b9 + + + + F10 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142aec695ecf296e7084a8f7f3ec408e16ac + + + + F11 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af9a8de90d90a7a7582269bc5c41f5afd + + + + F12 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af9d8807117d946de5e403bcbd4d7161d + + + + F13 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a9e28e971941ca2900c1eea17cda50a04 + + + + F14 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a9a0327a4ef876338d5f3c34c514f190c + + + + F15 + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a8949ce79077cc8bf64f4fa42bb6a2808 + + + + Pause + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a95daf340fcc3d5c2846f69d184170d9b + + + + KeyCount + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a93e6ffa0320fe9b2f29aec14a58be36b + + + + Tilde + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a90be0882086bccb516e3afc5c7fb82eb + + + + Dash + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a401a183dcfde0a06cb60fe6c91fa1e39 + + + + BackSpace + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a33aeaab900abcd01eebf2fcc4f6d97e2 + + + + BackSlash + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a536df84e73859aa44e11e192459470b6 + + + + SemiColon + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142a460ab09a36f9ed230504b89b9815de88 + + + + Return + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142ac291de81bdee518d636bc359f2ca77de + + + + Quote + classsf_1_1Keyboard.html + acb4cacd7cc5802dec45724cf3314a142af031edb6bcf319734a6664388958c475 + + + + static bool + isKeyPressed + classsf_1_1Keyboard.html + a80a04b2f53005886957f49eee3531599 + (Key key) + + + static bool + isKeyPressed + classsf_1_1Keyboard.html + a8364065ca899275ce3e9314cce98ed3e + (Scancode code) + + + static Key + localize + classsf_1_1Keyboard.html + a4f77c97de21fbb14b9df79e320b12d9a + (Scancode code) + + + static Scancode + delocalize + classsf_1_1Keyboard.html + af9fd530c73b8a2cd6094d373e879eb00 + (Key key) + + + static String + getDescription + classsf_1_1Keyboard.html + aab9652b25d81d6526b72bdc876d92d41 + (Scancode code) + + + static void + setVirtualKeyboardVisible + classsf_1_1Keyboard.html + ad61fee7e793242d444a8c5acd662fe5b + (bool visible) + + + + sf::Event::KeyEvent + structsf_1_1Event_1_1KeyEvent.html + + Keyboard::Key + code + structsf_1_1Event_1_1KeyEvent.html + a2879fdab8a68cb1c6ecc45730a2d0e61 + + + + Keyboard::Scancode + scancode + structsf_1_1Event_1_1KeyEvent.html + a182706c1c75e73c8fb85b796d1095ae1 + + + + bool + alt + structsf_1_1Event_1_1KeyEvent.html + a915a483317de67d995188a855701fbd7 + + + + bool + control + structsf_1_1Event_1_1KeyEvent.html + a9255861c2f88501d80ad6b44a310b62f + + + + bool + shift + structsf_1_1Event_1_1KeyEvent.html + a776af1a3ca79abeeec18ebf1c0065aa9 + + + + bool + system + structsf_1_1Event_1_1KeyEvent.html + ac0557f7edc2a608ec65175fdd843afc5 + + + + + sf::Listener + classsf_1_1Listener.html + + static void + setGlobalVolume + classsf_1_1Listener.html + a803a24a1fc04620cacc9f88c6fbc0e3a + (float volume) + + + static float + getGlobalVolume + classsf_1_1Listener.html + a137ea535799bdf70be6ec969673d4d33 + () + + + static void + setPosition + classsf_1_1Listener.html + a5bc2d8d18ea2d8f339d23cbf17678564 + (float x, float y, float z) + + + static void + setPosition + classsf_1_1Listener.html + a28a27d85cfbf8065c535c39176898fcb + (const Vector3f &position) + + + static Vector3f + getPosition + classsf_1_1Listener.html + acd7ee65bc948ca38e1c669aa12340c54 + () + + + static void + setDirection + classsf_1_1Listener.html + ae479dc15513c6557984d26e32d06d06e + (float x, float y, float z) + + + static void + setDirection + classsf_1_1Listener.html + a1d99d9457c6ddad93449ecb4f504c2bf + (const Vector3f &direction) + + + static Vector3f + getDirection + classsf_1_1Listener.html + a54e91baba51d4431474f53ff7f9309f9 + () + + + static void + setUpVector + classsf_1_1Listener.html + a0ea9b3083a994b2b90253543bc4e3ad6 + (float x, float y, float z) + + + static void + setUpVector + classsf_1_1Listener.html + a281e8cd44d3411d891b5e83b0cb6b9d4 + (const Vector3f &upVector) + + + static Vector3f + getUpVector + classsf_1_1Listener.html + ae1427dd7e9b425b0c23b7b766bd6c6e6 + () + + + + sf::Ftp::ListingResponse + classsf_1_1Ftp_1_1ListingResponse.html + sf::Ftp::Response + + + Status + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3b + + + + RestartMarkerReply + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba07e06d3326ba2d078583bef93930d909 + + + + ServiceReadySoon + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba22413357ade6b586f6ceb0d704f35075 + + + + DataConnectionAlreadyOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafa52d19bc813d69055f4cc390d4a76ca + + + + OpeningDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba794ebe743688be611447638bf9e49d86 + + + + Ok + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baa956e229ba6c0cdf0d88b0e05b286210 + + + + PointlessCommand + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba38adc424f1adcd332745de8cd3b7737a + + + + SystemStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9bdd02ae119b8be639e778859ee74060 + + + + DirectoryStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8729460a695013cc96330e2fced0ae1f + + + + FileStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baebddfc7997dca289c83068dff3f47dce + + + + HelpMessage + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba840fd2a1872fd4310b046541f57fdeb7 + + + + SystemType + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba78391f73aa11f07f1514c7d070b93c08 + + + + ServiceReady + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baea2ee2007d7843c21108bb686ef03757 + + + + ClosingConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bab23931490fc2d1df3081d651fe0f4d6e + + + + DataConnectionOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3badc78ed87d5bddb174fa3c16707ac2f2d + + + + ClosingDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bac723ebc8a38913bbf0d9504556cbaaa6 + + + + EnteringPassiveMode + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba48314fc47a72ad0aacdea93b91756f6e + + + + LoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba54a88210386cb72e35d737813a221754 + + + + FileActionOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf988b69b0a5f55f8122da5ba001932e0 + + + + DirectoryOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba06d26e95a170fc422af13def415e0437 + + + + NeedPassword + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9249e3fe9818eb93f181fbbf3ae3bc56 + + + + NeedAccountToLogIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9e048185f253f6eb6f5ff9e063b712fa + + + + NeedInformation + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba02e6f05964ecb829e9b6fb6020d6528a + + + + ServiceUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba43022ddf49b68a4f5aff0bea7e09e89f + + + + DataConnectionUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba757b89ff1f236941f7759b0ed0c28b88 + + + + TransferAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba7cfefcc586c12ba70f752353fde7126e + + + + FileActionAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf822d1b0abf3e9ae7dd44684549d512d + + + + LocalError + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bae54e84baaca95a7b36271ca3f3fdb900 + + + + InsufficientStorageSpace + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba5d9f3666222c808553c27e4e099c7c6d + + + + CommandUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba75bdf0b6844fa9c07b3c25647d22c269 + + + + ParametersUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf4c7c88815981bbb7c3a3461f9f48b67 + + + + CommandNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba2ca4834c756c81b924ebed696fcba0a8 + + + + BadCommandSequence + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad0c7ab07f01c1f7af16a1852650d7c47 + + + + ParameterNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8807473b8590e1debfb3740b7a3d081c + + + + NotLoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafcfbaff2c6fed941b6bcbc0999db764e + + + + NeedAccountToStore + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba1af0f173062a471739b50d8e0f40d5f7 + + + + FileUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba3f8f931e499936fde6b750d81f5ecfef + + + + PageTypeUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad220bc12dc45593af6e5079ea6c532c3 + + + + NotEnoughMemory + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf418e54753e0b8f9cb0325dd618acd14 + + + + FilenameNotAllowed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba03254aba823298179a98056e15568c5b + + + + InvalidResponse + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba59e041e4ef186e8ae8d6035973fc46bd + + + + ConnectionFailed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba51aa367cc1e85a45ea3c7be48730e990 + + + + ConnectionClosed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad1e5dcf298ce30c528261435f1a2eb53 + + + + InvalidFile + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baed2c74a9f335dee1463ca1a4f41c6478 + + + + RestartMarkerReply + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba07e06d3326ba2d078583bef93930d909 + + + + ServiceReadySoon + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba22413357ade6b586f6ceb0d704f35075 + + + + DataConnectionAlreadyOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafa52d19bc813d69055f4cc390d4a76ca + + + + OpeningDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba794ebe743688be611447638bf9e49d86 + + + + Ok + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baa956e229ba6c0cdf0d88b0e05b286210 + + + + PointlessCommand + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba38adc424f1adcd332745de8cd3b7737a + + + + SystemStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9bdd02ae119b8be639e778859ee74060 + + + + DirectoryStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8729460a695013cc96330e2fced0ae1f + + + + FileStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baebddfc7997dca289c83068dff3f47dce + + + + HelpMessage + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba840fd2a1872fd4310b046541f57fdeb7 + + + + SystemType + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba78391f73aa11f07f1514c7d070b93c08 + + + + ServiceReady + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baea2ee2007d7843c21108bb686ef03757 + + + + ClosingConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bab23931490fc2d1df3081d651fe0f4d6e + + + + DataConnectionOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3badc78ed87d5bddb174fa3c16707ac2f2d + + + + ClosingDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bac723ebc8a38913bbf0d9504556cbaaa6 + + + + EnteringPassiveMode + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba48314fc47a72ad0aacdea93b91756f6e + + + + LoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba54a88210386cb72e35d737813a221754 + + + + FileActionOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf988b69b0a5f55f8122da5ba001932e0 + + + + DirectoryOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba06d26e95a170fc422af13def415e0437 + + + + NeedPassword + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9249e3fe9818eb93f181fbbf3ae3bc56 + + + + NeedAccountToLogIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9e048185f253f6eb6f5ff9e063b712fa + + + + NeedInformation + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba02e6f05964ecb829e9b6fb6020d6528a + + + + ServiceUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba43022ddf49b68a4f5aff0bea7e09e89f + + + + DataConnectionUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba757b89ff1f236941f7759b0ed0c28b88 + + + + TransferAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba7cfefcc586c12ba70f752353fde7126e + + + + FileActionAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf822d1b0abf3e9ae7dd44684549d512d + + + + LocalError + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bae54e84baaca95a7b36271ca3f3fdb900 + + + + InsufficientStorageSpace + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba5d9f3666222c808553c27e4e099c7c6d + + + + CommandUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba75bdf0b6844fa9c07b3c25647d22c269 + + + + ParametersUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf4c7c88815981bbb7c3a3461f9f48b67 + + + + CommandNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba2ca4834c756c81b924ebed696fcba0a8 + + + + BadCommandSequence + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad0c7ab07f01c1f7af16a1852650d7c47 + + + + ParameterNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8807473b8590e1debfb3740b7a3d081c + + + + NotLoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafcfbaff2c6fed941b6bcbc0999db764e + + + + NeedAccountToStore + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba1af0f173062a471739b50d8e0f40d5f7 + + + + FileUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba3f8f931e499936fde6b750d81f5ecfef + + + + PageTypeUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad220bc12dc45593af6e5079ea6c532c3 + + + + NotEnoughMemory + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf418e54753e0b8f9cb0325dd618acd14 + + + + FilenameNotAllowed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba03254aba823298179a98056e15568c5b + + + + InvalidResponse + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba59e041e4ef186e8ae8d6035973fc46bd + + + + ConnectionFailed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba51aa367cc1e85a45ea3c7be48730e990 + + + + ConnectionClosed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad1e5dcf298ce30c528261435f1a2eb53 + + + + InvalidFile + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baed2c74a9f335dee1463ca1a4f41c6478 + + + + + ListingResponse + classsf_1_1Ftp_1_1ListingResponse.html + a7e98d0aed70105c71adb52e5b6ce0bb8 + (const Response &response, const std::string &data) + + + const std::vector< std::string > & + getListing + classsf_1_1Ftp_1_1ListingResponse.html + a0d0579db7e0531761992dbbae1174bf2 + () const + + + bool + isOk + classsf_1_1Ftp_1_1Response.html + a5102552955a2652c1a39e9046e617b36 + () const + + + Status + getStatus + classsf_1_1Ftp_1_1Response.html + a52bbca9fbf5451157bc055e3d8430c25 + () const + + + const std::string & + getMessage + classsf_1_1Ftp_1_1Response.html + adc2890c93c9f8ee997b828fcbef82c97 + () const + + + + sf::Lock + classsf_1_1Lock.html + sf::NonCopyable + + + Lock + classsf_1_1Lock.html + a1a4c5d7a15da61103d85c9aa7f118920 + (Mutex &mutex) + + + + ~Lock + classsf_1_1Lock.html + a8168b36323a18ccf5b6bc531d964aec5 + () + + + + sf::MemoryInputStream + classsf_1_1MemoryInputStream.html + sf::InputStream + + + MemoryInputStream + classsf_1_1MemoryInputStream.html + a2d78851a69a8956a79872be41bcdfe0e + () + + + void + open + classsf_1_1MemoryInputStream.html + ad3cfb4f4f915f7803d6a0784e394ac19 + (const void *data, std::size_t sizeInBytes) + + + virtual Int64 + read + classsf_1_1MemoryInputStream.html + adff5270c521819639154d42d76fd4c34 + (void *data, Int64 size) + + + virtual Int64 + seek + classsf_1_1MemoryInputStream.html + aa2ac8fda2bdb4c95248ae90c71633034 + (Int64 position) + + + virtual Int64 + tell + classsf_1_1MemoryInputStream.html + a7ad4bdf721f29de8f66421ff29e23ee4 + () + + + virtual Int64 + getSize + classsf_1_1MemoryInputStream.html + a6ade3ca45de361ffa0a718595f0b6763 + () + + + + sf::Mouse + classsf_1_1Mouse.html + + + Button + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90 + + + + Left + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90a8bb4856e1ec7f6b6a8605effdfc0eee8 + + + + Right + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90af2cff24ab6c26daf079b11189f982fc4 + + + + Middle + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90a2c353189c4b11cf216d7caddafcc609d + + + + XButton1 + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90aecc7f3ce9ad6a60b9b0027876446b8d7 + + + + XButton2 + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90a03fa056fd0dd9d629c205d91a8ef1b5a + + + + ButtonCount + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90a52a1d434289774240ddaa22496762402 + + + + + Wheel + classsf_1_1Mouse.html + a60dd479a43f26f200e7957aa11803ff4 + + + + VerticalWheel + classsf_1_1Mouse.html + a60dd479a43f26f200e7957aa11803ff4abd571de908d2b2c4b9f165f29c678496 + + + + HorizontalWheel + classsf_1_1Mouse.html + a60dd479a43f26f200e7957aa11803ff4a785768d5e33c77de9fdcfdd02219f4e2 + + + + Left + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90a8bb4856e1ec7f6b6a8605effdfc0eee8 + + + + Right + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90af2cff24ab6c26daf079b11189f982fc4 + + + + Middle + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90a2c353189c4b11cf216d7caddafcc609d + + + + XButton1 + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90aecc7f3ce9ad6a60b9b0027876446b8d7 + + + + XButton2 + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90a03fa056fd0dd9d629c205d91a8ef1b5a + + + + ButtonCount + classsf_1_1Mouse.html + a4fb128be433f9aafe66bc0c605daaa90a52a1d434289774240ddaa22496762402 + + + + VerticalWheel + classsf_1_1Mouse.html + a60dd479a43f26f200e7957aa11803ff4abd571de908d2b2c4b9f165f29c678496 + + + + HorizontalWheel + classsf_1_1Mouse.html + a60dd479a43f26f200e7957aa11803ff4a785768d5e33c77de9fdcfdd02219f4e2 + + + + static bool + isButtonPressed + classsf_1_1Mouse.html + ab647159eb88e369a0332a9c5a7ba6687 + (Button button) + + + static Vector2i + getPosition + classsf_1_1Mouse.html + ac368680f797b7f6e4f50b5b7928c1387 + () + + + static Vector2i + getPosition + classsf_1_1Mouse.html + ac9934f761e377da97993de5aab75006b + (const WindowBase &relativeTo) + + + static void + setPosition + classsf_1_1Mouse.html + a1222e16c583be9e3d176d86e0b7817d7 + (const Vector2i &position) + + + static void + setPosition + classsf_1_1Mouse.html + a698c41e9bce6f30ceb4063c21f869fc5 + (const Vector2i &position, const WindowBase &relativeTo) + + + + sf::Event::MouseButtonEvent + structsf_1_1Event_1_1MouseButtonEvent.html + + Mouse::Button + button + structsf_1_1Event_1_1MouseButtonEvent.html + a5f53725aa7b647705486eeb95f723024 + + + + int + x + structsf_1_1Event_1_1MouseButtonEvent.html + a49b937b311729174950787781aafcdc7 + + + + int + y + structsf_1_1Event_1_1MouseButtonEvent.html + aae4735071868d4411d1782bf67619d64 + + + + + sf::Event::MouseMoveEvent + structsf_1_1Event_1_1MouseMoveEvent.html + + int + x + structsf_1_1Event_1_1MouseMoveEvent.html + aa3a23809afb905cbb52c66d8512e21fd + + + + int + y + structsf_1_1Event_1_1MouseMoveEvent.html + a86d78a2fba5b3abda16ca059f2392ad4 + + + + + sf::Event::MouseWheelEvent + structsf_1_1Event_1_1MouseWheelEvent.html + + int + delta + structsf_1_1Event_1_1MouseWheelEvent.html + a4d02b524b5530c7863e7b0f211fa522c + + + + int + x + structsf_1_1Event_1_1MouseWheelEvent.html + a3079803f836ed7208f43b60332ab053e + + + + int + y + structsf_1_1Event_1_1MouseWheelEvent.html + a7ea1b8d8c28e2f530c6e9e6d9a5d32d3 + + + + + sf::Event::MouseWheelScrollEvent + structsf_1_1Event_1_1MouseWheelScrollEvent.html + + Mouse::Wheel + wheel + structsf_1_1Event_1_1MouseWheelScrollEvent.html + a1d82dccecc46968d517b2fc66639dd74 + + + + float + delta + structsf_1_1Event_1_1MouseWheelScrollEvent.html + ac45c164997a594d424071e74b53b5817 + + + + int + x + structsf_1_1Event_1_1MouseWheelScrollEvent.html + a3d17cae0568d18083f879655abdc8ae4 + + + + int + y + structsf_1_1Event_1_1MouseWheelScrollEvent.html + aa38bf23704162024eed19917eef3853c + + + + + sf::Music + classsf_1_1Music.html + sf::SoundStream + sf::Music::Span + + + Status + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03 + + + + Stopped + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03adabb01e8aa85b2f54b344890addf764a + + + + Paused + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03ac3ca1fcc0394267c9bdbe3dc0a8a7e41 + + + + Playing + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03af07bdea9f70ef7606dfc9f955beeee18 + + + + Stopped + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03adabb01e8aa85b2f54b344890addf764a + + + + Paused + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03ac3ca1fcc0394267c9bdbe3dc0a8a7e41 + + + + Playing + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03af07bdea9f70ef7606dfc9f955beeee18 + + + + + Music + classsf_1_1Music.html + a0bc787d8e022b3a9b89cf2c28befd42e + () + + + + ~Music + classsf_1_1Music.html + a4c65860fed2f01d0eaa6c4199870414b + () + + + bool + openFromFile + classsf_1_1Music.html + a3edc66e5f5b3f11e84b90eaec9c7d7c0 + (const std::string &filename) + + + bool + openFromMemory + classsf_1_1Music.html + ae93b21bcf28ff0b5fec458039111386e + (const void *data, std::size_t sizeInBytes) + + + bool + openFromStream + classsf_1_1Music.html + a4e55d1910a26858b44778c26b237d673 + (InputStream &stream) + + + Time + getDuration + classsf_1_1Music.html + a288ef6f552a136b0e56952dcada3d672 + () const + + + TimeSpan + getLoopPoints + classsf_1_1Music.html + aae3451cad5c16ee6a6e124e62ed61361 + () const + + + void + setLoopPoints + classsf_1_1Music.html + ae7b339f0a957dfad045f3f28083a015e + (TimeSpan timePoints) + + + void + play + classsf_1_1SoundStream.html + afdc08b69cab5f243d9324940a85a1144 + () + + + void + pause + classsf_1_1SoundStream.html + a932ff181e661503cad288b4bb6fe45ca + () + + + void + stop + classsf_1_1SoundStream.html + a16cc6a0404b32e42c4dce184bb94d0f4 + () + + + unsigned int + getChannelCount + classsf_1_1SoundStream.html + a1f70933912dd9498f4dc99feefed27f3 + () const + + + unsigned int + getSampleRate + classsf_1_1SoundStream.html + a7da448dc40d81a33b8dc555fbf0d3fbf + () const + + + Status + getStatus + classsf_1_1SoundStream.html + a64a8193ed728da37c115c65de015849f + () const + + + void + setPlayingOffset + classsf_1_1SoundStream.html + af416a5f84c8750d2acb9821d78bc8646 + (Time timeOffset) + + + Time + getPlayingOffset + classsf_1_1SoundStream.html + ae288f3c72edbad9cc7ee938ce5b907c1 + () const + + + void + setLoop + classsf_1_1SoundStream.html + a43fade018ffba7e4f847a9f00b353f3d + (bool loop) + + + bool + getLoop + classsf_1_1SoundStream.html + a49d263f9bbaefec4b019bd05fda59b25 + () const + + + void + setPitch + classsf_1_1SoundSource.html + a72a13695ed48b7f7b55e7cd4431f4bb6 + (float pitch) + + + void + setVolume + classsf_1_1SoundSource.html + a2f192f2b49fb8e2b82f3498d3663fcc2 + (float volume) + + + void + setPosition + classsf_1_1SoundSource.html + a0480257ea25d986eba6cc3c1a6f8d7c2 + (float x, float y, float z) + + + void + setPosition + classsf_1_1SoundSource.html + a17ba9ed01925395652181a7b2a7d3aef + (const Vector3f &position) + + + void + setRelativeToListener + classsf_1_1SoundSource.html + ac478a8b813faf7dd575635b102081d0d + (bool relative) + + + void + setMinDistance + classsf_1_1SoundSource.html + a75bbc2c34addc8b25a14edb908508afe + (float distance) + + + void + setAttenuation + classsf_1_1SoundSource.html + aa2adff44cd2f8b4e3c7315d7c2a45626 + (float attenuation) + + + float + getPitch + classsf_1_1SoundSource.html + a4736acc2c802f927544c9ce52a44a9e4 + () const + + + float + getVolume + classsf_1_1SoundSource.html + a04243fb5edf64561689b1d58953fc4ce + () const + + + Vector3f + getPosition + classsf_1_1SoundSource.html + a8d199521f55550c7a3b2b0f6950dffa1 + () const + + + bool + isRelativeToListener + classsf_1_1SoundSource.html + adcdb4ef32c2f4481d34aff0b5c31534b + () const + + + float + getMinDistance + classsf_1_1SoundSource.html + a605ca7f359ec1c36fcccdcd4696562ac + () const + + + float + getAttenuation + classsf_1_1SoundSource.html + a8ad7dafb4f1b4afbc638cebe24f48cc9 + () const + + + NoLoop + classsf_1_1SoundStream.html + a7707214e7cd4ffcf1c123e7bcab4092aa2f2c638731fdff0d6fe4e3e82b6f6146 + + + + NoLoop + classsf_1_1SoundStream.html + a7707214e7cd4ffcf1c123e7bcab4092aa2f2c638731fdff0d6fe4e3e82b6f6146 + + + + virtual bool + onGetData + classsf_1_1Music.html + aca1bcb4e5d56a854133e74bd86374463 + (Chunk &data) + + + virtual void + onSeek + classsf_1_1Music.html + a15119cc0419c16bb334fa0698699c02e + (Time timeOffset) + + + virtual Int64 + onLoop + classsf_1_1Music.html + aa68a64bdaf5d16e9ed64f202f5c45e03 + () + + + void + initialize + classsf_1_1SoundStream.html + a9c351711198ee1aa77c2fefd3ced4d2c + (unsigned int channelCount, unsigned int sampleRate) + + + void + setProcessingInterval + classsf_1_1SoundStream.html + a3a38d317279163f3766da2e538fbde93 + (Time interval) + + + unsigned int + m_source + classsf_1_1SoundSource.html + a0223cef4b1c587e6e1e17b4c92c4479c + + + + + sf::Mutex + classsf_1_1Mutex.html + sf::NonCopyable + + + Mutex + classsf_1_1Mutex.html + a9bd52a48320fd7b6db8a78037aad276e + () + + + + ~Mutex + classsf_1_1Mutex.html + a9f76a67b7b6d3918131a692179b4e3f2 + () + + + void + lock + classsf_1_1Mutex.html + a1a16956a6bbea764480c1b80f2e45763 + () + + + void + unlock + classsf_1_1Mutex.html + ade71268ffc5e80756652058b01c23c33 + () + + + + sf::NonCopyable + classsf_1_1NonCopyable.html + + + NonCopyable + classsf_1_1NonCopyable.html + a2110add170580fdb946f887719da6860 + () + + + + ~NonCopyable + classsf_1_1NonCopyable.html + a8274ffbf46014f5f7f364befb52c7728 + () + + + + sf::OutputSoundFile + classsf_1_1OutputSoundFile.html + sf::NonCopyable + + + OutputSoundFile + classsf_1_1OutputSoundFile.html + a7ae9f2dbd0991fa9394726a3d58bb19e + () + + + + ~OutputSoundFile + classsf_1_1OutputSoundFile.html + a1492adbfef1f391d720afb56f068182e + () + + + bool + openFromFile + classsf_1_1OutputSoundFile.html + ae5e55f01c53c1422c44eaed2eed67fce + (const std::string &filename, unsigned int sampleRate, unsigned int channelCount) + + + void + write + classsf_1_1OutputSoundFile.html + adfcf525fced71121f336fa89faac3d67 + (const Int16 *samples, Uint64 count) + + + void + close + classsf_1_1OutputSoundFile.html + ad20c867d7e565d533da029f31ea5a337 + () + + + + sf::Packet + classsf_1_1Packet.html + + + Packet + classsf_1_1Packet.html + a786e5d4ced83992ceefa1799963ea858 + () + + + virtual + ~Packet + classsf_1_1Packet.html + adc0490ca3c7c3d1e321bd742e5213913 + () + + + void + append + classsf_1_1Packet.html + a7dd6e429b87520008326c4d71f1cf011 + (const void *data, std::size_t sizeInBytes) + + + std::size_t + getReadPosition + classsf_1_1Packet.html + a5c2dc9878afaf30e88d922776201f6c3 + () const + + + void + clear + classsf_1_1Packet.html + a133ea8b8fe6e93c230f0d79f19a3bf0d + () + + + const void * + getData + classsf_1_1Packet.html + a998b70df024bee4792e2ecdc915ae46e + () const + + + std::size_t + getDataSize + classsf_1_1Packet.html + a0fae6eccf2ca704fc5099cd90a9f56f7 + () const + + + bool + endOfPacket + classsf_1_1Packet.html + a61e354fa670da053907c14b738839560 + () const + + + + operator BoolType + classsf_1_1Packet.html + a8ab20be4a63921b7cb1a4d8ca5c30f75 + () const + + + Packet & + operator>> + classsf_1_1Packet.html + a8b6403506fec6b69f033278de33c8145 + (bool &data) + + + Packet & + operator>> + classsf_1_1Packet.html + a1c7814f9dbc637986ac498094add5ca5 + (Int8 &data) + + + Packet & + operator>> + classsf_1_1Packet.html + a48df8986fc24551f1287144d3e990859 + (Uint8 &data) + + + Packet & + operator>> + classsf_1_1Packet.html + ae455be24bfd8dbaa4cd5097e0fb70ecd + (Int16 &data) + + + Packet & + operator>> + classsf_1_1Packet.html + a6bc20f1be9a63407079e6d26171ac71f + (Uint16 &data) + + + Packet & + operator>> + classsf_1_1Packet.html + a663e71b25a9352e3c4ddf4a3ce9db921 + (Int32 &data) + + + Packet & + operator>> + classsf_1_1Packet.html + aa3b0fabe6c14bcfa29bb04844b8bb987 + (Uint32 &data) + + + Packet & + operator>> + classsf_1_1Packet.html + ae76105996a6c2217bb3a4571603e92f6 + (Int64 &data) + + + Packet & + operator>> + classsf_1_1Packet.html + a79f7c144fd07a4036ffc7b0870a36613 + (Uint64 &data) + + + Packet & + operator>> + classsf_1_1Packet.html + a741849607d428e93c532e11eadcc39f1 + (float &data) + + + Packet & + operator>> + classsf_1_1Packet.html + a1854ca771105fb281edf349fc6507c73 + (double &data) + + + Packet & + operator>> + classsf_1_1Packet.html + aaed01fec1a3eae27a028506195607f82 + (char *data) + + + Packet & + operator>> + classsf_1_1Packet.html + a60484dff69997db11e2d4ab3704ab921 + (std::string &data) + + + Packet & + operator>> + classsf_1_1Packet.html + a8805e66013f9f84ec8a883e42ae259d4 + (wchar_t *data) + + + Packet & + operator>> + classsf_1_1Packet.html + a8621056995c32bcf59809e2aecf08635 + (std::wstring &data) + + + Packet & + operator>> + classsf_1_1Packet.html + a27d0ae92891dbf8a7914e5d5232940d0 + (String &data) + + + Packet & + operator<< + classsf_1_1Packet.html + ae02c874e0aac18a0497fca982a8f9083 + (bool data) + + + Packet & + operator<< + classsf_1_1Packet.html + a97aa4ecba66b8f528438fc41ed020825 + (Int8 data) + + + Packet & + operator<< + classsf_1_1Packet.html + ad5cc1857ed14878ab7a8509db8d99335 + (Uint8 data) + + + Packet & + operator<< + classsf_1_1Packet.html + a9d9c5a1bef415046aa46d51e7d2a9f1c + (Int16 data) + + + Packet & + operator<< + classsf_1_1Packet.html + afb6b2958f8a55923297da432c2a4f3e9 + (Uint16 data) + + + Packet & + operator<< + classsf_1_1Packet.html + af7f5c31c2d2749d3088783525f9fc974 + (Int32 data) + + + Packet & + operator<< + classsf_1_1Packet.html + ad1837e0990f71e3727e0e118ab9fd20e + (Uint32 data) + + + Packet & + operator<< + classsf_1_1Packet.html + a6dc89edcfcf19daf781b776439aba94a + (Int64 data) + + + Packet & + operator<< + classsf_1_1Packet.html + af3802406ed3430e20259e8551fa6554b + (Uint64 data) + + + Packet & + operator<< + classsf_1_1Packet.html + acf1a231e48452a1cd55af2c027a1c1ee + (float data) + + + Packet & + operator<< + classsf_1_1Packet.html + abee2df335bdc3ab40521248cdb187c02 + (double data) + + + Packet & + operator<< + classsf_1_1Packet.html + a94522071d95189ddff1ae7ca832695ff + (const char *data) + + + Packet & + operator<< + classsf_1_1Packet.html + ac45aab054ddee7de9599bc3b2d8e025f + (const std::string &data) + + + Packet & + operator<< + classsf_1_1Packet.html + ac5a13e3280cac77799f7fdadfe3e37b6 + (const wchar_t *data) + + + Packet & + operator<< + classsf_1_1Packet.html + a97acaefaee7d3ffb36f4e8a00d4c3970 + (const std::wstring &data) + + + Packet & + operator<< + classsf_1_1Packet.html + a5ef2e3308b93b80214b42a7d4683704a + (const String &data) + + + virtual const void * + onSend + classsf_1_1Packet.html + af0003506bcb290407dcf5fe7f13a887d + (std::size_t &size) + + + virtual void + onReceive + classsf_1_1Packet.html + ab71a31ef0f1d5d856de6f9fc75434128 + (const void *data, std::size_t size) + + + + sf::Rect + classsf_1_1Rect.html + typename T + + + Rect + classsf_1_1Rect.html + a0f87ebaef9722a6222fd2e04ce8efb37 + () + + + + Rect + classsf_1_1Rect.html + a15cdbc5a1aed3a8fc7be1bd5004f19f9 + (T rectLeft, T rectTop, T rectWidth, T rectHeight) + + + + Rect + classsf_1_1Rect.html + a27fdf85caa6d12caeeff78913cc59936 + (const Vector2< T > &position, const Vector2< T > &size) + + + + Rect + classsf_1_1Rect.html + a6fff2bb7e93677839461a66bc2957de0 + (const Rect< U > &rectangle) + + + bool + contains + classsf_1_1Rect.html + a910b998c92756157e1407e1363f93212 + (T x, T y) const + + + bool + contains + classsf_1_1Rect.html + a45c77c073a7a4d9232218ab2838f41bb + (const Vector2< T > &point) const + + + bool + intersects + classsf_1_1Rect.html + ac77531698f39203e4bbe023097bb6a13 + (const Rect< T > &rectangle) const + + + bool + intersects + classsf_1_1Rect.html + ad512c4a1127279e2d7464d0ace62500d + (const Rect< T > &rectangle, Rect< T > &intersection) const + + + sf::Vector2< T > + getPosition + classsf_1_1Rect.html + a846489bc985f7d1655150cad65961bbd + () const + + + sf::Vector2< T > + getSize + classsf_1_1Rect.html + ab1fd0936386404646ebe708652a66d09 + () const + + + T + left + classsf_1_1Rect.html + aa49960fa465103d9cb7069ceb25c7c32 + + + + T + top + classsf_1_1Rect.html + abd3d3a2d0ad211ef0082bd0aa1a5c0e3 + + + + T + width + classsf_1_1Rect.html + a4dd5b9d4333bebbc51bd309298fd500f + + + + T + height + classsf_1_1Rect.html + a6fa0fc7de1636d78cae1a1b54eef95cd + + + + bool + operator== + classsf_1_1Rect.html + ab3488b5dbd0e587c4d7cb80605affc46 + (const Rect< T > &left, const Rect< T > &right) + + + bool + operator!= + classsf_1_1Rect.html + a03fc4c105687b7d0f07b6b4ed4b45581 + (const Rect< T > &left, const Rect< T > &right) + + + + sf::RectangleShape + classsf_1_1RectangleShape.html + sf::Shape + + + RectangleShape + classsf_1_1RectangleShape.html + a83a2be157ebee85c95ed491c3e78dd7c + (const Vector2f &size=Vector2f(0, 0)) + + + void + setSize + classsf_1_1RectangleShape.html + a5c65d374d4a259dfdc24efdd24a5dbec + (const Vector2f &size) + + + const Vector2f & + getSize + classsf_1_1RectangleShape.html + af6819a7b842b83863f21e7a9c63097e7 + () const + + + virtual std::size_t + getPointCount + classsf_1_1RectangleShape.html + adfb2f429e5720c9ccdb26d5996c3ae33 + () const + + + virtual Vector2f + getPoint + classsf_1_1RectangleShape.html + a3909f1a1946930ff5ae17c26206c0f81 + (std::size_t index) const + + + void + setTexture + classsf_1_1Shape.html + af8fb22bab1956325be5d62282711e3b6 + (const Texture *texture, bool resetRect=false) + + + void + setTextureRect + classsf_1_1Shape.html + a2029cc820d1740d14ac794b82525e157 + (const IntRect &rect) + + + void + setFillColor + classsf_1_1Shape.html + a3506f9b5d916fec14d583d16f23c2485 + (const Color &color) + + + void + setOutlineColor + classsf_1_1Shape.html + a5978f41ee349ac3c52942996dcb184f7 + (const Color &color) + + + void + setOutlineThickness + classsf_1_1Shape.html + a5ad336ad74fc1f567fce3b7e44cf87dc + (float thickness) + + + const Texture * + getTexture + classsf_1_1Shape.html + af4c345931cd651ffb8f7a177446e28f7 + () const + + + const IntRect & + getTextureRect + classsf_1_1Shape.html + ad8adbb54823c8eff1830a938e164daa4 + () const + + + const Color & + getFillColor + classsf_1_1Shape.html + aa5da23e522d2dd11e3e7661c26164c78 + () const + + + const Color & + getOutlineColor + classsf_1_1Shape.html + a4aa05b59851468e948ac9682b9c71abb + () const + + + float + getOutlineThickness + classsf_1_1Shape.html + a1d4d5299c573a905e5833fc4dce783a7 + () const + + + FloatRect + getLocalBounds + classsf_1_1Shape.html + ae3294bcdf8713d33a862242ecf706443 + () const + + + FloatRect + getGlobalBounds + classsf_1_1Shape.html + ac0e29425d908d5442060cc44790fe4da + () const + + + void + setPosition + classsf_1_1Transformable.html + a4dbfb1a7c80688b0b4c477d706550208 + (float x, float y) + + + void + setPosition + classsf_1_1Transformable.html + af1a42209ce2b5d3f07b00f917bcd8015 + (const Vector2f &position) + + + void + setRotation + classsf_1_1Transformable.html + a32baf2bf1a74699b03bf8c95030a38ed + (float angle) + + + void + setScale + classsf_1_1Transformable.html + aaec50b46b3f41b054763304d1e727471 + (float factorX, float factorY) + + + void + setScale + classsf_1_1Transformable.html + a4c48a87f1626047e448f9c1a68ff167e + (const Vector2f &factors) + + + void + setOrigin + classsf_1_1Transformable.html + a56c67bd80aae8418d13fb96c034d25ec + (float x, float y) + + + void + setOrigin + classsf_1_1Transformable.html + aa93a835ffbf3bee2098dfbbc695a7f05 + (const Vector2f &origin) + + + const Vector2f & + getPosition + classsf_1_1Transformable.html + aea8b18e91a7bf7be589851bb9dd11241 + () const + + + float + getRotation + classsf_1_1Transformable.html + aa00b5c5d4a06ac24a94dd72c56931d3a + () const + + + const Vector2f & + getScale + classsf_1_1Transformable.html + a7bcae0e924213f2e89edd8926f2453af + () const + + + const Vector2f & + getOrigin + classsf_1_1Transformable.html + a898b33eb6513161eb5c747a072364f15 + () const + + + void + move + classsf_1_1Transformable.html + a86b461d6a941ad390c2ad8b6a4a20391 + (float offsetX, float offsetY) + + + void + move + classsf_1_1Transformable.html + ab9ca691522f6ddc1a40406849b87c469 + (const Vector2f &offset) + + + void + rotate + classsf_1_1Transformable.html + af8a5ffddc0d93f238fee3bf8efe1ebda + (float angle) + + + void + scale + classsf_1_1Transformable.html + a3de0c6d8957f3cf318092f3f60656391 + (float factorX, float factorY) + + + void + scale + classsf_1_1Transformable.html + adecaa6c69b1f27dd5194b067d96bb694 + (const Vector2f &factor) + + + const Transform & + getTransform + classsf_1_1Transformable.html + a3e1b4772a451ec66ac7e6af655726154 + () const + + + const Transform & + getInverseTransform + classsf_1_1Transformable.html + ac5e75d724436069d2268791c6b486916 + () const + + + void + update + classsf_1_1Shape.html + adfb2bd966c8edbc5d6c92ebc375e4ac1 + () + + + + sf::RenderStates + classsf_1_1RenderStates.html + + + RenderStates + classsf_1_1RenderStates.html + a885bf14070d0d5391f062f62b270b7d0 + () + + + + RenderStates + classsf_1_1RenderStates.html + acac8830a593c8a4523ac2fdf3cac8a01 + (const BlendMode &theBlendMode) + + + + RenderStates + classsf_1_1RenderStates.html + a3e99cad6ab05971d40357949930ed890 + (const Transform &theTransform) + + + + RenderStates + classsf_1_1RenderStates.html + a8f4ca3be0e27dafea0c4ab8547439bb1 + (const Texture *theTexture) + + + + RenderStates + classsf_1_1RenderStates.html + a39f94233f464739d8d8522f3aefe97d0 + (const Shader *theShader) + + + + RenderStates + classsf_1_1RenderStates.html + ab5eda13cd8c79c74eba3b1b0df817d67 + (const BlendMode &theBlendMode, const Transform &theTransform, const Texture *theTexture, const Shader *theShader) + + + BlendMode + blendMode + classsf_1_1RenderStates.html + ad6ac87f1b5006dae7ebfee4b5d40f5a8 + + + + Transform + transform + classsf_1_1RenderStates.html + a1f737981a0f2f0d4bb8dac866a8d1149 + + + + const Texture * + texture + classsf_1_1RenderStates.html + a457fc5a41731889de9cf39cf9b3436c3 + + + + const Shader * + shader + classsf_1_1RenderStates.html + ad4f79ecdd0c60ed0d24fbe555b221bd8 + + + + static const RenderStates + Default + classsf_1_1RenderStates.html + ad29672df29f19ce50c3021d95f2bb062 + + + + + sf::RenderTarget + classsf_1_1RenderTarget.html + sf::NonCopyable + + virtual + ~RenderTarget + classsf_1_1RenderTarget.html + a9abd1654a99fba46f6887b9c625b9b06 + () + + + void + clear + classsf_1_1RenderTarget.html + a6bb6f0ba348f2b1e2f46114aeaf60f26 + (const Color &color=Color(0, 0, 0, 255)) + + + void + setView + classsf_1_1RenderTarget.html + a063db6dd0a14913504af30e50cb6d946 + (const View &view) + + + const View & + getView + classsf_1_1RenderTarget.html + adbf8dc5a1f4abbe15a3fbb915844c7ea + () const + + + const View & + getDefaultView + classsf_1_1RenderTarget.html + a7741129e3ef7ab4f0a40024fca13480c + () const + + + IntRect + getViewport + classsf_1_1RenderTarget.html + a865d462915dc2a1fae2ebfb3300382ac + (const View &view) const + + + Vector2f + mapPixelToCoords + classsf_1_1RenderTarget.html + a0103ebebafa43a97e6e6414f8560d5e3 + (const Vector2i &point) const + + + Vector2f + mapPixelToCoords + classsf_1_1RenderTarget.html + a2d3e9d7c4a1f5ea7e52b06f53e3011f9 + (const Vector2i &point, const View &view) const + + + Vector2i + mapCoordsToPixel + classsf_1_1RenderTarget.html + ad92a9f0283aa5f3f67e473c1105b68cf + (const Vector2f &point) const + + + Vector2i + mapCoordsToPixel + classsf_1_1RenderTarget.html + a848eee44b72ac3f16fa9182df26e83bc + (const Vector2f &point, const View &view) const + + + void + draw + classsf_1_1RenderTarget.html + a12417a3bcc245c41d957b29583556f39 + (const Drawable &drawable, const RenderStates &states=RenderStates::Default) + + + void + draw + classsf_1_1RenderTarget.html + a976bc94057799eb9f8a18ac5fdfd9b73 + (const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default) + + + void + draw + classsf_1_1RenderTarget.html + a3dc4d06f081d36ca1e8f1a1298d49abc + (const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default) + + + void + draw + classsf_1_1RenderTarget.html + a07cb25d4557a30146b24b25b242310ea + (const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default) + + + virtual Vector2u + getSize + classsf_1_1RenderTarget.html + a2e5ade2457d9fb4c4907ae5b3d9e94a5 + () const =0 + + + virtual bool + isSrgb + classsf_1_1RenderTarget.html + aea6b58e5b2423c917e2664ecd4952687 + () const + + + virtual bool + setActive + classsf_1_1RenderTarget.html + adc225ead22a70843ffa9b7eebefa0ce1 + (bool active=true) + + + void + pushGLStates + classsf_1_1RenderTarget.html + a8d1998464ccc54e789aaf990242b47f7 + () + + + void + popGLStates + classsf_1_1RenderTarget.html + ad5a98401113df931ddcd54c080f7aa8e + () + + + void + resetGLStates + classsf_1_1RenderTarget.html + aac7504990d27dada4bfe3c7866920765 + () + + + + RenderTarget + classsf_1_1RenderTarget.html + a2997c96cbd93cb8ce0aba2ddae35b86f + () + + + void + initialize + classsf_1_1RenderTarget.html + af530274b34159d644e509b4b4dc43eb7 + () + + + + sf::RenderTexture + classsf_1_1RenderTexture.html + sf::RenderTarget + + + RenderTexture + classsf_1_1RenderTexture.html + a19ee6e5b4c40ad251803389b3953a9c6 + () + + + virtual + ~RenderTexture + classsf_1_1RenderTexture.html + a94b84ab9335be84d2a014c964d973304 + () + + + bool + create + classsf_1_1RenderTexture.html + a0e945c4ce7703591c7f240b169744603 + (unsigned int width, unsigned int height, bool depthBuffer) + + + bool + create + classsf_1_1RenderTexture.html + a49b7b723a80f89bc409a942364351dc3 + (unsigned int width, unsigned int height, const ContextSettings &settings=ContextSettings()) + + + void + setSmooth + classsf_1_1RenderTexture.html + af08991e63c6020865dd07b20e27305b6 + (bool smooth) + + + bool + isSmooth + classsf_1_1RenderTexture.html + a5b43c007ab6643accc5dae84b5bc8f61 + () const + + + void + setRepeated + classsf_1_1RenderTexture.html + af8f97b33512bf7d5b6be3da6f65f7365 + (bool repeated) + + + bool + isRepeated + classsf_1_1RenderTexture.html + a81c5a453a21c7e78299b062b97dc8c87 + () const + + + bool + generateMipmap + classsf_1_1RenderTexture.html + a8ca34c8b7e00793c1d3ef4f9a834f8cc + () + + + bool + setActive + classsf_1_1RenderTexture.html + a5da95ecdbce615a80bb78399012508cf + (bool active=true) + + + void + display + classsf_1_1RenderTexture.html + af92886d5faef3916caff9fa9ab32c555 + () + + + virtual Vector2u + getSize + classsf_1_1RenderTexture.html + a6685315b5c4c25a5dcb75b4280b381ba + () const + + + virtual bool + isSrgb + classsf_1_1RenderTexture.html + a994f2fa5a4235cbbdb60d9d9a5eed07b + () const + + + const Texture & + getTexture + classsf_1_1RenderTexture.html + a61a6eba45d5c9e5c913aebeccb7b7eda + () const + + + void + clear + classsf_1_1RenderTarget.html + a6bb6f0ba348f2b1e2f46114aeaf60f26 + (const Color &color=Color(0, 0, 0, 255)) + + + void + setView + classsf_1_1RenderTarget.html + a063db6dd0a14913504af30e50cb6d946 + (const View &view) + + + const View & + getView + classsf_1_1RenderTarget.html + adbf8dc5a1f4abbe15a3fbb915844c7ea + () const + + + const View & + getDefaultView + classsf_1_1RenderTarget.html + a7741129e3ef7ab4f0a40024fca13480c + () const + + + IntRect + getViewport + classsf_1_1RenderTarget.html + a865d462915dc2a1fae2ebfb3300382ac + (const View &view) const + + + Vector2f + mapPixelToCoords + classsf_1_1RenderTarget.html + a0103ebebafa43a97e6e6414f8560d5e3 + (const Vector2i &point) const + + + Vector2f + mapPixelToCoords + classsf_1_1RenderTarget.html + a2d3e9d7c4a1f5ea7e52b06f53e3011f9 + (const Vector2i &point, const View &view) const + + + Vector2i + mapCoordsToPixel + classsf_1_1RenderTarget.html + ad92a9f0283aa5f3f67e473c1105b68cf + (const Vector2f &point) const + + + Vector2i + mapCoordsToPixel + classsf_1_1RenderTarget.html + a848eee44b72ac3f16fa9182df26e83bc + (const Vector2f &point, const View &view) const + + + void + draw + classsf_1_1RenderTarget.html + a12417a3bcc245c41d957b29583556f39 + (const Drawable &drawable, const RenderStates &states=RenderStates::Default) + + + void + draw + classsf_1_1RenderTarget.html + a976bc94057799eb9f8a18ac5fdfd9b73 + (const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default) + + + void + draw + classsf_1_1RenderTarget.html + a3dc4d06f081d36ca1e8f1a1298d49abc + (const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default) + + + void + draw + classsf_1_1RenderTarget.html + a07cb25d4557a30146b24b25b242310ea + (const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default) + + + void + pushGLStates + classsf_1_1RenderTarget.html + a8d1998464ccc54e789aaf990242b47f7 + () + + + void + popGLStates + classsf_1_1RenderTarget.html + ad5a98401113df931ddcd54c080f7aa8e + () + + + void + resetGLStates + classsf_1_1RenderTarget.html + aac7504990d27dada4bfe3c7866920765 + () + + + static unsigned int + getMaximumAntialiasingLevel + classsf_1_1RenderTexture.html + ab0849fc3e064b744ffae1ab1d85ee12b + () + + + void + initialize + classsf_1_1RenderTarget.html + af530274b34159d644e509b4b4dc43eb7 + () + + + + sf::RenderWindow + classsf_1_1RenderWindow.html + sf::Window + sf::RenderTarget + + + RenderWindow + classsf_1_1RenderWindow.html + a839bbf336bdcafb084dafc3076fc9021 + () + + + + RenderWindow + classsf_1_1RenderWindow.html + aebef983e01f677bf5a66cefc4d547647 + (VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings()) + + + + RenderWindow + classsf_1_1RenderWindow.html + a25c0af7d515e710b6eebc9c6be952aa5 + (WindowHandle handle, const ContextSettings &settings=ContextSettings()) + + + virtual + ~RenderWindow + classsf_1_1RenderWindow.html + a3407e36bfc1752d723140438a825365c + () + + + virtual Vector2u + getSize + classsf_1_1RenderWindow.html + ae3eacf93661c8068fca7a78d57dc7e14 + () const + + + virtual bool + isSrgb + classsf_1_1RenderWindow.html + ad943b4797fe6e1d609f12ce413b6a093 + () const + + + bool + setActive + classsf_1_1RenderWindow.html + aee6c53eced675e885931eb3e91f11155 + (bool active=true) + + + Image + capture + classsf_1_1RenderWindow.html + a5a784b8a09bf4a8bc97ef9e0a8957c35 + () const + + + virtual void + create + classsf_1_1Window.html + ac6a58d9c26a18f0e70888d0f53e154c1 + (VideoMode mode, const String &title, Uint32 style=Style::Default) + + + virtual void + create + classsf_1_1Window.html + a6518b989614750e90d9784f4d05ce02c + (VideoMode mode, const String &title, Uint32 style, const ContextSettings &settings) + + + virtual void + create + classsf_1_1Window.html + a5ee0c5262df6cc4e1a8031ae6848437f + (WindowHandle handle) + + + virtual void + create + classsf_1_1Window.html + a064dd5dd7bb337fb9f5635f580081a1e + (WindowHandle handle, const ContextSettings &settings) + + + virtual void + close + classsf_1_1Window.html + a7355b916852af56cfe3cc00feed9f419 + () + + + const ContextSettings & + getSettings + classsf_1_1Window.html + a0605afbaceb02b098f9d731b7ab4203d + () const + + + void + setVerticalSyncEnabled + classsf_1_1Window.html + a59041c4556e0351048f8aff366034f61 + (bool enabled) + + + void + setFramerateLimit + classsf_1_1Window.html + af4322d315baf93405bf0d5087ad5e784 + (unsigned int limit) + + + bool + setActive + classsf_1_1Window.html + aaab549da64cedf74fa6f1ae7a3cc79e0 + (bool active=true) const + + + void + display + classsf_1_1Window.html + adabf839cb103ac96cfc82f781638772a + () + + + bool + isOpen + classsf_1_1WindowBase.html + aa43559822564ef958dc664a90c57cba0 + () const + + + bool + pollEvent + classsf_1_1WindowBase.html + a6a143de089c8716bd42c38c781268f7f + (Event &event) + + + bool + waitEvent + classsf_1_1WindowBase.html + aa1c100a69b5bc0c84e23a4652d51ac41 + (Event &event) + + + Vector2i + getPosition + classsf_1_1WindowBase.html + a5ddaa5943f547645079f081422e45c81 + () const + + + void + setPosition + classsf_1_1WindowBase.html + ab5b8d500fa5acd3ac2908c9221fe2019 + (const Vector2i &position) + + + void + setSize + classsf_1_1WindowBase.html + a7edca32bca3000d2e241dba720034bd6 + (const Vector2u &size) + + + void + setTitle + classsf_1_1WindowBase.html + accd36ae6244ae1e6d643f6c109e983f8 + (const String &title) + + + void + setIcon + classsf_1_1WindowBase.html + add42ae12c13012e6aab74d9e34591719 + (unsigned int width, unsigned int height, const Uint8 *pixels) + + + void + setVisible + classsf_1_1WindowBase.html + a576488ad202cb2cd4359af94eaba4dd8 + (bool visible) + + + void + setMouseCursorVisible + classsf_1_1WindowBase.html + afa4a3372b2870294d1579d8621fe3c1a + (bool visible) + + + void + setMouseCursorGrabbed + classsf_1_1WindowBase.html + a0023344922a1e854175c8ca22b072020 + (bool grabbed) + + + void + setMouseCursor + classsf_1_1WindowBase.html + a07487a3c7e04472b19e96d3a602213ec + (const Cursor &cursor) + + + void + setKeyRepeatEnabled + classsf_1_1WindowBase.html + afd1199a64d459ba531deb65f093050a6 + (bool enabled) + + + void + setJoystickThreshold + classsf_1_1WindowBase.html + ad37f939b492c7ea046d4f7b45ac46df1 + (float threshold) + + + void + requestFocus + classsf_1_1WindowBase.html + a448770d2372d8df0a1ad6b1c7cce3c89 + () + + + bool + hasFocus + classsf_1_1WindowBase.html + ad87bd19e979c426cb819ccde8c95232e + () const + + + WindowHandle + getSystemHandle + classsf_1_1WindowBase.html + af9e56181556545bf6e6d7ed969edae21 + () const + + + bool + createVulkanSurface + classsf_1_1WindowBase.html + a4bcb435cdb954f991f493976263a2fc1 + (const VkInstance &instance, VkSurfaceKHR &surface, const VkAllocationCallbacks *allocator=0) + + + void + clear + classsf_1_1RenderTarget.html + a6bb6f0ba348f2b1e2f46114aeaf60f26 + (const Color &color=Color(0, 0, 0, 255)) + + + void + setView + classsf_1_1RenderTarget.html + a063db6dd0a14913504af30e50cb6d946 + (const View &view) + + + const View & + getView + classsf_1_1RenderTarget.html + adbf8dc5a1f4abbe15a3fbb915844c7ea + () const + + + const View & + getDefaultView + classsf_1_1RenderTarget.html + a7741129e3ef7ab4f0a40024fca13480c + () const + + + IntRect + getViewport + classsf_1_1RenderTarget.html + a865d462915dc2a1fae2ebfb3300382ac + (const View &view) const + + + Vector2f + mapPixelToCoords + classsf_1_1RenderTarget.html + a0103ebebafa43a97e6e6414f8560d5e3 + (const Vector2i &point) const + + + Vector2f + mapPixelToCoords + classsf_1_1RenderTarget.html + a2d3e9d7c4a1f5ea7e52b06f53e3011f9 + (const Vector2i &point, const View &view) const + + + Vector2i + mapCoordsToPixel + classsf_1_1RenderTarget.html + ad92a9f0283aa5f3f67e473c1105b68cf + (const Vector2f &point) const + + + Vector2i + mapCoordsToPixel + classsf_1_1RenderTarget.html + a848eee44b72ac3f16fa9182df26e83bc + (const Vector2f &point, const View &view) const + + + void + draw + classsf_1_1RenderTarget.html + a12417a3bcc245c41d957b29583556f39 + (const Drawable &drawable, const RenderStates &states=RenderStates::Default) + + + void + draw + classsf_1_1RenderTarget.html + a976bc94057799eb9f8a18ac5fdfd9b73 + (const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default) + + + void + draw + classsf_1_1RenderTarget.html + a3dc4d06f081d36ca1e8f1a1298d49abc + (const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default) + + + void + draw + classsf_1_1RenderTarget.html + a07cb25d4557a30146b24b25b242310ea + (const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default) + + + void + pushGLStates + classsf_1_1RenderTarget.html + a8d1998464ccc54e789aaf990242b47f7 + () + + + void + popGLStates + classsf_1_1RenderTarget.html + ad5a98401113df931ddcd54c080f7aa8e + () + + + void + resetGLStates + classsf_1_1RenderTarget.html + aac7504990d27dada4bfe3c7866920765 + () + + + virtual void + onCreate + classsf_1_1RenderWindow.html + a5bef0040b0fa87bed9fbd459c980d53a + () + + + virtual void + onResize + classsf_1_1RenderWindow.html + a5c85fe482313562d33ffd24a194b6fef + () + + + void + initialize + classsf_1_1RenderTarget.html + af530274b34159d644e509b4b4dc43eb7 + () + + + + sf::Http::Request + classsf_1_1Http_1_1Request.html + + + Method + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598 + + + + Get + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598ab822baed393f3d0353621e5378b9fcb4 + + + + Post + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598ae8ec4048b9550f8d0747d4199603141a + + + + Head + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598a4df23138be7ed60f47aba6548ba65e7b + + + + Put + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598a523b94f9af069c1f35061d32011e2495 + + + + Delete + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598abc9555b94c1b896185015ec3990999f9 + + + + Get + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598ab822baed393f3d0353621e5378b9fcb4 + + + + Post + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598ae8ec4048b9550f8d0747d4199603141a + + + + Head + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598a4df23138be7ed60f47aba6548ba65e7b + + + + Put + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598a523b94f9af069c1f35061d32011e2495 + + + + Delete + classsf_1_1Http_1_1Request.html + a620f8bff6f43e1378f321bf53fbf5598abc9555b94c1b896185015ec3990999f9 + + + + + Request + classsf_1_1Http_1_1Request.html + a8e89d9e8ffcc1163259b35d79809a61c + (const std::string &uri="/", Method method=Get, const std::string &body="") + + + void + setField + classsf_1_1Http_1_1Request.html + aea672fae5dd089f4b6b3745ed46210d2 + (const std::string &field, const std::string &value) + + + void + setMethod + classsf_1_1Http_1_1Request.html + abab148554e873e80d2e41376fde1cb62 + (Method method) + + + void + setUri + classsf_1_1Http_1_1Request.html + a3723de4b4f1a14b744477841c4ac22e6 + (const std::string &uri) + + + void + setHttpVersion + classsf_1_1Http_1_1Request.html + aa683b607b737a6224a91387b4108d3c7 + (unsigned int major, unsigned int minor) + + + void + setBody + classsf_1_1Http_1_1Request.html + ae9f61ec3fa1639c70e9b5780cb35578e + (const std::string &body) + + + + sf::Ftp::Response + classsf_1_1Ftp_1_1Response.html + + + Status + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3b + + + + RestartMarkerReply + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba07e06d3326ba2d078583bef93930d909 + + + + ServiceReadySoon + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba22413357ade6b586f6ceb0d704f35075 + + + + DataConnectionAlreadyOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafa52d19bc813d69055f4cc390d4a76ca + + + + OpeningDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba794ebe743688be611447638bf9e49d86 + + + + Ok + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baa956e229ba6c0cdf0d88b0e05b286210 + + + + PointlessCommand + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba38adc424f1adcd332745de8cd3b7737a + + + + SystemStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9bdd02ae119b8be639e778859ee74060 + + + + DirectoryStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8729460a695013cc96330e2fced0ae1f + + + + FileStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baebddfc7997dca289c83068dff3f47dce + + + + HelpMessage + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba840fd2a1872fd4310b046541f57fdeb7 + + + + SystemType + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba78391f73aa11f07f1514c7d070b93c08 + + + + ServiceReady + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baea2ee2007d7843c21108bb686ef03757 + + + + ClosingConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bab23931490fc2d1df3081d651fe0f4d6e + + + + DataConnectionOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3badc78ed87d5bddb174fa3c16707ac2f2d + + + + ClosingDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bac723ebc8a38913bbf0d9504556cbaaa6 + + + + EnteringPassiveMode + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba48314fc47a72ad0aacdea93b91756f6e + + + + LoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba54a88210386cb72e35d737813a221754 + + + + FileActionOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf988b69b0a5f55f8122da5ba001932e0 + + + + DirectoryOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba06d26e95a170fc422af13def415e0437 + + + + NeedPassword + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9249e3fe9818eb93f181fbbf3ae3bc56 + + + + NeedAccountToLogIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9e048185f253f6eb6f5ff9e063b712fa + + + + NeedInformation + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba02e6f05964ecb829e9b6fb6020d6528a + + + + ServiceUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba43022ddf49b68a4f5aff0bea7e09e89f + + + + DataConnectionUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba757b89ff1f236941f7759b0ed0c28b88 + + + + TransferAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba7cfefcc586c12ba70f752353fde7126e + + + + FileActionAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf822d1b0abf3e9ae7dd44684549d512d + + + + LocalError + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bae54e84baaca95a7b36271ca3f3fdb900 + + + + InsufficientStorageSpace + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba5d9f3666222c808553c27e4e099c7c6d + + + + CommandUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba75bdf0b6844fa9c07b3c25647d22c269 + + + + ParametersUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf4c7c88815981bbb7c3a3461f9f48b67 + + + + CommandNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba2ca4834c756c81b924ebed696fcba0a8 + + + + BadCommandSequence + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad0c7ab07f01c1f7af16a1852650d7c47 + + + + ParameterNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8807473b8590e1debfb3740b7a3d081c + + + + NotLoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafcfbaff2c6fed941b6bcbc0999db764e + + + + NeedAccountToStore + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba1af0f173062a471739b50d8e0f40d5f7 + + + + FileUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba3f8f931e499936fde6b750d81f5ecfef + + + + PageTypeUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad220bc12dc45593af6e5079ea6c532c3 + + + + NotEnoughMemory + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf418e54753e0b8f9cb0325dd618acd14 + + + + FilenameNotAllowed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba03254aba823298179a98056e15568c5b + + + + InvalidResponse + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba59e041e4ef186e8ae8d6035973fc46bd + + + + ConnectionFailed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba51aa367cc1e85a45ea3c7be48730e990 + + + + ConnectionClosed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad1e5dcf298ce30c528261435f1a2eb53 + + + + InvalidFile + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baed2c74a9f335dee1463ca1a4f41c6478 + + + + RestartMarkerReply + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba07e06d3326ba2d078583bef93930d909 + + + + ServiceReadySoon + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba22413357ade6b586f6ceb0d704f35075 + + + + DataConnectionAlreadyOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafa52d19bc813d69055f4cc390d4a76ca + + + + OpeningDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba794ebe743688be611447638bf9e49d86 + + + + Ok + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baa956e229ba6c0cdf0d88b0e05b286210 + + + + PointlessCommand + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba38adc424f1adcd332745de8cd3b7737a + + + + SystemStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9bdd02ae119b8be639e778859ee74060 + + + + DirectoryStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8729460a695013cc96330e2fced0ae1f + + + + FileStatus + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baebddfc7997dca289c83068dff3f47dce + + + + HelpMessage + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba840fd2a1872fd4310b046541f57fdeb7 + + + + SystemType + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba78391f73aa11f07f1514c7d070b93c08 + + + + ServiceReady + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baea2ee2007d7843c21108bb686ef03757 + + + + ClosingConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bab23931490fc2d1df3081d651fe0f4d6e + + + + DataConnectionOpened + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3badc78ed87d5bddb174fa3c16707ac2f2d + + + + ClosingDataConnection + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bac723ebc8a38913bbf0d9504556cbaaa6 + + + + EnteringPassiveMode + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba48314fc47a72ad0aacdea93b91756f6e + + + + LoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba54a88210386cb72e35d737813a221754 + + + + FileActionOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf988b69b0a5f55f8122da5ba001932e0 + + + + DirectoryOk + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba06d26e95a170fc422af13def415e0437 + + + + NeedPassword + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9249e3fe9818eb93f181fbbf3ae3bc56 + + + + NeedAccountToLogIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba9e048185f253f6eb6f5ff9e063b712fa + + + + NeedInformation + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba02e6f05964ecb829e9b6fb6020d6528a + + + + ServiceUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba43022ddf49b68a4f5aff0bea7e09e89f + + + + DataConnectionUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba757b89ff1f236941f7759b0ed0c28b88 + + + + TransferAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba7cfefcc586c12ba70f752353fde7126e + + + + FileActionAborted + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf822d1b0abf3e9ae7dd44684549d512d + + + + LocalError + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bae54e84baaca95a7b36271ca3f3fdb900 + + + + InsufficientStorageSpace + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba5d9f3666222c808553c27e4e099c7c6d + + + + CommandUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba75bdf0b6844fa9c07b3c25647d22c269 + + + + ParametersUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf4c7c88815981bbb7c3a3461f9f48b67 + + + + CommandNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba2ca4834c756c81b924ebed696fcba0a8 + + + + BadCommandSequence + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad0c7ab07f01c1f7af16a1852650d7c47 + + + + ParameterNotImplemented + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba8807473b8590e1debfb3740b7a3d081c + + + + NotLoggedIn + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bafcfbaff2c6fed941b6bcbc0999db764e + + + + NeedAccountToStore + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba1af0f173062a471739b50d8e0f40d5f7 + + + + FileUnavailable + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba3f8f931e499936fde6b750d81f5ecfef + + + + PageTypeUnknown + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad220bc12dc45593af6e5079ea6c532c3 + + + + NotEnoughMemory + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baf418e54753e0b8f9cb0325dd618acd14 + + + + FilenameNotAllowed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba03254aba823298179a98056e15568c5b + + + + InvalidResponse + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba59e041e4ef186e8ae8d6035973fc46bd + + + + ConnectionFailed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3ba51aa367cc1e85a45ea3c7be48730e990 + + + + ConnectionClosed + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3bad1e5dcf298ce30c528261435f1a2eb53 + + + + InvalidFile + classsf_1_1Ftp_1_1Response.html + af81738f06b6f571761696291276acb3baed2c74a9f335dee1463ca1a4f41c6478 + + + + + Response + classsf_1_1Ftp_1_1Response.html + af300fffd4862774102f978eb22f85d9b + (Status code=InvalidResponse, const std::string &message="") + + + bool + isOk + classsf_1_1Ftp_1_1Response.html + a5102552955a2652c1a39e9046e617b36 + () const + + + Status + getStatus + classsf_1_1Ftp_1_1Response.html + a52bbca9fbf5451157bc055e3d8430c25 + () const + + + const std::string & + getMessage + classsf_1_1Ftp_1_1Response.html + adc2890c93c9f8ee997b828fcbef82c97 + () const + + + + sf::Http::Response + classsf_1_1Http_1_1Response.html + + + Status + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8 + + + + Ok + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a0158f932254d3f09647dd1f64bd43832 + + + + Created + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a0a6e8bafa9365a0ed10b8a9cbfd0649b + + + + Accepted + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8ad328945457bd2f0d65107ba6b5ccd443 + + + + NoContent + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8aefde9e4abf5682dcd314d63143be42e0 + + + + ResetContent + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a77327cc2a5e34cc64030b322e61d12a8 + + + + PartialContent + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a0cfae3ab0469b73dfddc54312a5e6a8a + + + + MultipleChoices + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8add95cbd8fa27516821f763488557f96b + + + + MovedPermanently + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a2f91651db3a09628faf68cbcefa0810a + + + + MovedTemporarily + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a05c50d7b17c844e0b909e5802d5f1587 + + + + NotModified + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a060ebc3af266e6bfe045b89e298e2545 + + + + BadRequest + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a3f88a714cf5483ee22f9051e5a3c080a + + + + Unauthorized + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8ab7a79b7bff50fb1902c19eecbb4e2a2d + + + + Forbidden + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a64492842e823ebe12a85539b6b454986 + + + + NotFound + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8affca8a8319a62d98bd3ef90ff5cfc030 + + + + RangeNotSatisfiable + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a12533d00093b190e6d4c0076577e2239 + + + + InternalServerError + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8adae2b2a936414349d55b4ed8c583fed1 + + + + NotImplemented + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a6920ba06d7e2bcf0b325da23ee95ef68 + + + + BadGateway + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8aad0cbad4cdaf448beb763e86bc1f747c + + + + ServiceNotAvailable + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8ac4fffba9d5ad4c14171a1bbe4f6adf87 + + + + GatewayTimeout + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a215935d823ab44694709a184a71353b0 + + + + VersionNotSupported + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8aeb32a1a087d5fcf1a42663eb40c3c305 + + + + InvalidResponse + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a0af0090420e60bf54da4860749345c95 + + + + ConnectionFailed + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a7f307376f13bdc06b24fc274ecd2aa60 + + + + Ok + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a0158f932254d3f09647dd1f64bd43832 + + + + Created + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a0a6e8bafa9365a0ed10b8a9cbfd0649b + + + + Accepted + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8ad328945457bd2f0d65107ba6b5ccd443 + + + + NoContent + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8aefde9e4abf5682dcd314d63143be42e0 + + + + ResetContent + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a77327cc2a5e34cc64030b322e61d12a8 + + + + PartialContent + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a0cfae3ab0469b73dfddc54312a5e6a8a + + + + MultipleChoices + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8add95cbd8fa27516821f763488557f96b + + + + MovedPermanently + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a2f91651db3a09628faf68cbcefa0810a + + + + MovedTemporarily + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a05c50d7b17c844e0b909e5802d5f1587 + + + + NotModified + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a060ebc3af266e6bfe045b89e298e2545 + + + + BadRequest + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a3f88a714cf5483ee22f9051e5a3c080a + + + + Unauthorized + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8ab7a79b7bff50fb1902c19eecbb4e2a2d + + + + Forbidden + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a64492842e823ebe12a85539b6b454986 + + + + NotFound + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8affca8a8319a62d98bd3ef90ff5cfc030 + + + + RangeNotSatisfiable + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a12533d00093b190e6d4c0076577e2239 + + + + InternalServerError + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8adae2b2a936414349d55b4ed8c583fed1 + + + + NotImplemented + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a6920ba06d7e2bcf0b325da23ee95ef68 + + + + BadGateway + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8aad0cbad4cdaf448beb763e86bc1f747c + + + + ServiceNotAvailable + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8ac4fffba9d5ad4c14171a1bbe4f6adf87 + + + + GatewayTimeout + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a215935d823ab44694709a184a71353b0 + + + + VersionNotSupported + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8aeb32a1a087d5fcf1a42663eb40c3c305 + + + + InvalidResponse + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a0af0090420e60bf54da4860749345c95 + + + + ConnectionFailed + classsf_1_1Http_1_1Response.html + a663e071978e30fbbeb20ed045be874d8a7f307376f13bdc06b24fc274ecd2aa60 + + + + + Response + classsf_1_1Http_1_1Response.html + a2e51c89356fe6a007c448a841a9ec08c + () + + + const std::string & + getField + classsf_1_1Http_1_1Response.html + ae16458c4e969206381b78587aa47c8dc + (const std::string &field) const + + + Status + getStatus + classsf_1_1Http_1_1Response.html + a4271651703764fd9a7d2c0315aff20de + () const + + + unsigned int + getMajorHttpVersion + classsf_1_1Http_1_1Response.html + ab1c6948f6444fad34d0537e206e398b8 + () const + + + unsigned int + getMinorHttpVersion + classsf_1_1Http_1_1Response.html + af3c649568d2e291e71c3a7da546bb392 + () const + + + const std::string & + getBody + classsf_1_1Http_1_1Response.html + ac59e2b11cae4b6232c737547a3ca9850 + () const + + + + sf::Keyboard::Scan + structsf_1_1Keyboard_1_1Scan.html + + + Scancode + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875 + + + + Unknown + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af29c5f0133653ccd3cbc947b51e97895 + + + + A + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af835596d7ce007d5c34c356dee6740c6 + + + + B + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5a277726531303b8ba5212999e9664cb + + + + C + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad3acc09d4a2dc958837e48b80af01a4c + + + + D + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a96ec4a613d00dce6f8d90adc8728864a + + + + E + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adc59d37687890a0efbac55992448e41f + + + + F + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a2d87edd4fa1f6ae355cabcccb5844ea3 + + + + G + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a21dc36f8ac9ff44d3c6aca6a66503264 + + + + H + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a40615dc67be807478f924c9aabf81915 + + + + I + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875acfe0506f6ce3d306b47134e99260d984 + + + + J + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aaf9b207522e37466a19f92b8dc836735 + + + + K + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a1e65a1d66582b430961cfc4e7cc76816 + + + + L + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ab6da0281265c57b9570de8be294d73b8 + + + + M + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5a8351cbbb24d61c47f146f414ef825d + + + + N + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a72b52a30a5f3aee77dc52e7c54c8db9f + + + + O + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aafe949e3a5c03b8981026f5b9621154b + + + + P + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a0943cf62e03a8616a8a41b72539ded38 + + + + Q + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af9b34314661202a2f73c2d71d95fcfeb + + + + R + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af04c2611e3ee0855a044927d5bd0e194 + + + + S + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3c650be640718237a3241e8da1602dae + + + + T + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a55bee4759c12cb033659e8d8de796ae9 + + + + U + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aeaecd56929398797033710d1cb274003 + + + + V + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875acf235c9f74c25df943ead5f38a01945a + + + + W + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a287b960abc4c422a8f4c1bbfc0dfd2a9 + + + + X + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af4f6ad0b93dd6bc360badd5abe812a67 + + + + Y + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6305407064e0beb4f0499166e087ff22 + + + + Z + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a2aca2d41fc86e4e31be7220d81ce589a + + + + Num1 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adbf8eb09afd75e2081b009ad7a3596ef + + + + Num2 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a16cfef5671ce6401aaf00316c88c0c7b + + + + Num3 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3301c6093c6f2a78158c1e44e3431227 + + + + Num4 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a15943e415124e0848e6b065d24b1b1e7 + + + + Num5 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875abf2de94b5156b86a228d7e5ec66d056a + + + + Num6 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6cd9d57ae648639eedcd16cb83da1af5 + + + + Num7 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aaf5540b714391414c06503b8aaee908a + + + + Num8 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aee7fee4dc6a4dbfe9e038a5366cc1e4b + + + + Num9 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af003329d2c5a26d0262caf3ddef0a45e + + + + Num0 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adb7e8aa25d5d5204de03a5aa1ee0b390 + + + + Enter + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adb4984ca4b4e90eae95e32bb0de29c8e + + + + Escape + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac8409d6faf55c88bc01c722c51e99b93 + + + + Backspace + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6621384ae8e5b8f0faf0b879c7813817 + + + + Tab + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa724a5e6b812f12b06957717fd78d4a3 + + + + Space + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a37fceb15fd79c29859aeb30e4b34237d + + + + Hyphen + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae6888d3715971e533b4379452cbae94a + + + + Equal + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6cd11681bbd83c0565c9c63e4d512a86 + + + + LBracket + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3e4bb5cf828df8c4660d323df8589c43 + + + + RBracket + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5b278a8f7b97c3972ec572412d855660 + + + + Backslash + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a01ce415ff140d34d25a7bdbbbb785287 + + + + Semicolon + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a60e05ed7eb42bf7d283d7ea4aafeef90 + + + + Apostrophe + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac391cefe75135833aea37c75293db820 + + + + Grave + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a813711cd9de71dab611b7155b36880f5 + + + + Comma + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a035f3ce4c48fecfd7d2c77987710e5fa + + + + Period + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae09b8ab0fa58ee31f499678d3e93a411 + + + + Slash + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5c37f9adf66e083d85950db1597c45f5 + + + + F1 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a60bdd99ca0d0ab177a65078a185333a6 + + + + F2 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3ea5468548feaccb419a8c4c160c16b0 + + + + F3 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af2e1be02540c0794302ec9e1d2262ef4 + + + + F4 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae4a9bcd1df4becc4994c676f44a5a101 + + + + F5 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a4fe3daf6c23906249b87f0ffffb458be + + + + F6 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3c3934e6efc54b366de1e27f5099276e + + + + F7 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5dc33031068713ce55bb332672d9bb9a + + + + F8 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae1faf360e99035dff729917bee051daa + + + + F9 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae0cb68ca4ec3844548d4e089ec9ea8c5 + + + + F10 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aee4c9257be218585114cf27602892572 + + + + F11 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5047f3be2633e101840945b58867be6e + + + + F12 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa068df80ff6d72b0bdab149e3a3d26af + + + + F13 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af3416f863ce92ae05b26aed80e72a52f + + + + F14 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a8589f17d8b4170b7f51711c1d6611f21 + + + + F15 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875acad0fde63b2171cc56d42a1d23d679ba + + + + F16 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a1c3d4ce6fc1826f1da081b942676cccd + + + + F17 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa416a15ec21b4957d740992f446a5224 + + + + F18 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae50807a7d06cc5324eac783bf4d0b96d + + + + F19 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a51ff7425b98bbcd8e777908de15f3d10 + + + + F20 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a06d01cd179c76fe33c2f61006176f076 + + + + F21 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad86a6e71ba08ffc8167d003b92cadb77 + + + + F22 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a538c92aa44eae29b23ef3c096c1b571b + + + + F23 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac66a8fea90d7307b434b4a09b0822202 + + + + F24 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a069f7f10bbdb13aeea8cfdebee4752f4 + + + + CapsLock + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6a1c1f6a4dfac0c5170296a88da1dd57 + + + + PrintScreen + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a8699683af17a0a4031bccf52f5222302 + + + + ScrollLock + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875abbf3aeeb831834f97684647c1495d333 + + + + Pause + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a40a805122e3ce91bde95d98ac43be234 + + + + Insert + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a8935170f7f2ea9ea6586c3c686edc72a + + + + Home + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae5d4c031080001f1449e3d55e8571e3a + + + + PageUp + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a0c1f655bf99a3c7d2052814385fb222d + + + + Delete + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a2f071cf261d91b0facc044c2ba11ae94 + + + + End + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a60da82f685e98127043da8ffd04b7442 + + + + PageDown + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a395ec644184fe789a12ee2ed98d19ee3 + + + + Right + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a03d293668313031e7ff7eb9b7894e5c7 + + + + Left + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a24060c475e1887a28d821b6174df10c9 + + + + Down + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a18774f082756cdee120731cd53689008 + + + + Up + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6b3aa7f474aba344035fb34c037cdc05 + + + + NumLock + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad1d1d7ce47ea768bcb565633fe9962b5 + + + + NumpadDivide + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac3dc3e9289a9b7db8aa346c3f02b327d + + + + NumpadMultiply + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875abd043b0e9270f97b4c1d6c2e4bf94288 + + + + NumpadMinus + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae48b0805330de77fbf671644d446a9ef + + + + NumpadPlus + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875abb76cfff74d39902a4c7b286520f1d5b + + + + NumpadEqual + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5b96402c34611cd5a7661c9c93e8dc0a + + + + NumpadEnter + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad6da599320b8c485ca42eb16e81d0ad0 + + + + NumpadDecimal + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a62ce565c4d62bcbd9a9af09f8d4f80df + + + + Numpad1 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac17746b6b36dc8b79a222fa73ef2501e + + + + Numpad2 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a53e419e5206289bcc16b4500bd8105af + + + + Numpad3 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a185a36e136a349d9073312919cede6a7 + + + + Numpad4 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a25c36d972efaf310f4f9d4ec23b89df5 + + + + Numpad5 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a8e370bc5b50d37f1ed280453fa6d47f6 + + + + Numpad6 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a58523c54f6cfb3844021e7a9526eb34b + + + + Numpad7 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3d0502d5ad29d2e8bdfd5e4ab03252ee + + + + Numpad8 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a74fda39289bc3e8ff17d4aec863b7029 + + + + Numpad9 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a335a1aa0289d7e582fdc924ca710cbc1 + + + + Numpad0 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5852c4163a2cacb7979415d09412d500 + + + + NonUsBackslash + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a44a8cbe245638c8431b233930f543a87 + + + + Application + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5a7f9d3ad8d2528dc7648b682b069211 + + + + Execute + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a12c94b4dc55153a952283aff554ae3a0 + + + + ModeChange + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adbd3b55bd8d0f7c790f30d5a5bb6660c + + + + Help + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a4e8eeeae3acd3740053d2041e22dbf95 + + + + Menu + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad74c4a46669c3bd59ef93154e4669632 + + + + Select + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a30a8160d16b2ee9cc2d56a1a3394efa1 + + + + Redo + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad7b33839e3d1dc8048ed4e32297113ad + + + + Undo + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac7476165cf08ca489e6949441d4e0715 + + + + Cut + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af5b15a621ad19b8f357821f7adfc6bb1 + + + + Copy + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a7ecdffb69ce6c849414e4a818d3103a7 + + + + Paste + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ab5417583410afc02cad51e66cb97b196 + + + + VolumeMute + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3af7a1640f764386171d4cba53e6d5e2 + + + + VolumeUp + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa76641e5826ca3a7fb09cefa4d922270 + + + + VolumeDown + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa32039062878ff1d9ed8fb062949f976 + + + + MediaPlayPause + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a421303fdaaa4cbcf571ff6905808b69b + + + + MediaStop + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6afe82e357291a40a03c85773eae734d + + + + MediaNextTrack + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a08b48a760a2a550f21b3b6b184797742 + + + + MediaPreviousTrack + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac2ac37264e076dcab002e24e54090dbc + + + + LControl + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa81bc64b2e4ca7eae223891075a1d754 + + + + LShift + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a99aa94c6db970fe2d06d6a0b265084d7 + + + + LAlt + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a9d640314aaa812b4646178409910043d + + + + LSystem + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5e1b12c4476475396c6f04eccbbf04f7 + + + + RControl + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ab80b18e7c688d4cd1bbb52b40b9699fe + + + + RShift + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a81b7e74173912d98493b62b13a7ed648 + + + + RAlt + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a2d6f466aef0f34d0d794d79362002ae3 + + + + RSystem + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a62f3504c695ca7968e710cfdc1d8c61b + + + + Back + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae5c30910d66a7706ec731fff17e552d2 + + + + Forward + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adb5993c42ae3794c0e755f8e4b4666ea + + + + Refresh + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a21a543fae6b497b61df6e58d315f9e12 + + + + Stop + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a03a70c06d505acb1473f68a63c712faa + + + + Search + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a1b0d59ec95a4d6b585cdc7f0756ff6f0 + + + + Favorites + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad54aa9735cb59fe6fbd9a54939dadb53 + + + + HomePage + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a97afbc93fdb29797ed0fbfe45b93b80d + + + + LaunchApplication1 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac195d6bb66bd43b6c89f70df8ecc7d4d + + + + LaunchApplication2 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a7fd8f0dfcbccd3e4c72269f8159b2170 + + + + LaunchMail + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ab91775c7cc9288d35cadc11bc65b6994 + + + + LaunchMediaSelect + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a200b5a6f78bebcf697bb4e046c41fe4c + + + + ScancodeCount + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a28c5ad8524e1e653b43440e660d441d0 + + + + Unknown + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af29c5f0133653ccd3cbc947b51e97895 + + + + A + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af835596d7ce007d5c34c356dee6740c6 + + + + B + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5a277726531303b8ba5212999e9664cb + + + + C + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad3acc09d4a2dc958837e48b80af01a4c + + + + D + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a96ec4a613d00dce6f8d90adc8728864a + + + + E + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adc59d37687890a0efbac55992448e41f + + + + F + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a2d87edd4fa1f6ae355cabcccb5844ea3 + + + + G + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a21dc36f8ac9ff44d3c6aca6a66503264 + + + + H + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a40615dc67be807478f924c9aabf81915 + + + + I + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875acfe0506f6ce3d306b47134e99260d984 + + + + J + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aaf9b207522e37466a19f92b8dc836735 + + + + K + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a1e65a1d66582b430961cfc4e7cc76816 + + + + L + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ab6da0281265c57b9570de8be294d73b8 + + + + M + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5a8351cbbb24d61c47f146f414ef825d + + + + N + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a72b52a30a5f3aee77dc52e7c54c8db9f + + + + O + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aafe949e3a5c03b8981026f5b9621154b + + + + P + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a0943cf62e03a8616a8a41b72539ded38 + + + + Q + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af9b34314661202a2f73c2d71d95fcfeb + + + + R + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af04c2611e3ee0855a044927d5bd0e194 + + + + S + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3c650be640718237a3241e8da1602dae + + + + T + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a55bee4759c12cb033659e8d8de796ae9 + + + + U + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aeaecd56929398797033710d1cb274003 + + + + V + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875acf235c9f74c25df943ead5f38a01945a + + + + W + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a287b960abc4c422a8f4c1bbfc0dfd2a9 + + + + X + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af4f6ad0b93dd6bc360badd5abe812a67 + + + + Y + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6305407064e0beb4f0499166e087ff22 + + + + Z + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a2aca2d41fc86e4e31be7220d81ce589a + + + + Num1 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adbf8eb09afd75e2081b009ad7a3596ef + + + + Num2 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a16cfef5671ce6401aaf00316c88c0c7b + + + + Num3 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3301c6093c6f2a78158c1e44e3431227 + + + + Num4 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a15943e415124e0848e6b065d24b1b1e7 + + + + Num5 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875abf2de94b5156b86a228d7e5ec66d056a + + + + Num6 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6cd9d57ae648639eedcd16cb83da1af5 + + + + Num7 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aaf5540b714391414c06503b8aaee908a + + + + Num8 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aee7fee4dc6a4dbfe9e038a5366cc1e4b + + + + Num9 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af003329d2c5a26d0262caf3ddef0a45e + + + + Num0 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adb7e8aa25d5d5204de03a5aa1ee0b390 + + + + Enter + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adb4984ca4b4e90eae95e32bb0de29c8e + + + + Escape + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac8409d6faf55c88bc01c722c51e99b93 + + + + Backspace + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6621384ae8e5b8f0faf0b879c7813817 + + + + Tab + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa724a5e6b812f12b06957717fd78d4a3 + + + + Space + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a37fceb15fd79c29859aeb30e4b34237d + + + + Hyphen + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae6888d3715971e533b4379452cbae94a + + + + Equal + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6cd11681bbd83c0565c9c63e4d512a86 + + + + LBracket + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3e4bb5cf828df8c4660d323df8589c43 + + + + RBracket + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5b278a8f7b97c3972ec572412d855660 + + + + Backslash + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a01ce415ff140d34d25a7bdbbbb785287 + + + + Semicolon + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a60e05ed7eb42bf7d283d7ea4aafeef90 + + + + Apostrophe + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac391cefe75135833aea37c75293db820 + + + + Grave + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a813711cd9de71dab611b7155b36880f5 + + + + Comma + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a035f3ce4c48fecfd7d2c77987710e5fa + + + + Period + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae09b8ab0fa58ee31f499678d3e93a411 + + + + Slash + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5c37f9adf66e083d85950db1597c45f5 + + + + F1 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a60bdd99ca0d0ab177a65078a185333a6 + + + + F2 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3ea5468548feaccb419a8c4c160c16b0 + + + + F3 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af2e1be02540c0794302ec9e1d2262ef4 + + + + F4 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae4a9bcd1df4becc4994c676f44a5a101 + + + + F5 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a4fe3daf6c23906249b87f0ffffb458be + + + + F6 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3c3934e6efc54b366de1e27f5099276e + + + + F7 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5dc33031068713ce55bb332672d9bb9a + + + + F8 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae1faf360e99035dff729917bee051daa + + + + F9 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae0cb68ca4ec3844548d4e089ec9ea8c5 + + + + F10 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aee4c9257be218585114cf27602892572 + + + + F11 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5047f3be2633e101840945b58867be6e + + + + F12 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa068df80ff6d72b0bdab149e3a3d26af + + + + F13 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af3416f863ce92ae05b26aed80e72a52f + + + + F14 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a8589f17d8b4170b7f51711c1d6611f21 + + + + F15 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875acad0fde63b2171cc56d42a1d23d679ba + + + + F16 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a1c3d4ce6fc1826f1da081b942676cccd + + + + F17 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa416a15ec21b4957d740992f446a5224 + + + + F18 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae50807a7d06cc5324eac783bf4d0b96d + + + + F19 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a51ff7425b98bbcd8e777908de15f3d10 + + + + F20 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a06d01cd179c76fe33c2f61006176f076 + + + + F21 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad86a6e71ba08ffc8167d003b92cadb77 + + + + F22 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a538c92aa44eae29b23ef3c096c1b571b + + + + F23 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac66a8fea90d7307b434b4a09b0822202 + + + + F24 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a069f7f10bbdb13aeea8cfdebee4752f4 + + + + CapsLock + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6a1c1f6a4dfac0c5170296a88da1dd57 + + + + PrintScreen + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a8699683af17a0a4031bccf52f5222302 + + + + ScrollLock + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875abbf3aeeb831834f97684647c1495d333 + + + + Pause + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a40a805122e3ce91bde95d98ac43be234 + + + + Insert + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a8935170f7f2ea9ea6586c3c686edc72a + + + + Home + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae5d4c031080001f1449e3d55e8571e3a + + + + PageUp + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a0c1f655bf99a3c7d2052814385fb222d + + + + Delete + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a2f071cf261d91b0facc044c2ba11ae94 + + + + End + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a60da82f685e98127043da8ffd04b7442 + + + + PageDown + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a395ec644184fe789a12ee2ed98d19ee3 + + + + Right + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a03d293668313031e7ff7eb9b7894e5c7 + + + + Left + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a24060c475e1887a28d821b6174df10c9 + + + + Down + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a18774f082756cdee120731cd53689008 + + + + Up + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6b3aa7f474aba344035fb34c037cdc05 + + + + NumLock + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad1d1d7ce47ea768bcb565633fe9962b5 + + + + NumpadDivide + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac3dc3e9289a9b7db8aa346c3f02b327d + + + + NumpadMultiply + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875abd043b0e9270f97b4c1d6c2e4bf94288 + + + + NumpadMinus + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae48b0805330de77fbf671644d446a9ef + + + + NumpadPlus + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875abb76cfff74d39902a4c7b286520f1d5b + + + + NumpadEqual + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5b96402c34611cd5a7661c9c93e8dc0a + + + + NumpadEnter + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad6da599320b8c485ca42eb16e81d0ad0 + + + + NumpadDecimal + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a62ce565c4d62bcbd9a9af09f8d4f80df + + + + Numpad1 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac17746b6b36dc8b79a222fa73ef2501e + + + + Numpad2 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a53e419e5206289bcc16b4500bd8105af + + + + Numpad3 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a185a36e136a349d9073312919cede6a7 + + + + Numpad4 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a25c36d972efaf310f4f9d4ec23b89df5 + + + + Numpad5 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a8e370bc5b50d37f1ed280453fa6d47f6 + + + + Numpad6 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a58523c54f6cfb3844021e7a9526eb34b + + + + Numpad7 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3d0502d5ad29d2e8bdfd5e4ab03252ee + + + + Numpad8 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a74fda39289bc3e8ff17d4aec863b7029 + + + + Numpad9 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a335a1aa0289d7e582fdc924ca710cbc1 + + + + Numpad0 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5852c4163a2cacb7979415d09412d500 + + + + NonUsBackslash + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a44a8cbe245638c8431b233930f543a87 + + + + Application + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5a7f9d3ad8d2528dc7648b682b069211 + + + + Execute + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a12c94b4dc55153a952283aff554ae3a0 + + + + ModeChange + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adbd3b55bd8d0f7c790f30d5a5bb6660c + + + + Help + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a4e8eeeae3acd3740053d2041e22dbf95 + + + + Menu + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad74c4a46669c3bd59ef93154e4669632 + + + + Select + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a30a8160d16b2ee9cc2d56a1a3394efa1 + + + + Redo + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad7b33839e3d1dc8048ed4e32297113ad + + + + Undo + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac7476165cf08ca489e6949441d4e0715 + + + + Cut + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875af5b15a621ad19b8f357821f7adfc6bb1 + + + + Copy + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a7ecdffb69ce6c849414e4a818d3103a7 + + + + Paste + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ab5417583410afc02cad51e66cb97b196 + + + + VolumeMute + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a3af7a1640f764386171d4cba53e6d5e2 + + + + VolumeUp + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa76641e5826ca3a7fb09cefa4d922270 + + + + VolumeDown + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa32039062878ff1d9ed8fb062949f976 + + + + MediaPlayPause + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a421303fdaaa4cbcf571ff6905808b69b + + + + MediaStop + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a6afe82e357291a40a03c85773eae734d + + + + MediaNextTrack + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a08b48a760a2a550f21b3b6b184797742 + + + + MediaPreviousTrack + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac2ac37264e076dcab002e24e54090dbc + + + + LControl + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875aa81bc64b2e4ca7eae223891075a1d754 + + + + LShift + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a99aa94c6db970fe2d06d6a0b265084d7 + + + + LAlt + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a9d640314aaa812b4646178409910043d + + + + LSystem + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a5e1b12c4476475396c6f04eccbbf04f7 + + + + RControl + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ab80b18e7c688d4cd1bbb52b40b9699fe + + + + RShift + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a81b7e74173912d98493b62b13a7ed648 + + + + RAlt + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a2d6f466aef0f34d0d794d79362002ae3 + + + + RSystem + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a62f3504c695ca7968e710cfdc1d8c61b + + + + Back + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ae5c30910d66a7706ec731fff17e552d2 + + + + Forward + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875adb5993c42ae3794c0e755f8e4b4666ea + + + + Refresh + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a21a543fae6b497b61df6e58d315f9e12 + + + + Stop + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a03a70c06d505acb1473f68a63c712faa + + + + Search + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a1b0d59ec95a4d6b585cdc7f0756ff6f0 + + + + Favorites + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ad54aa9735cb59fe6fbd9a54939dadb53 + + + + HomePage + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a97afbc93fdb29797ed0fbfe45b93b80d + + + + LaunchApplication1 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ac195d6bb66bd43b6c89f70df8ecc7d4d + + + + LaunchApplication2 + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a7fd8f0dfcbccd3e4c72269f8159b2170 + + + + LaunchMail + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875ab91775c7cc9288d35cadc11bc65b6994 + + + + LaunchMediaSelect + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a200b5a6f78bebcf697bb4e046c41fe4c + + + + ScancodeCount + structsf_1_1Keyboard_1_1Scan.html + aa42fbf6954d6f81f7606e566c7abe875a28c5ad8524e1e653b43440e660d441d0 + + + + + sf::Sensor + classsf_1_1Sensor.html + + + Type + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84 + + + + Accelerometer + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84a11bc58199593e217de23641755ecc867 + + + + Gyroscope + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84a1c43984aacd29b1fda5356883fb19656 + + + + Magnetometer + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84ae706bb678bde8d3c370e246ffde6a63d + + + + Gravity + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84afab4d098cc64e791a0c4a9ef6b32db92 + + + + UserAcceleration + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84ad3a399e0025892b7c53e8767cebb9215 + + + + Orientation + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84aa428c5260446555de87c69b65f6edf00 + + + + Count + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84afcb4a80eb9e3f927c5837207a1b9eb29 + + + + Accelerometer + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84a11bc58199593e217de23641755ecc867 + + + + Gyroscope + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84a1c43984aacd29b1fda5356883fb19656 + + + + Magnetometer + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84ae706bb678bde8d3c370e246ffde6a63d + + + + Gravity + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84afab4d098cc64e791a0c4a9ef6b32db92 + + + + UserAcceleration + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84ad3a399e0025892b7c53e8767cebb9215 + + + + Orientation + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84aa428c5260446555de87c69b65f6edf00 + + + + Count + classsf_1_1Sensor.html + a687375af3ab77b818fca73735bcaea84afcb4a80eb9e3f927c5837207a1b9eb29 + + + + static bool + isAvailable + classsf_1_1Sensor.html + a7b7a2570218221781233bd495323abf0 + (Type sensor) + + + static void + setEnabled + classsf_1_1Sensor.html + afb31c5697d2e0a5fec70d702ec1d6cd9 + (Type sensor, bool enabled) + + + static Vector3f + getValue + classsf_1_1Sensor.html + ab9a2710f55ead2f7b4e1b0bead34457e + (Type sensor) + + + + sf::Event::SensorEvent + structsf_1_1Event_1_1SensorEvent.html + + Sensor::Type + type + structsf_1_1Event_1_1SensorEvent.html + abee7d67bf0947fd1138e4466011e2436 + + + + float + x + structsf_1_1Event_1_1SensorEvent.html + aa6ccbd13c181b866a6467462158d93d9 + + + + float + y + structsf_1_1Event_1_1SensorEvent.html + aecafcd25ecb3ba486e42284e4bb69a57 + + + + float + z + structsf_1_1Event_1_1SensorEvent.html + a5704e0d0b82b07f051cc858894f3ea43 + + + + + sf::Shader + classsf_1_1Shader.html + sf::GlResource + sf::NonCopyable + sf::Shader::CurrentTextureType + + + Type + classsf_1_1Shader.html + afaa1aa65e5de37b74d047da9def9f9b3 + + + + Vertex + classsf_1_1Shader.html + afaa1aa65e5de37b74d047da9def9f9b3a8718008f827eb32e29bbdd1791c62dce + + + + Geometry + classsf_1_1Shader.html + afaa1aa65e5de37b74d047da9def9f9b3a812421100fd57456727375938fb62788 + + + + Fragment + classsf_1_1Shader.html + afaa1aa65e5de37b74d047da9def9f9b3ace6e88eec3a56b2e55ee3c8e64e9b89a + + + + Vertex + classsf_1_1Shader.html + afaa1aa65e5de37b74d047da9def9f9b3a8718008f827eb32e29bbdd1791c62dce + + + + Geometry + classsf_1_1Shader.html + afaa1aa65e5de37b74d047da9def9f9b3a812421100fd57456727375938fb62788 + + + + Fragment + classsf_1_1Shader.html + afaa1aa65e5de37b74d047da9def9f9b3ace6e88eec3a56b2e55ee3c8e64e9b89a + + + + + Shader + classsf_1_1Shader.html + a1d7f28f26b4122959fcafec871c2c3c5 + () + + + + ~Shader + classsf_1_1Shader.html + a4bac6cc8b046ecd8fb967c145a2380e6 + () + + + bool + loadFromFile + classsf_1_1Shader.html + a053a5632848ebaca2fcd8ba29abe9e6e + (const std::string &filename, Type type) + + + bool + loadFromFile + classsf_1_1Shader.html + ac9d7289966fcef562eeb92271c03e3dc + (const std::string &vertexShaderFilename, const std::string &fragmentShaderFilename) + + + bool + loadFromFile + classsf_1_1Shader.html + a295d8468811ca15bf9c5401a7a7d4f54 + (const std::string &vertexShaderFilename, const std::string &geometryShaderFilename, const std::string &fragmentShaderFilename) + + + bool + loadFromMemory + classsf_1_1Shader.html + ac92d46bf71dff2d791117e4e472148aa + (const std::string &shader, Type type) + + + bool + loadFromMemory + classsf_1_1Shader.html + ae34e94070d7547a890166b7993658a9b + (const std::string &vertexShader, const std::string &fragmentShader) + + + bool + loadFromMemory + classsf_1_1Shader.html + ab8c8b715b02aba2cf7c0a0e0c0984250 + (const std::string &vertexShader, const std::string &geometryShader, const std::string &fragmentShader) + + + bool + loadFromStream + classsf_1_1Shader.html + a2ee1b130c0606e4f8bcdf65c1efc2a53 + (InputStream &stream, Type type) + + + bool + loadFromStream + classsf_1_1Shader.html + a3b7958159ffb5596c4babc3052e35465 + (InputStream &vertexShaderStream, InputStream &fragmentShaderStream) + + + bool + loadFromStream + classsf_1_1Shader.html + aa08f1c091806205e6654db9d83197fcd + (InputStream &vertexShaderStream, InputStream &geometryShaderStream, InputStream &fragmentShaderStream) + + + void + setUniform + classsf_1_1Shader.html + abf78e3bea1e9b0bab850b6b0a0de29c7 + (const std::string &name, float x) + + + void + setUniform + classsf_1_1Shader.html + a4a2c673c41e37b17d67e4af1298b679f + (const std::string &name, const Glsl::Vec2 &vector) + + + void + setUniform + classsf_1_1Shader.html + aad654ad8de6f0c56191fa7b8cea21db2 + (const std::string &name, const Glsl::Vec3 &vector) + + + void + setUniform + classsf_1_1Shader.html + abc1aee8343800680fd62e1f3d43c24bf + (const std::string &name, const Glsl::Vec4 &vector) + + + void + setUniform + classsf_1_1Shader.html + ae4fc8b4c18e6b653952bce5c8c81e4a0 + (const std::string &name, int x) + + + void + setUniform + classsf_1_1Shader.html + a2ccb5bae59cedc7d6a9b533c97f7d1ed + (const std::string &name, const Glsl::Ivec2 &vector) + + + void + setUniform + classsf_1_1Shader.html + a9e328e3e97cd753fdc7b842f4b0f202e + (const std::string &name, const Glsl::Ivec3 &vector) + + + void + setUniform + classsf_1_1Shader.html + a380e7a5a2896162c5fd08966c4523790 + (const std::string &name, const Glsl::Ivec4 &vector) + + + void + setUniform + classsf_1_1Shader.html + af417027ac72c06e6cfbf30975cd678e9 + (const std::string &name, bool x) + + + void + setUniform + classsf_1_1Shader.html + ab2518b8dd0762e682b452a5d5005f2bf + (const std::string &name, const Glsl::Bvec2 &vector) + + + void + setUniform + classsf_1_1Shader.html + ab06830875c82476fbb9c975cdeb78a11 + (const std::string &name, const Glsl::Bvec3 &vector) + + + void + setUniform + classsf_1_1Shader.html + ac8db3e0adf1129abf24f0a51a7ec36f4 + (const std::string &name, const Glsl::Bvec4 &vector) + + + void + setUniform + classsf_1_1Shader.html + ac1198ae0152d439bc05781046883e281 + (const std::string &name, const Glsl::Mat3 &matrix) + + + void + setUniform + classsf_1_1Shader.html + aca5c55c4a3b23d21e33dbdaab7990755 + (const std::string &name, const Glsl::Mat4 &matrix) + + + void + setUniform + classsf_1_1Shader.html + a7806a29ffbd0ee9251256a9e7265d479 + (const std::string &name, const Texture &texture) + + + void + setUniform + classsf_1_1Shader.html + ab18f531e1f726b88fec1cf5a1e6af26d + (const std::string &name, CurrentTextureType) + + + void + setUniformArray + classsf_1_1Shader.html + a731d3b9953c50fe7d3fb03340b97deff + (const std::string &name, const float *scalarArray, std::size_t length) + + + void + setUniformArray + classsf_1_1Shader.html + ab2e2eab45d9a091f3720c0879a5bb026 + (const std::string &name, const Glsl::Vec2 *vectorArray, std::size_t length) + + + void + setUniformArray + classsf_1_1Shader.html + aeae884292fed977bbea5039818f208e7 + (const std::string &name, const Glsl::Vec3 *vectorArray, std::size_t length) + + + void + setUniformArray + classsf_1_1Shader.html + aa89ac1ea7918c9b1c2232df59affb7fa + (const std::string &name, const Glsl::Vec4 *vectorArray, std::size_t length) + + + void + setUniformArray + classsf_1_1Shader.html + a69587701d347ba21d506197d0fb9f842 + (const std::string &name, const Glsl::Mat3 *matrixArray, std::size_t length) + + + void + setUniformArray + classsf_1_1Shader.html + a066b0ba02e1c1bddc9e2571eca1156ab + (const std::string &name, const Glsl::Mat4 *matrixArray, std::size_t length) + + + void + setParameter + classsf_1_1Shader.html + a47e4dd78f0752ae08664b4ee616db1cf + (const std::string &name, float x) + + + void + setParameter + classsf_1_1Shader.html + ab8d379f40810b8e3eadebee81aedd231 + (const std::string &name, float x, float y) + + + void + setParameter + classsf_1_1Shader.html + a7e36e044d6b8adca8339f40c5a4b1801 + (const std::string &name, float x, float y, float z) + + + void + setParameter + classsf_1_1Shader.html + aeb468f1bc2d26750b96b74f1e19027fb + (const std::string &name, float x, float y, float z, float w) + + + void + setParameter + classsf_1_1Shader.html + a3ac473ece2c6fa26dc5032c07fd7288e + (const std::string &name, const Vector2f &vector) + + + void + setParameter + classsf_1_1Shader.html + a87d4a0c6dc70ae68aecc0dda3f343c07 + (const std::string &name, const Vector3f &vector) + + + void + setParameter + classsf_1_1Shader.html + aa8618119ed4399df3fd33e78ee96b4fc + (const std::string &name, const Color &color) + + + void + setParameter + classsf_1_1Shader.html + a8599ee1348407025039b89ddf3f7cb62 + (const std::string &name, const Transform &transform) + + + void + setParameter + classsf_1_1Shader.html + a7f58ab5c0a1084f238dfcec86602daa1 + (const std::string &name, const Texture &texture) + + + void + setParameter + classsf_1_1Shader.html + af06b4cba0bab915fa01032b063909044 + (const std::string &name, CurrentTextureType) + + + unsigned int + getNativeHandle + classsf_1_1Shader.html + ac14d0bf7afe7b6bb415d309f9c707188 + () const + + + static void + bind + classsf_1_1Shader.html + a09778f78afcbeb854d608c8dacd8ea30 + (const Shader *shader) + + + static bool + isAvailable + classsf_1_1Shader.html + ad22474690bafe4a305c1b9826b1bd86a + () + + + static bool + isGeometryAvailable + classsf_1_1Shader.html + a45db14baf1bbc688577f81813b1fce96 + () + + + static CurrentTextureType + CurrentTexture + classsf_1_1Shader.html + ac84c7953eec2e19358ea6e2cc5385b8d + + + + + sf::Shape + classsf_1_1Shape.html + sf::Drawable + sf::Transformable + + virtual + ~Shape + classsf_1_1Shape.html + a2262aceb9df52d4275c19633592f19bf + () + + + void + setTexture + classsf_1_1Shape.html + af8fb22bab1956325be5d62282711e3b6 + (const Texture *texture, bool resetRect=false) + + + void + setTextureRect + classsf_1_1Shape.html + a2029cc820d1740d14ac794b82525e157 + (const IntRect &rect) + + + void + setFillColor + classsf_1_1Shape.html + a3506f9b5d916fec14d583d16f23c2485 + (const Color &color) + + + void + setOutlineColor + classsf_1_1Shape.html + a5978f41ee349ac3c52942996dcb184f7 + (const Color &color) + + + void + setOutlineThickness + classsf_1_1Shape.html + a5ad336ad74fc1f567fce3b7e44cf87dc + (float thickness) + + + const Texture * + getTexture + classsf_1_1Shape.html + af4c345931cd651ffb8f7a177446e28f7 + () const + + + const IntRect & + getTextureRect + classsf_1_1Shape.html + ad8adbb54823c8eff1830a938e164daa4 + () const + + + const Color & + getFillColor + classsf_1_1Shape.html + aa5da23e522d2dd11e3e7661c26164c78 + () const + + + const Color & + getOutlineColor + classsf_1_1Shape.html + a4aa05b59851468e948ac9682b9c71abb + () const + + + float + getOutlineThickness + classsf_1_1Shape.html + a1d4d5299c573a905e5833fc4dce783a7 + () const + + + virtual std::size_t + getPointCount + classsf_1_1Shape.html + af988dd61a29803fc04d02198e44b5643 + () const =0 + + + virtual Vector2f + getPoint + classsf_1_1Shape.html + a40e5d83713eb9f0c999944cf96458085 + (std::size_t index) const =0 + + + FloatRect + getLocalBounds + classsf_1_1Shape.html + ae3294bcdf8713d33a862242ecf706443 + () const + + + FloatRect + getGlobalBounds + classsf_1_1Shape.html + ac0e29425d908d5442060cc44790fe4da + () const + + + void + setPosition + classsf_1_1Transformable.html + a4dbfb1a7c80688b0b4c477d706550208 + (float x, float y) + + + void + setPosition + classsf_1_1Transformable.html + af1a42209ce2b5d3f07b00f917bcd8015 + (const Vector2f &position) + + + void + setRotation + classsf_1_1Transformable.html + a32baf2bf1a74699b03bf8c95030a38ed + (float angle) + + + void + setScale + classsf_1_1Transformable.html + aaec50b46b3f41b054763304d1e727471 + (float factorX, float factorY) + + + void + setScale + classsf_1_1Transformable.html + a4c48a87f1626047e448f9c1a68ff167e + (const Vector2f &factors) + + + void + setOrigin + classsf_1_1Transformable.html + a56c67bd80aae8418d13fb96c034d25ec + (float x, float y) + + + void + setOrigin + classsf_1_1Transformable.html + aa93a835ffbf3bee2098dfbbc695a7f05 + (const Vector2f &origin) + + + const Vector2f & + getPosition + classsf_1_1Transformable.html + aea8b18e91a7bf7be589851bb9dd11241 + () const + + + float + getRotation + classsf_1_1Transformable.html + aa00b5c5d4a06ac24a94dd72c56931d3a + () const + + + const Vector2f & + getScale + classsf_1_1Transformable.html + a7bcae0e924213f2e89edd8926f2453af + () const + + + const Vector2f & + getOrigin + classsf_1_1Transformable.html + a898b33eb6513161eb5c747a072364f15 + () const + + + void + move + classsf_1_1Transformable.html + a86b461d6a941ad390c2ad8b6a4a20391 + (float offsetX, float offsetY) + + + void + move + classsf_1_1Transformable.html + ab9ca691522f6ddc1a40406849b87c469 + (const Vector2f &offset) + + + void + rotate + classsf_1_1Transformable.html + af8a5ffddc0d93f238fee3bf8efe1ebda + (float angle) + + + void + scale + classsf_1_1Transformable.html + a3de0c6d8957f3cf318092f3f60656391 + (float factorX, float factorY) + + + void + scale + classsf_1_1Transformable.html + adecaa6c69b1f27dd5194b067d96bb694 + (const Vector2f &factor) + + + const Transform & + getTransform + classsf_1_1Transformable.html + a3e1b4772a451ec66ac7e6af655726154 + () const + + + const Transform & + getInverseTransform + classsf_1_1Transformable.html + ac5e75d724436069d2268791c6b486916 + () const + + + + Shape + classsf_1_1Shape.html + a413a457f720835b9f5d8e97ca8b80960 + () + + + void + update + classsf_1_1Shape.html + adfb2bd966c8edbc5d6c92ebc375e4ac1 + () + + + + sf::Event::SizeEvent + structsf_1_1Event_1_1SizeEvent.html + + unsigned int + width + structsf_1_1Event_1_1SizeEvent.html + a20ea1b78c9bb1604432f8f0067bbfd94 + + + + unsigned int + height + structsf_1_1Event_1_1SizeEvent.html + af0f76a599d5f48189cb8d78d4e5facdb + + + + + sf::Socket + classsf_1_1Socket.html + sf::NonCopyable + + + Status + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dc + + + + Done + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1de3a85bc56d3ae85b3d0f3cfd04ae90 + + + + NotReady + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca8554848daae98f996e131bdeed076c09 + + + + Partial + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca181c163fad2eaea927185d127c392706 + + + + Disconnected + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dcab215141f756acdc23c67fad149710eb1 + + + + Error + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1dc9854433a28c22e192721179a2df5d + + + + AnyPort + classsf_1_1Socket.html + aa3e6c984bcb81a35234dcc9cc8369d75a5a3c30fd128895403afc11076f461b19 + + + + Done + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1de3a85bc56d3ae85b3d0f3cfd04ae90 + + + + NotReady + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca8554848daae98f996e131bdeed076c09 + + + + Partial + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca181c163fad2eaea927185d127c392706 + + + + Disconnected + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dcab215141f756acdc23c67fad149710eb1 + + + + Error + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1dc9854433a28c22e192721179a2df5d + + + + AnyPort + classsf_1_1Socket.html + aa3e6c984bcb81a35234dcc9cc8369d75a5a3c30fd128895403afc11076f461b19 + + + + virtual + ~Socket + classsf_1_1Socket.html + a79a4b5918f0b34a2f8db449089694788 + () + + + void + setBlocking + classsf_1_1Socket.html + a165fc1423e281ea2714c70303d3a9782 + (bool blocking) + + + bool + isBlocking + classsf_1_1Socket.html + ab1ceca9ac114b8baeeda3b34a0aca468 + () const + + + + Type + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8 + + + + Tcp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8acc02e97e90234b957eaad4dff7f22214 + + + + Udp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8a6ebf3094830db4820191a327f3cc6ce2 + + + + Tcp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8acc02e97e90234b957eaad4dff7f22214 + + + + Udp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8a6ebf3094830db4820191a327f3cc6ce2 + + + + + Socket + classsf_1_1Socket.html + a80ffb47ec0bafc83af019055d3e6a303 + (Type type) + + + SocketHandle + getHandle + classsf_1_1Socket.html + a675457784284ae2f5640bbbe16729393 + () const + + + void + create + classsf_1_1Socket.html + aafbe140f4b1921e0d19e88cf7a61dcbc + () + + + void + create + classsf_1_1Socket.html + af1dd898f7aa3ead7ff7b2d1c20e97781 + (SocketHandle handle) + + + void + close + classsf_1_1Socket.html + a71f2f5c2aa99e01cafe824fee4c573be + () + + + + sf::SocketSelector + classsf_1_1SocketSelector.html + + + SocketSelector + classsf_1_1SocketSelector.html + a741959c5158aeb1e4457cad47d90f76b + () + + + + SocketSelector + classsf_1_1SocketSelector.html + a50b1b955eb7ecb2e7c2764f3f4722fbf + (const SocketSelector &copy) + + + + ~SocketSelector + classsf_1_1SocketSelector.html + a9069cd61208260b8ed9cf233afa1f73d + () + + + void + add + classsf_1_1SocketSelector.html + ade952013232802ff7b9b33668f8d2096 + (Socket &socket) + + + void + remove + classsf_1_1SocketSelector.html + a98b6ab693a65b82caa375639232357c1 + (Socket &socket) + + + void + clear + classsf_1_1SocketSelector.html + a76e650acb0199d4be91e90a493fbc91a + () + + + bool + wait + classsf_1_1SocketSelector.html + a9cfda5475f17925e65889394d70af702 + (Time timeout=Time::Zero) + + + bool + isReady + classsf_1_1SocketSelector.html + a917a4bac708290a6782e6686fd3bf889 + (Socket &socket) const + + + SocketSelector & + operator= + classsf_1_1SocketSelector.html + af7247f1c8badd43932f3adcbc1fec7e8 + (const SocketSelector &right) + + + + sf::Sound + classsf_1_1Sound.html + sf::SoundSource + + + Status + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03 + + + + Stopped + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03adabb01e8aa85b2f54b344890addf764a + + + + Paused + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03ac3ca1fcc0394267c9bdbe3dc0a8a7e41 + + + + Playing + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03af07bdea9f70ef7606dfc9f955beeee18 + + + + Stopped + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03adabb01e8aa85b2f54b344890addf764a + + + + Paused + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03ac3ca1fcc0394267c9bdbe3dc0a8a7e41 + + + + Playing + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03af07bdea9f70ef7606dfc9f955beeee18 + + + + + Sound + classsf_1_1Sound.html + a36ab74beaaa953d9879c933ddd246282 + () + + + + Sound + classsf_1_1Sound.html + a3b1cfc19a856d4ff8c079ee41bb78e69 + (const SoundBuffer &buffer) + + + + Sound + classsf_1_1Sound.html + ae05eeed6377932694d86b3011be366c0 + (const Sound &copy) + + + + ~Sound + classsf_1_1Sound.html + ad0792c35310eba2dffd8489c80fad076 + () + + + void + play + classsf_1_1Sound.html + a2953ffe632536e72e696fd880ced2532 + () + + + void + pause + classsf_1_1Sound.html + a5eeb25815bfa8cdc4a6cc000b7b19ad5 + () + + + void + stop + classsf_1_1Sound.html + aa9c91c34f7c6d344d5ee9b997511f754 + () + + + void + setBuffer + classsf_1_1Sound.html + a8b395e9713d0efa48a18628c8ec1972e + (const SoundBuffer &buffer) + + + void + setLoop + classsf_1_1Sound.html + af23ab4f78f975bbabac031102321612b + (bool loop) + + + void + setPlayingOffset + classsf_1_1Sound.html + ab905677846558042022dd6ab15cddff0 + (Time timeOffset) + + + const SoundBuffer * + getBuffer + classsf_1_1Sound.html + a7c0f6033856909eeefa2e6696db96ef2 + () const + + + bool + getLoop + classsf_1_1Sound.html + a054da07266ce8f39229495146e3041eb + () const + + + Time + getPlayingOffset + classsf_1_1Sound.html + a559bc3aea581107bcb380fdbe523aa08 + () const + + + Status + getStatus + classsf_1_1Sound.html + a406fc363594a7718a53ebef49a870f51 + () const + + + Sound & + operator= + classsf_1_1Sound.html + a8eee9197359bfdf20d399544a894af8b + (const Sound &right) + + + void + resetBuffer + classsf_1_1Sound.html + acb7289d45e06fb76b8292ac84beb82a7 + () + + + void + setPitch + classsf_1_1SoundSource.html + a72a13695ed48b7f7b55e7cd4431f4bb6 + (float pitch) + + + void + setVolume + classsf_1_1SoundSource.html + a2f192f2b49fb8e2b82f3498d3663fcc2 + (float volume) + + + void + setPosition + classsf_1_1SoundSource.html + a0480257ea25d986eba6cc3c1a6f8d7c2 + (float x, float y, float z) + + + void + setPosition + classsf_1_1SoundSource.html + a17ba9ed01925395652181a7b2a7d3aef + (const Vector3f &position) + + + void + setRelativeToListener + classsf_1_1SoundSource.html + ac478a8b813faf7dd575635b102081d0d + (bool relative) + + + void + setMinDistance + classsf_1_1SoundSource.html + a75bbc2c34addc8b25a14edb908508afe + (float distance) + + + void + setAttenuation + classsf_1_1SoundSource.html + aa2adff44cd2f8b4e3c7315d7c2a45626 + (float attenuation) + + + float + getPitch + classsf_1_1SoundSource.html + a4736acc2c802f927544c9ce52a44a9e4 + () const + + + float + getVolume + classsf_1_1SoundSource.html + a04243fb5edf64561689b1d58953fc4ce + () const + + + Vector3f + getPosition + classsf_1_1SoundSource.html + a8d199521f55550c7a3b2b0f6950dffa1 + () const + + + bool + isRelativeToListener + classsf_1_1SoundSource.html + adcdb4ef32c2f4481d34aff0b5c31534b + () const + + + float + getMinDistance + classsf_1_1SoundSource.html + a605ca7f359ec1c36fcccdcd4696562ac + () const + + + float + getAttenuation + classsf_1_1SoundSource.html + a8ad7dafb4f1b4afbc638cebe24f48cc9 + () const + + + unsigned int + m_source + classsf_1_1SoundSource.html + a0223cef4b1c587e6e1e17b4c92c4479c + + + + + sf::SoundBuffer + classsf_1_1SoundBuffer.html + sf::AlResource + + + SoundBuffer + classsf_1_1SoundBuffer.html + a0cabfbfe19b831bf7d5c9592d92ef233 + () + + + + SoundBuffer + classsf_1_1SoundBuffer.html + aaf000fc741ff27015907e8588263f4a6 + (const SoundBuffer &copy) + + + + ~SoundBuffer + classsf_1_1SoundBuffer.html + aea240161724ffba74a0d6a9e277d3cd5 + () + + + bool + loadFromFile + classsf_1_1SoundBuffer.html + a2be6a8025c97eb622a7dff6cf2594394 + (const std::string &filename) + + + bool + loadFromMemory + classsf_1_1SoundBuffer.html + af8cfa5599739a7edae69c5cba273d33f + (const void *data, std::size_t sizeInBytes) + + + bool + loadFromStream + classsf_1_1SoundBuffer.html + ad292156b1e01f6dabd4c0c277d5e079e + (InputStream &stream) + + + bool + loadFromSamples + classsf_1_1SoundBuffer.html + a42d51ce4bb3b60c7ea06f63c273fd063 + (const Int16 *samples, Uint64 sampleCount, unsigned int channelCount, unsigned int sampleRate) + + + bool + saveToFile + classsf_1_1SoundBuffer.html + aade64260c6375580a085314a30be007e + (const std::string &filename) const + + + const Int16 * + getSamples + classsf_1_1SoundBuffer.html + a3d5571a5231d3aea0d2cea933c38cc9e + () const + + + Uint64 + getSampleCount + classsf_1_1SoundBuffer.html + aebe2a4bdbfbd9249353748da3f6a4fa1 + () const + + + unsigned int + getSampleRate + classsf_1_1SoundBuffer.html + a2c2cf0078ce0549246ecc4a1646212b4 + () const + + + unsigned int + getChannelCount + classsf_1_1SoundBuffer.html + a127707b831d875ed790eef1aa2b9fcc3 + () const + + + Time + getDuration + classsf_1_1SoundBuffer.html + a280a581d9b360fd16121714c51fc8261 + () const + + + SoundBuffer & + operator= + classsf_1_1SoundBuffer.html + ad0b6f45d3008cd7d29d340195e68459a + (const SoundBuffer &right) + + + + sf::SoundBufferRecorder + classsf_1_1SoundBufferRecorder.html + sf::SoundRecorder + + + ~SoundBufferRecorder + classsf_1_1SoundBufferRecorder.html + a350f7f885ccfd12b4c6c120c23695637 + () + + + const SoundBuffer & + getBuffer + classsf_1_1SoundBufferRecorder.html + a1befea2bfa3959ff6fabbf7e33cbc864 + () const + + + bool + start + classsf_1_1SoundRecorder.html + a715f0fd2f228c83d79aaedca562ae51f + (unsigned int sampleRate=44100) + + + void + stop + classsf_1_1SoundRecorder.html + a8d9c8346aa9aa409cfed4a1101159c4c + () + + + unsigned int + getSampleRate + classsf_1_1SoundRecorder.html + aed292c297a3e0d627db4eb5c18f58c44 + () const + + + bool + setDevice + classsf_1_1SoundRecorder.html + a8eb3e473292c16e874322815836d3cd3 + (const std::string &name) + + + const std::string & + getDevice + classsf_1_1SoundRecorder.html + a13d7d97b3ca67efa18f5ee0aa5884f1f + () const + + + void + setChannelCount + classsf_1_1SoundRecorder.html + ae4e22ba67d12a74966eb05fad55a317c + (unsigned int channelCount) + + + unsigned int + getChannelCount + classsf_1_1SoundRecorder.html + a610e98e7a73b316ce26b7c55234f86e9 + () const + + + static std::vector< std::string > + getAvailableDevices + classsf_1_1SoundRecorder.html + a2a0a831148dcf3d979de42029ec0c280 + () + + + static std::string + getDefaultDevice + classsf_1_1SoundRecorder.html + ad1d450a80642dab4b632999d72a1bf23 + () + + + static bool + isAvailable + classsf_1_1SoundRecorder.html + aab2bd0fee9e48d6cfd449b1cb078ce5a + () + + + virtual bool + onStart + classsf_1_1SoundBufferRecorder.html + a531a7445fc8a48eaf9fc039c83f17c6f + () + + + virtual bool + onProcessSamples + classsf_1_1SoundBufferRecorder.html + a9ceb94de14632ae8c1b78faf603b4767 + (const Int16 *samples, std::size_t sampleCount) + + + virtual void + onStop + classsf_1_1SoundBufferRecorder.html + ab8e53849312413431873a5869d509f1e + () + + + void + setProcessingInterval + classsf_1_1SoundRecorder.html + a85b7fb8a86c08b5084f8f142767bccf6 + (Time interval) + + + + sf::SoundFileFactory + classsf_1_1SoundFileFactory.html + + static void + registerReader + classsf_1_1SoundFileFactory.html + aeee396bfdbb6ac24c57e5c73c30ec105 + () + + + static void + unregisterReader + classsf_1_1SoundFileFactory.html + ac42f01faf678d1f410e1ce8a18e4cebb + () + + + static void + registerWriter + classsf_1_1SoundFileFactory.html + abb6e082ea3fedf22c8648113d1be5755 + () + + + static void + unregisterWriter + classsf_1_1SoundFileFactory.html + a1bd8ebd264a5ec33962a9f7a8ca21a60 + () + + + static SoundFileReader * + createReaderFromFilename + classsf_1_1SoundFileFactory.html + ae68185540db5e2a451d626be45036fe0 + (const std::string &filename) + + + static SoundFileReader * + createReaderFromMemory + classsf_1_1SoundFileFactory.html + a2384ed647b08c5b2bbf43566d5d7b5fd + (const void *data, std::size_t sizeInBytes) + + + static SoundFileReader * + createReaderFromStream + classsf_1_1SoundFileFactory.html + af64ce454cde415ebd3ca5442801d87d8 + (InputStream &stream) + + + static SoundFileWriter * + createWriterFromFilename + classsf_1_1SoundFileFactory.html + a2bc9da55d78be2c41a273bbbea4c0978 + (const std::string &filename) + + + + sf::SoundFileReader + classsf_1_1SoundFileReader.html + sf::SoundFileReader::Info + + virtual + ~SoundFileReader + classsf_1_1SoundFileReader.html + a34163297f302d15818c76b54f815acc8 + () + + + virtual bool + open + classsf_1_1SoundFileReader.html + aa1d2fee2ba8f359c833ab74590d55935 + (InputStream &stream, Info &info)=0 + + + virtual void + seek + classsf_1_1SoundFileReader.html + a1e18ade5ffe882bdfa20a2ebe7e2b015 + (Uint64 sampleOffset)=0 + + + virtual Uint64 + read + classsf_1_1SoundFileReader.html + a3b7d86769ea07e24e7b0f0486bed7591 + (Int16 *samples, Uint64 maxCount)=0 + + + + sf::SoundFileWriter + classsf_1_1SoundFileWriter.html + + virtual + ~SoundFileWriter + classsf_1_1SoundFileWriter.html + a76944fc158688f35050bd5b592c90270 + () + + + virtual bool + open + classsf_1_1SoundFileWriter.html + a5c92bcaaa880ef4d3eaab18dae1d3d07 + (const std::string &filename, unsigned int sampleRate, unsigned int channelCount)=0 + + + virtual void + write + classsf_1_1SoundFileWriter.html + a4ce597e7682d22c5b2c98d77e931a1da + (const Int16 *samples, Uint64 count)=0 + + + + sf::SoundRecorder + classsf_1_1SoundRecorder.html + sf::AlResource + + virtual + ~SoundRecorder + classsf_1_1SoundRecorder.html + acc599e61aaa47edaae88cf43f0a43549 + () + + + bool + start + classsf_1_1SoundRecorder.html + a715f0fd2f228c83d79aaedca562ae51f + (unsigned int sampleRate=44100) + + + void + stop + classsf_1_1SoundRecorder.html + a8d9c8346aa9aa409cfed4a1101159c4c + () + + + unsigned int + getSampleRate + classsf_1_1SoundRecorder.html + aed292c297a3e0d627db4eb5c18f58c44 + () const + + + bool + setDevice + classsf_1_1SoundRecorder.html + a8eb3e473292c16e874322815836d3cd3 + (const std::string &name) + + + const std::string & + getDevice + classsf_1_1SoundRecorder.html + a13d7d97b3ca67efa18f5ee0aa5884f1f + () const + + + void + setChannelCount + classsf_1_1SoundRecorder.html + ae4e22ba67d12a74966eb05fad55a317c + (unsigned int channelCount) + + + unsigned int + getChannelCount + classsf_1_1SoundRecorder.html + a610e98e7a73b316ce26b7c55234f86e9 + () const + + + static std::vector< std::string > + getAvailableDevices + classsf_1_1SoundRecorder.html + a2a0a831148dcf3d979de42029ec0c280 + () + + + static std::string + getDefaultDevice + classsf_1_1SoundRecorder.html + ad1d450a80642dab4b632999d72a1bf23 + () + + + static bool + isAvailable + classsf_1_1SoundRecorder.html + aab2bd0fee9e48d6cfd449b1cb078ce5a + () + + + + SoundRecorder + classsf_1_1SoundRecorder.html + a50ebad413c4f157408a0fa49f23212a9 + () + + + void + setProcessingInterval + classsf_1_1SoundRecorder.html + a85b7fb8a86c08b5084f8f142767bccf6 + (Time interval) + + + virtual bool + onStart + classsf_1_1SoundRecorder.html + a7af418fb036201d3f85745bef78ce77f + () + + + virtual bool + onProcessSamples + classsf_1_1SoundRecorder.html + a2670124cbe7a87c7e46b4840807f4fd7 + (const Int16 *samples, std::size_t sampleCount)=0 + + + virtual void + onStop + classsf_1_1SoundRecorder.html + aefc36138ca1e96c658301280e4a31b64 + () + + + + sf::SoundSource + classsf_1_1SoundSource.html + sf::AlResource + + + Status + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03 + + + + Stopped + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03adabb01e8aa85b2f54b344890addf764a + + + + Paused + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03ac3ca1fcc0394267c9bdbe3dc0a8a7e41 + + + + Playing + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03af07bdea9f70ef7606dfc9f955beeee18 + + + + Stopped + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03adabb01e8aa85b2f54b344890addf764a + + + + Paused + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03ac3ca1fcc0394267c9bdbe3dc0a8a7e41 + + + + Playing + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03af07bdea9f70ef7606dfc9f955beeee18 + + + + + SoundSource + classsf_1_1SoundSource.html + ae0c7728c1449fdebe65749ab6fcb3170 + (const SoundSource &copy) + + + virtual + ~SoundSource + classsf_1_1SoundSource.html + a77c7c1524f8cb81df2de9375b0f87c5c + () + + + void + setPitch + classsf_1_1SoundSource.html + a72a13695ed48b7f7b55e7cd4431f4bb6 + (float pitch) + + + void + setVolume + classsf_1_1SoundSource.html + a2f192f2b49fb8e2b82f3498d3663fcc2 + (float volume) + + + void + setPosition + classsf_1_1SoundSource.html + a0480257ea25d986eba6cc3c1a6f8d7c2 + (float x, float y, float z) + + + void + setPosition + classsf_1_1SoundSource.html + a17ba9ed01925395652181a7b2a7d3aef + (const Vector3f &position) + + + void + setRelativeToListener + classsf_1_1SoundSource.html + ac478a8b813faf7dd575635b102081d0d + (bool relative) + + + void + setMinDistance + classsf_1_1SoundSource.html + a75bbc2c34addc8b25a14edb908508afe + (float distance) + + + void + setAttenuation + classsf_1_1SoundSource.html + aa2adff44cd2f8b4e3c7315d7c2a45626 + (float attenuation) + + + float + getPitch + classsf_1_1SoundSource.html + a4736acc2c802f927544c9ce52a44a9e4 + () const + + + float + getVolume + classsf_1_1SoundSource.html + a04243fb5edf64561689b1d58953fc4ce + () const + + + Vector3f + getPosition + classsf_1_1SoundSource.html + a8d199521f55550c7a3b2b0f6950dffa1 + () const + + + bool + isRelativeToListener + classsf_1_1SoundSource.html + adcdb4ef32c2f4481d34aff0b5c31534b + () const + + + float + getMinDistance + classsf_1_1SoundSource.html + a605ca7f359ec1c36fcccdcd4696562ac + () const + + + float + getAttenuation + classsf_1_1SoundSource.html + a8ad7dafb4f1b4afbc638cebe24f48cc9 + () const + + + SoundSource & + operator= + classsf_1_1SoundSource.html + a4b494e4a0b819bae9cd99b43e2f3f59d + (const SoundSource &right) + + + virtual void + play + classsf_1_1SoundSource.html + a6e1bbb1f247ed8743faf3b1ed6f2bc21 + ()=0 + + + virtual void + pause + classsf_1_1SoundSource.html + a21553d4e8fcf136231dd8c7ad4630aba + ()=0 + + + virtual void + stop + classsf_1_1SoundSource.html + a06501a25b12376befcc7ee1ed4865fda + ()=0 + + + virtual Status + getStatus + classsf_1_1SoundSource.html + aa8d313c31b968159582a999aa66e5ed7 + () const + + + + SoundSource + classsf_1_1SoundSource.html + aefa4bd4460f387d81a0637d293979436 + () + + + unsigned int + m_source + classsf_1_1SoundSource.html + a0223cef4b1c587e6e1e17b4c92c4479c + + + + + sf::SoundStream + classsf_1_1SoundStream.html + sf::SoundSource + sf::SoundStream::Chunk + + + Status + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03 + + + + Stopped + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03adabb01e8aa85b2f54b344890addf764a + + + + Paused + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03ac3ca1fcc0394267c9bdbe3dc0a8a7e41 + + + + Playing + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03af07bdea9f70ef7606dfc9f955beeee18 + + + + Stopped + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03adabb01e8aa85b2f54b344890addf764a + + + + Paused + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03ac3ca1fcc0394267c9bdbe3dc0a8a7e41 + + + + Playing + classsf_1_1SoundSource.html + ac43af72c98c077500b239bc75b812f03af07bdea9f70ef7606dfc9f955beeee18 + + + + virtual + ~SoundStream + classsf_1_1SoundStream.html + a1fafb9f1ca572d23d7d6a17921860d85 + () + + + void + play + classsf_1_1SoundStream.html + afdc08b69cab5f243d9324940a85a1144 + () + + + void + pause + classsf_1_1SoundStream.html + a932ff181e661503cad288b4bb6fe45ca + () + + + void + stop + classsf_1_1SoundStream.html + a16cc6a0404b32e42c4dce184bb94d0f4 + () + + + unsigned int + getChannelCount + classsf_1_1SoundStream.html + a1f70933912dd9498f4dc99feefed27f3 + () const + + + unsigned int + getSampleRate + classsf_1_1SoundStream.html + a7da448dc40d81a33b8dc555fbf0d3fbf + () const + + + Status + getStatus + classsf_1_1SoundStream.html + a64a8193ed728da37c115c65de015849f + () const + + + void + setPlayingOffset + classsf_1_1SoundStream.html + af416a5f84c8750d2acb9821d78bc8646 + (Time timeOffset) + + + Time + getPlayingOffset + classsf_1_1SoundStream.html + ae288f3c72edbad9cc7ee938ce5b907c1 + () const + + + void + setLoop + classsf_1_1SoundStream.html + a43fade018ffba7e4f847a9f00b353f3d + (bool loop) + + + bool + getLoop + classsf_1_1SoundStream.html + a49d263f9bbaefec4b019bd05fda59b25 + () const + + + void + setPitch + classsf_1_1SoundSource.html + a72a13695ed48b7f7b55e7cd4431f4bb6 + (float pitch) + + + void + setVolume + classsf_1_1SoundSource.html + a2f192f2b49fb8e2b82f3498d3663fcc2 + (float volume) + + + void + setPosition + classsf_1_1SoundSource.html + a0480257ea25d986eba6cc3c1a6f8d7c2 + (float x, float y, float z) + + + void + setPosition + classsf_1_1SoundSource.html + a17ba9ed01925395652181a7b2a7d3aef + (const Vector3f &position) + + + void + setRelativeToListener + classsf_1_1SoundSource.html + ac478a8b813faf7dd575635b102081d0d + (bool relative) + + + void + setMinDistance + classsf_1_1SoundSource.html + a75bbc2c34addc8b25a14edb908508afe + (float distance) + + + void + setAttenuation + classsf_1_1SoundSource.html + aa2adff44cd2f8b4e3c7315d7c2a45626 + (float attenuation) + + + float + getPitch + classsf_1_1SoundSource.html + a4736acc2c802f927544c9ce52a44a9e4 + () const + + + float + getVolume + classsf_1_1SoundSource.html + a04243fb5edf64561689b1d58953fc4ce + () const + + + Vector3f + getPosition + classsf_1_1SoundSource.html + a8d199521f55550c7a3b2b0f6950dffa1 + () const + + + bool + isRelativeToListener + classsf_1_1SoundSource.html + adcdb4ef32c2f4481d34aff0b5c31534b + () const + + + float + getMinDistance + classsf_1_1SoundSource.html + a605ca7f359ec1c36fcccdcd4696562ac + () const + + + float + getAttenuation + classsf_1_1SoundSource.html + a8ad7dafb4f1b4afbc638cebe24f48cc9 + () const + + + NoLoop + classsf_1_1SoundStream.html + a7707214e7cd4ffcf1c123e7bcab4092aa2f2c638731fdff0d6fe4e3e82b6f6146 + + + + NoLoop + classsf_1_1SoundStream.html + a7707214e7cd4ffcf1c123e7bcab4092aa2f2c638731fdff0d6fe4e3e82b6f6146 + + + + + SoundStream + classsf_1_1SoundStream.html + a769d08f4c3c6b4340ef3a838329d2e5c + () + + + void + initialize + classsf_1_1SoundStream.html + a9c351711198ee1aa77c2fefd3ced4d2c + (unsigned int channelCount, unsigned int sampleRate) + + + virtual bool + onGetData + classsf_1_1SoundStream.html + a968ec024a6e45490962c8a1121cb7c5f + (Chunk &data)=0 + + + virtual void + onSeek + classsf_1_1SoundStream.html + a907036dd2ca7d3af5ead316e54b75997 + (Time timeOffset)=0 + + + virtual Int64 + onLoop + classsf_1_1SoundStream.html + a3f717d18846f261fc375d71d6c7e41da + () + + + void + setProcessingInterval + classsf_1_1SoundStream.html + a3a38d317279163f3766da2e538fbde93 + (Time interval) + + + unsigned int + m_source + classsf_1_1SoundSource.html + a0223cef4b1c587e6e1e17b4c92c4479c + + + + + sf::Music::Span + structsf_1_1Music_1_1Span.html + typename T + + + Span + structsf_1_1Music_1_1Span.html + a71e6200a586f650ce002e7e99929ae85 + () + + + + Span + structsf_1_1Music_1_1Span.html + a935db12207fa3da4c2461cd5e1f9fa0d + (T off, T len) + + + T + offset + structsf_1_1Music_1_1Span.html + a49bb6a3c4239288cf47c1298c3e5e1a3 + + + + T + length + structsf_1_1Music_1_1Span.html + a509fdbef69a8fc0f8430ecb7b9e76221 + + + + + sf::Sprite + classsf_1_1Sprite.html + sf::Drawable + sf::Transformable + + + Sprite + classsf_1_1Sprite.html + a92559fbca895a96758abf5eabab96984 + () + + + + Sprite + classsf_1_1Sprite.html + a2a9fca374d7abf084bb1c143a879ff4a + (const Texture &texture) + + + + Sprite + classsf_1_1Sprite.html + a01cfe1402372d243dbaa2ffa96020206 + (const Texture &texture, const IntRect &rectangle) + + + void + setTexture + classsf_1_1Sprite.html + a3729c88d88ac38c19317c18e87242560 + (const Texture &texture, bool resetRect=false) + + + void + setTextureRect + classsf_1_1Sprite.html + a3fefec419a4e6a90c0fd54c793d82ec2 + (const IntRect &rectangle) + + + void + setColor + classsf_1_1Sprite.html + a14def44da6437bfea20c4df5e71aba4c + (const Color &color) + + + const Texture * + getTexture + classsf_1_1Sprite.html + a6d0f107b5dd5976be50bc5b163ba21aa + () const + + + const IntRect & + getTextureRect + classsf_1_1Sprite.html + afb19e5b4f39d17cf4d95752b3a79bcb6 + () const + + + const Color & + getColor + classsf_1_1Sprite.html + af4a3ee8177fdd6e472a360a0a837d7cf + () const + + + FloatRect + getLocalBounds + classsf_1_1Sprite.html + ab2f4c781464da6f8a52b1df6058a48b8 + () const + + + FloatRect + getGlobalBounds + classsf_1_1Sprite.html + aa795483096b90745b2e799532963e271 + () const + + + void + setPosition + classsf_1_1Transformable.html + a4dbfb1a7c80688b0b4c477d706550208 + (float x, float y) + + + void + setPosition + classsf_1_1Transformable.html + af1a42209ce2b5d3f07b00f917bcd8015 + (const Vector2f &position) + + + void + setRotation + classsf_1_1Transformable.html + a32baf2bf1a74699b03bf8c95030a38ed + (float angle) + + + void + setScale + classsf_1_1Transformable.html + aaec50b46b3f41b054763304d1e727471 + (float factorX, float factorY) + + + void + setScale + classsf_1_1Transformable.html + a4c48a87f1626047e448f9c1a68ff167e + (const Vector2f &factors) + + + void + setOrigin + classsf_1_1Transformable.html + a56c67bd80aae8418d13fb96c034d25ec + (float x, float y) + + + void + setOrigin + classsf_1_1Transformable.html + aa93a835ffbf3bee2098dfbbc695a7f05 + (const Vector2f &origin) + + + const Vector2f & + getPosition + classsf_1_1Transformable.html + aea8b18e91a7bf7be589851bb9dd11241 + () const + + + float + getRotation + classsf_1_1Transformable.html + aa00b5c5d4a06ac24a94dd72c56931d3a + () const + + + const Vector2f & + getScale + classsf_1_1Transformable.html + a7bcae0e924213f2e89edd8926f2453af + () const + + + const Vector2f & + getOrigin + classsf_1_1Transformable.html + a898b33eb6513161eb5c747a072364f15 + () const + + + void + move + classsf_1_1Transformable.html + a86b461d6a941ad390c2ad8b6a4a20391 + (float offsetX, float offsetY) + + + void + move + classsf_1_1Transformable.html + ab9ca691522f6ddc1a40406849b87c469 + (const Vector2f &offset) + + + void + rotate + classsf_1_1Transformable.html + af8a5ffddc0d93f238fee3bf8efe1ebda + (float angle) + + + void + scale + classsf_1_1Transformable.html + a3de0c6d8957f3cf318092f3f60656391 + (float factorX, float factorY) + + + void + scale + classsf_1_1Transformable.html + adecaa6c69b1f27dd5194b067d96bb694 + (const Vector2f &factor) + + + const Transform & + getTransform + classsf_1_1Transformable.html + a3e1b4772a451ec66ac7e6af655726154 + () const + + + const Transform & + getInverseTransform + classsf_1_1Transformable.html + ac5e75d724436069d2268791c6b486916 + () const + + + + sf::String + classsf_1_1String.html + + std::basic_string< Uint32 >::iterator + Iterator + classsf_1_1String.html + ac90f2b7b28f703020f8d027e98806235 + + + + std::basic_string< Uint32 >::const_iterator + ConstIterator + classsf_1_1String.html + a8e18efc2e8464f6eb82818902d527efa + + + + + String + classsf_1_1String.html + a9563a4e93f692e0c8e8702b374ef8692 + () + + + + String + classsf_1_1String.html + ac9df7f7696cff164794e338f3c89ccc5 + (char ansiChar, const std::locale &locale=std::locale()) + + + + String + classsf_1_1String.html + aefaa202d2aa5ff85b4f75a5983367e86 + (wchar_t wideChar) + + + + String + classsf_1_1String.html + a8e1a5027416d121187908e2ed77079ff + (Uint32 utf32Char) + + + + String + classsf_1_1String.html + a57d2b8c289f9894f859564cad034bfc7 + (const char *ansiString, const std::locale &locale=std::locale()) + + + + String + classsf_1_1String.html + a0aa41dcbd17b0c36c74d03d3b0147f1e + (const std::string &ansiString, const std::locale &locale=std::locale()) + + + + String + classsf_1_1String.html + a5742d0a9b0c754f711820c2b5c40fa55 + (const wchar_t *wideString) + + + + String + classsf_1_1String.html + a5e38151340af4f9a5f74ad24c0664074 + (const std::wstring &wideString) + + + + String + classsf_1_1String.html + aea3629adf19f9fe713d4946f6c75b214 + (const Uint32 *utf32String) + + + + String + classsf_1_1String.html + a6eee86dbe75d16bbcc26e97416c2e1ca + (const std::basic_string< Uint32 > &utf32String) + + + + String + classsf_1_1String.html + af862594d3c4070d8ddbf08cf8dce4f59 + (const String &copy) + + + + operator std::string + classsf_1_1String.html + a884816a0f688cfd48f9324c9741dc257 + () const + + + + operator std::wstring + classsf_1_1String.html + a6bd1444bebaca9bbf01ba203061f5076 + () const + + + std::string + toAnsiString + classsf_1_1String.html + ada5d5bba4528aceb0a1e298553e6c30a + (const std::locale &locale=std::locale()) const + + + std::wstring + toWideString + classsf_1_1String.html + a9d81aa3103e7e2062bd85d912a5aecf1 + () const + + + std::basic_string< Uint8 > + toUtf8 + classsf_1_1String.html + a2a4f366d5db833ae818881507b46e13a + () const + + + std::basic_string< Uint16 > + toUtf16 + classsf_1_1String.html + ab805f230a0b2e972f9f32ac4cf11d912 + () const + + + std::basic_string< Uint32 > + toUtf32 + classsf_1_1String.html + aef4f51ebe43465c665c78692d0262e43 + () const + + + String & + operator= + classsf_1_1String.html + af14c8e1bf351cf18486f0258c36260d7 + (const String &right) + + + String & + operator+= + classsf_1_1String.html + afdae61e813b2951a6e39015e34a143f7 + (const String &right) + + + Uint32 + operator[] + classsf_1_1String.html + a035c1b585a0ebed81e773ecafed57926 + (std::size_t index) const + + + Uint32 & + operator[] + classsf_1_1String.html + a3e2041bd9ae84d223e6b12e46e5aa5d6 + (std::size_t index) + + + void + clear + classsf_1_1String.html + a391c1b4950cbf3d3f8040cea73af2969 + () + + + std::size_t + getSize + classsf_1_1String.html + ae7aff54e178f5d3e399953adff5cad20 + () const + + + bool + isEmpty + classsf_1_1String.html + a2ba26cb6945d2bbb210b822f222aa7f6 + () const + + + void + erase + classsf_1_1String.html + aaa78a0a46b3fbe200a4ccdedc326eb93 + (std::size_t position, std::size_t count=1) + + + void + insert + classsf_1_1String.html + ad0b1455deabf07af13ee79812e05fa02 + (std::size_t position, const String &str) + + + std::size_t + find + classsf_1_1String.html + aa189ec8656854106ab8d2e935fd9cbcc + (const String &str, std::size_t start=0) const + + + void + replace + classsf_1_1String.html + ad460e628c287b0fa88deba2eb0b6744b + (std::size_t position, std::size_t length, const String &replaceWith) + + + void + replace + classsf_1_1String.html + a82bbfee2bf23c641e5361ad505c07921 + (const String &searchFor, const String &replaceWith) + + + String + substring + classsf_1_1String.html + a492645e00032455e6d92ff0e992654ce + (std::size_t position, std::size_t length=InvalidPos) const + + + const Uint32 * + getData + classsf_1_1String.html + a3ed7f3ad41659a2b31a8d8e99a7b8199 + () const + + + Iterator + begin + classsf_1_1String.html + a8ec30ddc08e3a6bd11c99aed782f6dfe + () + + + ConstIterator + begin + classsf_1_1String.html + a0e4755d6b4d51de7c3dc2e984b79f95d + () const + + + Iterator + end + classsf_1_1String.html + ac823012f39cb6f61100418876e99d53b + () + + + ConstIterator + end + classsf_1_1String.html + af1ab4c82ff2bdfb6903b4b1bb78a8e5c + () const + + + static String + fromUtf8 + classsf_1_1String.html + aa7beb7ae5b26e63dcbbfa390e27a9e4b + (T begin, T end) + + + static String + fromUtf16 + classsf_1_1String.html + a81f70eecad0000a4f2e4d66f97b80300 + (T begin, T end) + + + static String + fromUtf32 + classsf_1_1String.html + ab023a4900dce37ee71ab9e29b30a23cb + (T begin, T end) + + + static const std::size_t + InvalidPos + classsf_1_1String.html + abaadecaf12a6b41c54d725c75fd28527 + + + + bool + operator== + classsf_1_1String.html + a483931724196c580552b68751fb4d837 + (const String &left, const String &right) + + + bool + operator!= + classsf_1_1String.html + a3bfb9217788a9978499b8d5696bb0ef2 + (const String &left, const String &right) + + + bool + operator< + classsf_1_1String.html + a5158a142e0966685ec7fb4e147b24ef0 + (const String &left, const String &right) + + + bool + operator> + classsf_1_1String.html + ac96278a8cbe282632b11f0c8c007df0c + (const String &left, const String &right) + + + bool + operator<= + classsf_1_1String.html + ac1c1bb5dcf02aad3b2c0a1bf74a11cc9 + (const String &left, const String &right) + + + bool + operator>= + classsf_1_1String.html + a112689eec28e0ca9489e8c4ec6a34493 + (const String &left, const String &right) + + + String + operator+ + classsf_1_1String.html + af140f992b7698cf1448677c2c8e11bf1 + (const String &left, const String &right) + + + + sf::TcpListener + classsf_1_1TcpListener.html + sf::Socket + + + Status + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dc + + + + Done + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1de3a85bc56d3ae85b3d0f3cfd04ae90 + + + + NotReady + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca8554848daae98f996e131bdeed076c09 + + + + Partial + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca181c163fad2eaea927185d127c392706 + + + + Disconnected + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dcab215141f756acdc23c67fad149710eb1 + + + + Error + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1dc9854433a28c22e192721179a2df5d + + + + AnyPort + classsf_1_1Socket.html + aa3e6c984bcb81a35234dcc9cc8369d75a5a3c30fd128895403afc11076f461b19 + + + + Done + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1de3a85bc56d3ae85b3d0f3cfd04ae90 + + + + NotReady + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca8554848daae98f996e131bdeed076c09 + + + + Partial + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca181c163fad2eaea927185d127c392706 + + + + Disconnected + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dcab215141f756acdc23c67fad149710eb1 + + + + Error + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1dc9854433a28c22e192721179a2df5d + + + + AnyPort + classsf_1_1Socket.html + aa3e6c984bcb81a35234dcc9cc8369d75a5a3c30fd128895403afc11076f461b19 + + + + + TcpListener + classsf_1_1TcpListener.html + a59a1db5b6f4711a3e57390da2f8d9630 + () + + + unsigned short + getLocalPort + classsf_1_1TcpListener.html + a784b9a9c59d4cdbae1795e90b8015780 + () const + + + Status + listen + classsf_1_1TcpListener.html + a9504758ea3570e62cb20b209c11776a1 + (unsigned short port, const IpAddress &address=IpAddress::Any) + + + void + close + classsf_1_1TcpListener.html + a3a00a850506bd0f9f48867a0fe59556b + () + + + Status + accept + classsf_1_1TcpListener.html + ae2c83ce5a64d50b68180c46bef0a7346 + (TcpSocket &socket) + + + void + setBlocking + classsf_1_1Socket.html + a165fc1423e281ea2714c70303d3a9782 + (bool blocking) + + + bool + isBlocking + classsf_1_1Socket.html + ab1ceca9ac114b8baeeda3b34a0aca468 + () const + + + + Type + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8 + + + + Tcp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8acc02e97e90234b957eaad4dff7f22214 + + + + Udp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8a6ebf3094830db4820191a327f3cc6ce2 + + + + Tcp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8acc02e97e90234b957eaad4dff7f22214 + + + + Udp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8a6ebf3094830db4820191a327f3cc6ce2 + + + + SocketHandle + getHandle + classsf_1_1Socket.html + a675457784284ae2f5640bbbe16729393 + () const + + + void + create + classsf_1_1Socket.html + aafbe140f4b1921e0d19e88cf7a61dcbc + () + + + void + create + classsf_1_1Socket.html + af1dd898f7aa3ead7ff7b2d1c20e97781 + (SocketHandle handle) + + + + sf::TcpSocket + classsf_1_1TcpSocket.html + sf::Socket + + + Status + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dc + + + + Done + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1de3a85bc56d3ae85b3d0f3cfd04ae90 + + + + NotReady + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca8554848daae98f996e131bdeed076c09 + + + + Partial + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca181c163fad2eaea927185d127c392706 + + + + Disconnected + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dcab215141f756acdc23c67fad149710eb1 + + + + Error + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1dc9854433a28c22e192721179a2df5d + + + + AnyPort + classsf_1_1Socket.html + aa3e6c984bcb81a35234dcc9cc8369d75a5a3c30fd128895403afc11076f461b19 + + + + Done + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1de3a85bc56d3ae85b3d0f3cfd04ae90 + + + + NotReady + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca8554848daae98f996e131bdeed076c09 + + + + Partial + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca181c163fad2eaea927185d127c392706 + + + + Disconnected + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dcab215141f756acdc23c67fad149710eb1 + + + + Error + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1dc9854433a28c22e192721179a2df5d + + + + AnyPort + classsf_1_1Socket.html + aa3e6c984bcb81a35234dcc9cc8369d75a5a3c30fd128895403afc11076f461b19 + + + + + TcpSocket + classsf_1_1TcpSocket.html + a62a9bf81fd7f15fedb29fd1348483236 + () + + + unsigned short + getLocalPort + classsf_1_1TcpSocket.html + a98e45f0f49af1fd99216b9195e86d86b + () const + + + IpAddress + getRemoteAddress + classsf_1_1TcpSocket.html + aa8579c203b1fd21beb74d7f76444a94c + () const + + + unsigned short + getRemotePort + classsf_1_1TcpSocket.html + a93bced0afd4b1c60797a85725be04951 + () const + + + Status + connect + classsf_1_1TcpSocket.html + a68cd42d5ab70ab54b16787f555951c40 + (const IpAddress &remoteAddress, unsigned short remotePort, Time timeout=Time::Zero) + + + void + disconnect + classsf_1_1TcpSocket.html + ac18f518a9be3d6be5e74b9404c253c1e + () + + + Status + send + classsf_1_1TcpSocket.html + affce26ab3bcc4f5b9269dad79db544c0 + (const void *data, std::size_t size) + + + Status + send + classsf_1_1TcpSocket.html + a31f5b280126a96c6f3ad430f4cbcb54d + (const void *data, std::size_t size, std::size_t &sent) + + + Status + receive + classsf_1_1TcpSocket.html + a90ce50811ea61d4f00efc62bb99ae1af + (void *data, std::size_t size, std::size_t &received) + + + Status + send + classsf_1_1TcpSocket.html + a0f8276e2b1c75aac4a7b0a707b250f44 + (Packet &packet) + + + Status + receive + classsf_1_1TcpSocket.html + aa655352609bc9804f2baa020df3e7331 + (Packet &packet) + + + void + setBlocking + classsf_1_1Socket.html + a165fc1423e281ea2714c70303d3a9782 + (bool blocking) + + + bool + isBlocking + classsf_1_1Socket.html + ab1ceca9ac114b8baeeda3b34a0aca468 + () const + + + + Type + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8 + + + + Tcp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8acc02e97e90234b957eaad4dff7f22214 + + + + Udp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8a6ebf3094830db4820191a327f3cc6ce2 + + + + Tcp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8acc02e97e90234b957eaad4dff7f22214 + + + + Udp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8a6ebf3094830db4820191a327f3cc6ce2 + + + + SocketHandle + getHandle + classsf_1_1Socket.html + a675457784284ae2f5640bbbe16729393 + () const + + + void + create + classsf_1_1Socket.html + aafbe140f4b1921e0d19e88cf7a61dcbc + () + + + void + create + classsf_1_1Socket.html + af1dd898f7aa3ead7ff7b2d1c20e97781 + (SocketHandle handle) + + + void + close + classsf_1_1Socket.html + a71f2f5c2aa99e01cafe824fee4c573be + () + + + + sf::Text + classsf_1_1Text.html + sf::Drawable + sf::Transformable + + + Style + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82 + + + + Regular + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82a2af9ae5e1cda126570f744448e0caa32 + + + + Bold + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82af1b47f98fb1e10509ba930a596987171 + + + + Italic + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82aee249eb803848723c542c2062ebe69d8 + + + + Underlined + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82a664bd143f92b6e8c709d7f788e8b20df + + + + StrikeThrough + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82a9ed1f5bb154c21269e1190c5aa97d479 + + + + Regular + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82a2af9ae5e1cda126570f744448e0caa32 + + + + Bold + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82af1b47f98fb1e10509ba930a596987171 + + + + Italic + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82aee249eb803848723c542c2062ebe69d8 + + + + Underlined + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82a664bd143f92b6e8c709d7f788e8b20df + + + + StrikeThrough + classsf_1_1Text.html + aa8add4aef484c6e6b20faff07452bd82a9ed1f5bb154c21269e1190c5aa97d479 + + + + + Text + classsf_1_1Text.html + aff7cab6a92e5948c9d1481cb2d87eb84 + () + + + + Text + classsf_1_1Text.html + a614019e0b5c0ed39a99d32483a51f2c5 + (const String &string, const Font &font, unsigned int characterSize=30) + + + void + setString + classsf_1_1Text.html + a7d3b3359f286fd9503d1ced25b7b6c33 + (const String &string) + + + void + setFont + classsf_1_1Text.html + a2927805d1ae92d57f15034ea34756b81 + (const Font &font) + + + void + setCharacterSize + classsf_1_1Text.html + ae96f835fc1bff858f8a23c5b01eaaf7e + (unsigned int size) + + + void + setLineSpacing + classsf_1_1Text.html + af6505688f79e2e2d90bd68f4d767e965 + (float spacingFactor) + + + void + setLetterSpacing + classsf_1_1Text.html + ab516110605edb0191a7873138ac42af2 + (float spacingFactor) + + + void + setStyle + classsf_1_1Text.html + ad791702bc2d1b6590a1719aa60635edf + (Uint32 style) + + + void + setColor + classsf_1_1Text.html + afd1742fca1adb6b0ea98357250ffb634 + (const Color &color) + + + void + setFillColor + classsf_1_1Text.html + ab7bb3babac5a6da1802b2c3e1a3e6dcc + (const Color &color) + + + void + setOutlineColor + classsf_1_1Text.html + aa19ec69c3b894e963602a6804ca68fe4 + (const Color &color) + + + void + setOutlineThickness + classsf_1_1Text.html + ab0e6be3b40124557bf53737fe6a6ce77 + (float thickness) + + + const String & + getString + classsf_1_1Text.html + ab334881845307db46ccf344191aa819c + () const + + + const Font * + getFont + classsf_1_1Text.html + ad947a43bddaddf54d008df600699599b + () const + + + unsigned int + getCharacterSize + classsf_1_1Text.html + a46d1d7f1d513bb8d434e985a93ea5224 + () const + + + float + getLetterSpacing + classsf_1_1Text.html + a028fc6e561bd9a0671254419b498b889 + () const + + + float + getLineSpacing + classsf_1_1Text.html + a670622e1c299dfd6518afe289c7cd248 + () const + + + Uint32 + getStyle + classsf_1_1Text.html + a0da79b0c057f4bb51592465a205c35d7 + () const + + + const Color & + getColor + classsf_1_1Text.html + ab367e86c9e9e6cd3806c362ab8e79101 + () const + + + const Color & + getFillColor + classsf_1_1Text.html + a10400757492ec7fa97454488314ca39b + () const + + + const Color & + getOutlineColor + classsf_1_1Text.html + ade9256ff9d43c9481fcf5f4003fe0141 + () const + + + float + getOutlineThickness + classsf_1_1Text.html + af6bf01c23189edf52c8b38708db6f3f6 + () const + + + Vector2f + findCharacterPos + classsf_1_1Text.html + a2e252d8dcae3eb61c6c962c0bc674b12 + (std::size_t index) const + + + FloatRect + getLocalBounds + classsf_1_1Text.html + a3e6b3b298827f853b41165eee2cbbc66 + () const + + + FloatRect + getGlobalBounds + classsf_1_1Text.html + ad33ed96ce9fbe99610f7f8b6874a16b4 + () const + + + void + setPosition + classsf_1_1Transformable.html + a4dbfb1a7c80688b0b4c477d706550208 + (float x, float y) + + + void + setPosition + classsf_1_1Transformable.html + af1a42209ce2b5d3f07b00f917bcd8015 + (const Vector2f &position) + + + void + setRotation + classsf_1_1Transformable.html + a32baf2bf1a74699b03bf8c95030a38ed + (float angle) + + + void + setScale + classsf_1_1Transformable.html + aaec50b46b3f41b054763304d1e727471 + (float factorX, float factorY) + + + void + setScale + classsf_1_1Transformable.html + a4c48a87f1626047e448f9c1a68ff167e + (const Vector2f &factors) + + + void + setOrigin + classsf_1_1Transformable.html + a56c67bd80aae8418d13fb96c034d25ec + (float x, float y) + + + void + setOrigin + classsf_1_1Transformable.html + aa93a835ffbf3bee2098dfbbc695a7f05 + (const Vector2f &origin) + + + const Vector2f & + getPosition + classsf_1_1Transformable.html + aea8b18e91a7bf7be589851bb9dd11241 + () const + + + float + getRotation + classsf_1_1Transformable.html + aa00b5c5d4a06ac24a94dd72c56931d3a + () const + + + const Vector2f & + getScale + classsf_1_1Transformable.html + a7bcae0e924213f2e89edd8926f2453af + () const + + + const Vector2f & + getOrigin + classsf_1_1Transformable.html + a898b33eb6513161eb5c747a072364f15 + () const + + + void + move + classsf_1_1Transformable.html + a86b461d6a941ad390c2ad8b6a4a20391 + (float offsetX, float offsetY) + + + void + move + classsf_1_1Transformable.html + ab9ca691522f6ddc1a40406849b87c469 + (const Vector2f &offset) + + + void + rotate + classsf_1_1Transformable.html + af8a5ffddc0d93f238fee3bf8efe1ebda + (float angle) + + + void + scale + classsf_1_1Transformable.html + a3de0c6d8957f3cf318092f3f60656391 + (float factorX, float factorY) + + + void + scale + classsf_1_1Transformable.html + adecaa6c69b1f27dd5194b067d96bb694 + (const Vector2f &factor) + + + const Transform & + getTransform + classsf_1_1Transformable.html + a3e1b4772a451ec66ac7e6af655726154 + () const + + + const Transform & + getInverseTransform + classsf_1_1Transformable.html + ac5e75d724436069d2268791c6b486916 + () const + + + + sf::Event::TextEvent + structsf_1_1Event_1_1TextEvent.html + + Uint32 + unicode + structsf_1_1Event_1_1TextEvent.html + a00d96b1a5328a1d7cbc276e161befcb0 + + + + + sf::Texture + classsf_1_1Texture.html + sf::GlResource + + + CoordinateType + classsf_1_1Texture.html + aa6fd3bbe3c334b3c4428edfb2765a82e + + + + Normalized + classsf_1_1Texture.html + aa6fd3bbe3c334b3c4428edfb2765a82ea69d6228950882e4d68be4ba4dbe7df73 + + + + Pixels + classsf_1_1Texture.html + aa6fd3bbe3c334b3c4428edfb2765a82ea6372f9c3a10203a7a69d8d5da59d82ff + + + + Normalized + classsf_1_1Texture.html + aa6fd3bbe3c334b3c4428edfb2765a82ea69d6228950882e4d68be4ba4dbe7df73 + + + + Pixels + classsf_1_1Texture.html + aa6fd3bbe3c334b3c4428edfb2765a82ea6372f9c3a10203a7a69d8d5da59d82ff + + + + + Texture + classsf_1_1Texture.html + a3e04674853b8533bf981db3173e3a4a7 + () + + + + Texture + classsf_1_1Texture.html + a524855cbf89de3b74be84d385fd229de + (const Texture &copy) + + + + ~Texture + classsf_1_1Texture.html + a9c5354ad40eb1c5aeeeb21f57ccd7e6c + () + + + bool + create + classsf_1_1Texture.html + a89b4c7d204acf1033c3a1b6e0a3ad0a3 + (unsigned int width, unsigned int height) + + + bool + loadFromFile + classsf_1_1Texture.html + a8e1b56eabfe33e2e0e1cb03712c7fcc7 + (const std::string &filename, const IntRect &area=IntRect()) + + + bool + loadFromMemory + classsf_1_1Texture.html + a2c4adb19dd4cbee0a588eeb85e52a249 + (const void *data, std::size_t size, const IntRect &area=IntRect()) + + + bool + loadFromStream + classsf_1_1Texture.html + a786b486a46b1c6d1c16ff4af61ecc601 + (InputStream &stream, const IntRect &area=IntRect()) + + + bool + loadFromImage + classsf_1_1Texture.html + abec4567ad9856a3596dc74803f26fba2 + (const Image &image, const IntRect &area=IntRect()) + + + Vector2u + getSize + classsf_1_1Texture.html + a9f86b8cc670c6399c539d4ce07ae5c8a + () const + + + Image + copyToImage + classsf_1_1Texture.html + a77e18a70de2e525ac5e4a7cd95f614b9 + () const + + + void + update + classsf_1_1Texture.html + ae4eab5c6781316840b0c50ad08370963 + (const Uint8 *pixels) + + + void + update + classsf_1_1Texture.html + a1352d8e16c2aeb4df586ed65dd2c36b9 + (const Uint8 *pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y) + + + void + update + classsf_1_1Texture.html + af9885ca00b74950d60feea28132d9691 + (const Texture &texture) + + + void + update + classsf_1_1Texture.html + a89beb474da1da84b5e38c9fc0b441fe4 + (const Texture &texture, unsigned int x, unsigned int y) + + + void + update + classsf_1_1Texture.html + a037cdf171af0fb392d07626a44a4ea17 + (const Image &image) + + + void + update + classsf_1_1Texture.html + a87f916490b757fe900798eedf3abf3ba + (const Image &image, unsigned int x, unsigned int y) + + + void + update + classsf_1_1Texture.html + ad3cceef238f7d5d2108a98dd38c17fc5 + (const Window &window) + + + void + update + classsf_1_1Texture.html + a154f246eb8059b602076009ab1cfd175 + (const Window &window, unsigned int x, unsigned int y) + + + void + setSmooth + classsf_1_1Texture.html + a0c3bd6825b9a99714f10d44179d74324 + (bool smooth) + + + bool + isSmooth + classsf_1_1Texture.html + a3ebb050b5a71e1d40ba66eb1a060e103 + () const + + + void + setSrgb + classsf_1_1Texture.html + af8a38872c50a33ff074bd0865db19dd4 + (bool sRgb) + + + bool + isSrgb + classsf_1_1Texture.html + a9d77ce4f8124abfda96900a6bd53bfe9 + () const + + + void + setRepeated + classsf_1_1Texture.html + aaa87d1eff053b9d4d34a24c784a28658 + (bool repeated) + + + bool + isRepeated + classsf_1_1Texture.html + af1a1a32ca5c799204b2bea4040df7647 + () const + + + bool + generateMipmap + classsf_1_1Texture.html + a7779a75c0324b5faff77602f871710a9 + () + + + Texture & + operator= + classsf_1_1Texture.html + a8d856e3b5865984d6ba0c25ac04fbedb + (const Texture &right) + + + void + swap + classsf_1_1Texture.html + a9243470c64b7ff0d231e00663e495798 + (Texture &right) + + + unsigned int + getNativeHandle + classsf_1_1Texture.html + a674b632608747bfc27b53a4935c835b0 + () const + + + static void + bind + classsf_1_1Texture.html + ae9a4274e7b95ebf7244d09c7445833b0 + (const Texture *texture, CoordinateType coordinateType=Normalized) + + + static unsigned int + getMaximumSize + classsf_1_1Texture.html + a0bf905d487b104b758549c2e9e20a3fb + () + + + + sf::Thread + classsf_1_1Thread.html + sf::NonCopyable + + + Thread + classsf_1_1Thread.html + a4cc65399bbb111cf8132537783b8e96c + (F function) + + + + Thread + classsf_1_1Thread.html + a719b2cc067d92d52c35064a49d850a53 + (F function, A argument) + + + + Thread + classsf_1_1Thread.html + aa9f473c8cbb078900c62b1fd14a83a34 + (void(C::*function)(), C *object) + + + + ~Thread + classsf_1_1Thread.html + af77942fc1730af7c31bc4c3a913a9c1d + () + + + void + launch + classsf_1_1Thread.html + a74f75a9e86e1eb47479496314048b5f6 + () + + + void + wait + classsf_1_1Thread.html + a724b1f94c2d54f84280f2f78bde95fa0 + () + + + void + terminate + classsf_1_1Thread.html + ad6b205d4f1ce38b8d44bba0f5501477c + () + + + + sf::ThreadLocal + classsf_1_1ThreadLocal.html + sf::NonCopyable + + + ThreadLocal + classsf_1_1ThreadLocal.html + a44ea3c4be4eef118080275cbf4cf04cd + (void *value=NULL) + + + + ~ThreadLocal + classsf_1_1ThreadLocal.html + acc612bddfd0f0507b1c5da8b3b8c75c2 + () + + + void + setValue + classsf_1_1ThreadLocal.html + ab7e334c83d77644a8e67ee31c3230007 + (void *value) + + + void * + getValue + classsf_1_1ThreadLocal.html + a3273f1976f96a838e386937eae33fc21 + () const + + + + sf::ThreadLocalPtr + classsf_1_1ThreadLocalPtr.html + typename T + sf::ThreadLocal + + + ThreadLocalPtr + classsf_1_1ThreadLocalPtr.html + a8c678211d7828d2a8c41cb534422d649 + (T *value=NULL) + + + T & + operator* + classsf_1_1ThreadLocalPtr.html + adcbb45ae077df714bf9c61e936d97770 + () const + + + T * + operator-> + classsf_1_1ThreadLocalPtr.html + a25646e1014a933d1a45b9ce17bab7703 + () const + + + + operator T* + classsf_1_1ThreadLocalPtr.html + a81ca089ae5cda72c7470ca93041c3cb2 + () const + + + ThreadLocalPtr< T > & + operator= + classsf_1_1ThreadLocalPtr.html + a14dcf1cdf5f6b3bcdd633014b2b671f5 + (T *value) + + + ThreadLocalPtr< T > & + operator= + classsf_1_1ThreadLocalPtr.html + a6792a6a808af06f0d13e3ceecf2fc947 + (const ThreadLocalPtr< T > &right) + + + + sf::Time + classsf_1_1Time.html + + + Time + classsf_1_1Time.html + acba0cfbc49e3a09a22a8e079eb67a05c + () + + + float + asSeconds + classsf_1_1Time.html + aa3df2f992d0b0041b4eb02258d43f0e3 + () const + + + Int32 + asMilliseconds + classsf_1_1Time.html + aa16858ca030a07eb18958c321f256e5a + () const + + + Int64 + asMicroseconds + classsf_1_1Time.html + a000c2c64b74658ebd228b9294a464275 + () const + + + static const Time + Zero + classsf_1_1Time.html + a8db127b632fa8da21550e7282af11fa0 + + + + Time + seconds + classsf_1_1Time.html + af9fc40a6c0e687e3430da1cf296385b1 + (float amount) + + + Time + milliseconds + classsf_1_1Time.html + a9231f886d925a24d181c8dcfa6448d87 + (Int32 amount) + + + Time + microseconds + classsf_1_1Time.html + a8a6ae28a1962198a69b92355649c6aa0 + (Int64 amount) + + + bool + operator== + classsf_1_1Time.html + a9bbb2368cf012149f1001535a20c664a + (Time left, Time right) + + + bool + operator!= + classsf_1_1Time.html + a3a142729f295af8b1baf2d8762bc39ac + (Time left, Time right) + + + bool + operator< + classsf_1_1Time.html + a3bad89721b8c026e80082a7aa539f244 + (Time left, Time right) + + + bool + operator> + classsf_1_1Time.html + a9a472ce6d82aa0caf8e20af4a4b309f2 + (Time left, Time right) + + + bool + operator<= + classsf_1_1Time.html + aafb9de87ed6047956cd9487ab807371f + (Time left, Time right) + + + bool + operator>= + classsf_1_1Time.html + a158c5f9a6abf575651b7b2f6af8aedaa + (Time left, Time right) + + + Time + operator- + classsf_1_1Time.html + acaead0aa2de9f82a548fcd8208a40f70 + (Time right) + + + Time + operator+ + classsf_1_1Time.html + a8249d3a28c8062c7c46cc426186f76c8 + (Time left, Time right) + + + Time & + operator+= + classsf_1_1Time.html + a34b983deefecaf2725131771d54631e0 + (Time &left, Time right) + + + Time + operator- + classsf_1_1Time.html + aebd95ec0cd0b2dc5d858e70149ccd136 + (Time left, Time right) + + + Time & + operator-= + classsf_1_1Time.html + ae0a16136d024a44bbaa4ca49ac172c8f + (Time &left, Time right) + + + Time + operator* + classsf_1_1Time.html + ab891d4f3dbb454f6c1c484a7844bb581 + (Time left, float right) + + + Time + operator* + classsf_1_1Time.html + a667d1568893f4e2520a223fa4e2b6ee2 + (Time left, Int64 right) + + + Time + operator* + classsf_1_1Time.html + a61e3255c79b3d98a1a04ed8968a87863 + (float left, Time right) + + + Time + operator* + classsf_1_1Time.html + a998a2ae6bd79e753bf9f4dea5b06370c + (Int64 left, Time right) + + + Time & + operator*= + classsf_1_1Time.html + a3f7baa961b8961fc5e6a37dea7de10e3 + (Time &left, float right) + + + Time & + operator*= + classsf_1_1Time.html + ac883749b4e0a72c32e166ad802220539 + (Time &left, Int64 right) + + + Time + operator/ + classsf_1_1Time.html + a67510d018fd010819ee075db2cbd004f + (Time left, float right) + + + Time + operator/ + classsf_1_1Time.html + a5f7b24dd13c0068d5cba678e1d5db9a6 + (Time left, Int64 right) + + + Time & + operator/= + classsf_1_1Time.html + ad513a413be41bc66feb0ff2b29d5f947 + (Time &left, float right) + + + Time & + operator/= + classsf_1_1Time.html + ac4b8df6ef282ee71808fd185f91490aa + (Time &left, Int64 right) + + + float + operator/ + classsf_1_1Time.html + a097cf1326d2d50e0043ff4e865c1bbac + (Time left, Time right) + + + Time + operator% + classsf_1_1Time.html + abe7206e15c2bf7ce8695f82219d466d2 + (Time left, Time right) + + + Time & + operator%= + classsf_1_1Time.html + a880fb0137cd426bd4457fd9e4a2f9d83 + (Time &left, Time right) + + + + sf::Touch + classsf_1_1Touch.html + + static bool + isDown + classsf_1_1Touch.html + a2f85297123ea4e401d02c346e50d48a3 + (unsigned int finger) + + + static Vector2i + getPosition + classsf_1_1Touch.html + af1b7035be709091c7475075e43e2bc23 + (unsigned int finger) + + + static Vector2i + getPosition + classsf_1_1Touch.html + a8a1456574d2825d4249fcf72f11d4398 + (unsigned int finger, const WindowBase &relativeTo) + + + + sf::Event::TouchEvent + structsf_1_1Event_1_1TouchEvent.html + + unsigned int + finger + structsf_1_1Event_1_1TouchEvent.html + a9a79fe86bf9ac3c16ec7326f96feb61a + + + + int + x + structsf_1_1Event_1_1TouchEvent.html + a8993963790b850caa68b98d3cad2be45 + + + + int + y + structsf_1_1Event_1_1TouchEvent.html + add80639dc68bc37e3275744d501cdbe0 + + + + + sf::Transform + classsf_1_1Transform.html + + + Transform + classsf_1_1Transform.html + ac32de51bd0b9f3d52fbe0838225ee83b + () + + + + Transform + classsf_1_1Transform.html + a78c48677712fcf41122d02f1301d71a3 + (float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22) + + + const float * + getMatrix + classsf_1_1Transform.html + ab85cb4194f42a965d337a8f02783c534 + () const + + + Transform + getInverse + classsf_1_1Transform.html + a14f49e81af44aabcff7611f6703a1e4a + () const + + + Vector2f + transformPoint + classsf_1_1Transform.html + af2e38c3c077d28898686662558b41135 + (float x, float y) const + + + Vector2f + transformPoint + classsf_1_1Transform.html + ab42a0bb7a252c6d221004f6372ce5fdc + (const Vector2f &point) const + + + FloatRect + transformRect + classsf_1_1Transform.html + a3824a20505d81a94bc22be1ffee57d3d + (const FloatRect &rectangle) const + + + Transform & + combine + classsf_1_1Transform.html + ad8403f888799b5c9f781cb9f3757f2a4 + (const Transform &transform) + + + Transform & + translate + classsf_1_1Transform.html + a053cd024e320ae719837386d126d0f51 + (float x, float y) + + + Transform & + translate + classsf_1_1Transform.html + a2426209f1fd3cc02129dec373a3c6f69 + (const Vector2f &offset) + + + Transform & + rotate + classsf_1_1Transform.html + ad09ce22a1fb08709f66f30befc7b2e7b + (float angle) + + + Transform & + rotate + classsf_1_1Transform.html + ad78237e81d1de866d1b3c040ad003971 + (float angle, float centerX, float centerY) + + + Transform & + rotate + classsf_1_1Transform.html + a11aa9a4fbd9254e7d22b96f92f018d09 + (float angle, const Vector2f &center) + + + Transform & + scale + classsf_1_1Transform.html + a846e9ff8567f50adea9b3ce4c70c1554 + (float scaleX, float scaleY) + + + Transform & + scale + classsf_1_1Transform.html + af1ad4ae13dacaf812b6411142243042b + (float scaleX, float scaleY, float centerX, float centerY) + + + Transform & + scale + classsf_1_1Transform.html + a23fe4e63821354600b7592be90f2d65e + (const Vector2f &factors) + + + Transform & + scale + classsf_1_1Transform.html + a486a4a1946208a883c7f8ec1e9cf2e35 + (const Vector2f &factors, const Vector2f &center) + + + static const Transform + Identity + classsf_1_1Transform.html + aa4eb1eecbcb9979d76e2543b337fdb13 + + + + Transform + operator* + classsf_1_1Transform.html + a85ea4e5539795f9b2ceb7d4b06736c8f + (const Transform &left, const Transform &right) + + + Transform & + operator*= + classsf_1_1Transform.html + a189899674616490f6250953ac581ac30 + (Transform &left, const Transform &right) + + + Vector2f + operator* + classsf_1_1Transform.html + a4eeee49125c3c72c250062eef35ceb75 + (const Transform &left, const Vector2f &right) + + + bool + operator== + classsf_1_1Transform.html + aa2de0a3ee2f8af05dbc94bf3b4633b4a + (const Transform &left, const Transform &right) + + + bool + operator!= + classsf_1_1Transform.html + a5eee840ff0b2db9e5f57a87281cc2b01 + (const Transform &left, const Transform &right) + + + + sf::Transformable + classsf_1_1Transformable.html + + + Transformable + classsf_1_1Transformable.html + ae71710de0fef423121bab1c684954a2e + () + + + virtual + ~Transformable + classsf_1_1Transformable.html + a43253abcb863195a673c2a347a7425cc + () + + + void + setPosition + classsf_1_1Transformable.html + a4dbfb1a7c80688b0b4c477d706550208 + (float x, float y) + + + void + setPosition + classsf_1_1Transformable.html + af1a42209ce2b5d3f07b00f917bcd8015 + (const Vector2f &position) + + + void + setRotation + classsf_1_1Transformable.html + a32baf2bf1a74699b03bf8c95030a38ed + (float angle) + + + void + setScale + classsf_1_1Transformable.html + aaec50b46b3f41b054763304d1e727471 + (float factorX, float factorY) + + + void + setScale + classsf_1_1Transformable.html + a4c48a87f1626047e448f9c1a68ff167e + (const Vector2f &factors) + + + void + setOrigin + classsf_1_1Transformable.html + a56c67bd80aae8418d13fb96c034d25ec + (float x, float y) + + + void + setOrigin + classsf_1_1Transformable.html + aa93a835ffbf3bee2098dfbbc695a7f05 + (const Vector2f &origin) + + + const Vector2f & + getPosition + classsf_1_1Transformable.html + aea8b18e91a7bf7be589851bb9dd11241 + () const + + + float + getRotation + classsf_1_1Transformable.html + aa00b5c5d4a06ac24a94dd72c56931d3a + () const + + + const Vector2f & + getScale + classsf_1_1Transformable.html + a7bcae0e924213f2e89edd8926f2453af + () const + + + const Vector2f & + getOrigin + classsf_1_1Transformable.html + a898b33eb6513161eb5c747a072364f15 + () const + + + void + move + classsf_1_1Transformable.html + a86b461d6a941ad390c2ad8b6a4a20391 + (float offsetX, float offsetY) + + + void + move + classsf_1_1Transformable.html + ab9ca691522f6ddc1a40406849b87c469 + (const Vector2f &offset) + + + void + rotate + classsf_1_1Transformable.html + af8a5ffddc0d93f238fee3bf8efe1ebda + (float angle) + + + void + scale + classsf_1_1Transformable.html + a3de0c6d8957f3cf318092f3f60656391 + (float factorX, float factorY) + + + void + scale + classsf_1_1Transformable.html + adecaa6c69b1f27dd5194b067d96bb694 + (const Vector2f &factor) + + + const Transform & + getTransform + classsf_1_1Transformable.html + a3e1b4772a451ec66ac7e6af655726154 + () const + + + const Transform & + getInverseTransform + classsf_1_1Transformable.html + ac5e75d724436069d2268791c6b486916 + () const + + + + sf::GlResource::TransientContextLock + classsf_1_1GlResource_1_1TransientContextLock.html + sf::NonCopyable + + + TransientContextLock + classsf_1_1GlResource_1_1TransientContextLock.html + a6434ee8f0380c300b361be038f37123a + () + + + + ~TransientContextLock + classsf_1_1GlResource_1_1TransientContextLock.html + a169285281b252ac8d54523b0fcc4b814 + () + + + + sf::UdpSocket + classsf_1_1UdpSocket.html + sf::Socket + + MaxDatagramSize + classsf_1_1UdpSocket.html + a8ad087820b1ae07267858212f3d0fac5a728a7d33027bee0d65f70f964dd9c9eb + + + + MaxDatagramSize + classsf_1_1UdpSocket.html + a8ad087820b1ae07267858212f3d0fac5a728a7d33027bee0d65f70f964dd9c9eb + + + + + Status + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dc + + + + Done + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1de3a85bc56d3ae85b3d0f3cfd04ae90 + + + + NotReady + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca8554848daae98f996e131bdeed076c09 + + + + Partial + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca181c163fad2eaea927185d127c392706 + + + + Disconnected + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dcab215141f756acdc23c67fad149710eb1 + + + + Error + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1dc9854433a28c22e192721179a2df5d + + + + AnyPort + classsf_1_1Socket.html + aa3e6c984bcb81a35234dcc9cc8369d75a5a3c30fd128895403afc11076f461b19 + + + + Done + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1de3a85bc56d3ae85b3d0f3cfd04ae90 + + + + NotReady + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca8554848daae98f996e131bdeed076c09 + + + + Partial + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca181c163fad2eaea927185d127c392706 + + + + Disconnected + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dcab215141f756acdc23c67fad149710eb1 + + + + Error + classsf_1_1Socket.html + a51bf0fd51057b98a10fbb866246176dca1dc9854433a28c22e192721179a2df5d + + + + AnyPort + classsf_1_1Socket.html + aa3e6c984bcb81a35234dcc9cc8369d75a5a3c30fd128895403afc11076f461b19 + + + + + UdpSocket + classsf_1_1UdpSocket.html + abb10725e26dee9d3a8165fe87ffb71bb + () + + + unsigned short + getLocalPort + classsf_1_1UdpSocket.html + a5c03644b3da34bb763bce93e758c938e + () const + + + Status + bind + classsf_1_1UdpSocket.html + ad764c3d06d90b4714dcc97a0d1647bcc + (unsigned short port, const IpAddress &address=IpAddress::Any) + + + void + unbind + classsf_1_1UdpSocket.html + a2c4abb8102a1bd31f51fcfe7f15427a3 + () + + + Status + send + classsf_1_1UdpSocket.html + a664ab8f26f37c21cc4de1b847c2efcca + (const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort) + + + Status + receive + classsf_1_1UdpSocket.html + ade9ca0f7ed7919136917b0b997a9833a + (void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort) + + + Status + send + classsf_1_1UdpSocket.html + a48969a62c80d40fd74293a740798e435 + (Packet &packet, const IpAddress &remoteAddress, unsigned short remotePort) + + + Status + receive + classsf_1_1UdpSocket.html + afdd5c655d00c96222d5b477fc057a22b + (Packet &packet, IpAddress &remoteAddress, unsigned short &remotePort) + + + void + setBlocking + classsf_1_1Socket.html + a165fc1423e281ea2714c70303d3a9782 + (bool blocking) + + + bool + isBlocking + classsf_1_1Socket.html + ab1ceca9ac114b8baeeda3b34a0aca468 + () const + + + + Type + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8 + + + + Tcp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8acc02e97e90234b957eaad4dff7f22214 + + + + Udp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8a6ebf3094830db4820191a327f3cc6ce2 + + + + Tcp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8acc02e97e90234b957eaad4dff7f22214 + + + + Udp + classsf_1_1Socket.html + a5d3ff44e56e68f02816bb0fabc34adf8a6ebf3094830db4820191a327f3cc6ce2 + + + + SocketHandle + getHandle + classsf_1_1Socket.html + a675457784284ae2f5640bbbe16729393 + () const + + + void + create + classsf_1_1Socket.html + aafbe140f4b1921e0d19e88cf7a61dcbc + () + + + void + create + classsf_1_1Socket.html + af1dd898f7aa3ead7ff7b2d1c20e97781 + (SocketHandle handle) + + + void + close + classsf_1_1Socket.html + a71f2f5c2aa99e01cafe824fee4c573be + () + + + + sf::Utf + classsf_1_1Utf.html + unsigned int N + + + sf::Utf< 16 > + classsf_1_1Utf_3_0116_01_4.html + + static In + decode + classsf_1_1Utf_3_0116_01_4.html + a17be6fc08e51182e7ac8bf9269dfae37 + (In begin, In end, Uint32 &output, Uint32 replacement=0) + + + static Out + encode + classsf_1_1Utf_3_0116_01_4.html + a516090c84ceec2cfde0a13b6148363bb + (Uint32 input, Out output, Uint16 replacement=0) + + + static In + next + classsf_1_1Utf_3_0116_01_4.html + ab899108d77ce088eb001588e84d91525 + (In begin, In end) + + + static std::size_t + count + classsf_1_1Utf_3_0116_01_4.html + a6df8d9be8211ffe1095b3b82eac83f6f + (In begin, In end) + + + static Out + fromAnsi + classsf_1_1Utf_3_0116_01_4.html + a8a595dc1ea57ecf7aad944964913f0ff + (In begin, In end, Out output, const std::locale &locale=std::locale()) + + + static Out + fromWide + classsf_1_1Utf_3_0116_01_4.html + a263423929b6f8e4d3ad09b45ac5cb0a1 + (In begin, In end, Out output) + + + static Out + fromLatin1 + classsf_1_1Utf_3_0116_01_4.html + a52293df75893733fe6cf84b8a017cbf7 + (In begin, In end, Out output) + + + static Out + toAnsi + classsf_1_1Utf_3_0116_01_4.html + a6d2bfbdfe46364bd49bca28a410b18f7 + (In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale()) + + + static Out + toWide + classsf_1_1Utf_3_0116_01_4.html + a42bace5988f7f20497cfdd6025c2d7f2 + (In begin, In end, Out output, wchar_t replacement=0) + + + static Out + toLatin1 + classsf_1_1Utf_3_0116_01_4.html + ad0cc57ebf48fac584f4d5f3d30a20010 + (In begin, In end, Out output, char replacement=0) + + + static Out + toUtf8 + classsf_1_1Utf_3_0116_01_4.html + afdd2f31536ce3fba4dfb632dfdd6e4b7 + (In begin, In end, Out output) + + + static Out + toUtf16 + classsf_1_1Utf_3_0116_01_4.html + a0c9744c8f142360a8afebb24da134b34 + (In begin, In end, Out output) + + + static Out + toUtf32 + classsf_1_1Utf_3_0116_01_4.html + a781174f776a3effb96c1ccd9a4513ab1 + (In begin, In end, Out output) + + + + sf::Utf< 32 > + classsf_1_1Utf_3_0132_01_4.html + + static In + decode + classsf_1_1Utf_3_0132_01_4.html + ad754ce8476f7b80563890dec12cefd46 + (In begin, In end, Uint32 &output, Uint32 replacement=0) + + + static Out + encode + classsf_1_1Utf_3_0132_01_4.html + a27b9d3f3fc49a8c88d91966889fcfca1 + (Uint32 input, Out output, Uint32 replacement=0) + + + static In + next + classsf_1_1Utf_3_0132_01_4.html + a788b4ebc728dde2aaba38f3605d4867c + (In begin, In end) + + + static std::size_t + count + classsf_1_1Utf_3_0132_01_4.html + a9b18c32b9e6d4b3126e9b4af45988b55 + (In begin, In end) + + + static Out + fromAnsi + classsf_1_1Utf_3_0132_01_4.html + a384a4169287af15876783ad477cac4e3 + (In begin, In end, Out output, const std::locale &locale=std::locale()) + + + static Out + fromWide + classsf_1_1Utf_3_0132_01_4.html + abdf0d41e0c8814a68326688e3b8d187f + (In begin, In end, Out output) + + + static Out + fromLatin1 + classsf_1_1Utf_3_0132_01_4.html + a05741b76b5a26267a72735e40ca61c55 + (In begin, In end, Out output) + + + static Out + toAnsi + classsf_1_1Utf_3_0132_01_4.html + a768cb205f7f1d20cd900e34fb48f9316 + (In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale()) + + + static Out + toWide + classsf_1_1Utf_3_0132_01_4.html + a0d5bf45a9732beb935592da6bed1242c + (In begin, In end, Out output, wchar_t replacement=0) + + + static Out + toLatin1 + classsf_1_1Utf_3_0132_01_4.html + a064ce0ad81768d0d99b6b3e2e980e3ce + (In begin, In end, Out output, char replacement=0) + + + static Out + toUtf8 + classsf_1_1Utf_3_0132_01_4.html + a193e155964b073c8ba838434f41d5e97 + (In begin, In end, Out output) + + + static Out + toUtf16 + classsf_1_1Utf_3_0132_01_4.html + a3f97efb599ad237af06f076f3fcfa354 + (In begin, In end, Out output) + + + static Out + toUtf32 + classsf_1_1Utf_3_0132_01_4.html + abd7c1e80791c80c4d78257440de96140 + (In begin, In end, Out output) + + + static Uint32 + decodeAnsi + classsf_1_1Utf_3_0132_01_4.html + a68346ea833f88267a7c739d4d96fb86f + (In input, const std::locale &locale=std::locale()) + + + static Uint32 + decodeWide + classsf_1_1Utf_3_0132_01_4.html + a043fe25f5f4dbc205e78e6f1d99840dc + (In input) + + + static Out + encodeAnsi + classsf_1_1Utf_3_0132_01_4.html + af6590226a071076ca22d818573a16ded + (Uint32 codepoint, Out output, char replacement=0, const std::locale &locale=std::locale()) + + + static Out + encodeWide + classsf_1_1Utf_3_0132_01_4.html + a52e511e74ddc5df1bbf18f910193bc47 + (Uint32 codepoint, Out output, wchar_t replacement=0) + + + + sf::Utf< 8 > + classsf_1_1Utf_3_018_01_4.html + + static In + decode + classsf_1_1Utf_3_018_01_4.html + a59d4e8d5832961e62b263d308b72bf4b + (In begin, In end, Uint32 &output, Uint32 replacement=0) + + + static Out + encode + classsf_1_1Utf_3_018_01_4.html + a5fbc6b5a996f52e9e4a14633d0d71847 + (Uint32 input, Out output, Uint8 replacement=0) + + + static In + next + classsf_1_1Utf_3_018_01_4.html + a0365a0b38700baa161843563d083edf6 + (In begin, In end) + + + static std::size_t + count + classsf_1_1Utf_3_018_01_4.html + af1f15d9a772ee887be39e97431e15d32 + (In begin, In end) + + + static Out + fromAnsi + classsf_1_1Utf_3_018_01_4.html + a1b62ba85ad3c8ce68746e16192b3eef0 + (In begin, In end, Out output, const std::locale &locale=std::locale()) + + + static Out + fromWide + classsf_1_1Utf_3_018_01_4.html + aa99e636a7addc157b425dfc11b008f42 + (In begin, In end, Out output) + + + static Out + fromLatin1 + classsf_1_1Utf_3_018_01_4.html + a85dd3643b7109a1a2f802747e55e28e8 + (In begin, In end, Out output) + + + static Out + toAnsi + classsf_1_1Utf_3_018_01_4.html + a3d8b02f29021bd48831e7706d826f0c5 + (In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale()) + + + static Out + toWide + classsf_1_1Utf_3_018_01_4.html + ac6633c64ff1fad6bd1bfe72c37b3a468 + (In begin, In end, Out output, wchar_t replacement=0) + + + static Out + toLatin1 + classsf_1_1Utf_3_018_01_4.html + adf6f6e0a8ee0527c8ab390ce5c0b6b13 + (In begin, In end, Out output, char replacement=0) + + + static Out + toUtf8 + classsf_1_1Utf_3_018_01_4.html + aef68054cab6a592c0b04de94e93bb520 + (In begin, In end, Out output) + + + static Out + toUtf16 + classsf_1_1Utf_3_018_01_4.html + a925ac9e141dcb6f9b07c7b95f7cfbda2 + (In begin, In end, Out output) + + + static Out + toUtf32 + classsf_1_1Utf_3_018_01_4.html + a79395429baba13dd04a8c1fba745ce65 + (In begin, In end, Out output) + + + + sf::Vector2 + classsf_1_1Vector2.html + typename T + + + Vector2 + classsf_1_1Vector2.html + a58c32383b5291380db4b43a289f75988 + () + + + + Vector2 + classsf_1_1Vector2.html + aed26a72164e59e8a4a0aeee2049568f1 + (T X, T Y) + + + + Vector2 + classsf_1_1Vector2.html + a3da455e0ae3f8ff6d2fe36d10b332d10 + (const Vector2< U > &vector) + + + T + x + classsf_1_1Vector2.html + a1e6ad77fa155f3753bfb92699bd28141 + + + + T + y + classsf_1_1Vector2.html + a420f2481b015f4eb929c75f2af564299 + + + + Vector2< T > + operator- + classsf_1_1Vector2.html + a3885c2e66dc427cec7eaa178d59d8e8b + (const Vector2< T > &right) + + + Vector2< T > & + operator+= + classsf_1_1Vector2.html + ad4b7a9d355d57790bfc7df0ade8bb628 + (Vector2< T > &left, const Vector2< T > &right) + + + Vector2< T > & + operator-= + classsf_1_1Vector2.html + a30a5a12ad03c9a3a982a0a313bf84e6f + (Vector2< T > &left, const Vector2< T > &right) + + + Vector2< T > + operator+ + classsf_1_1Vector2.html + a72421239823c38a6b780c86a710ead07 + (const Vector2< T > &left, const Vector2< T > &right) + + + Vector2< T > + operator- + classsf_1_1Vector2.html + ad027adae53ec547a86c20deeb05c9e85 + (const Vector2< T > &left, const Vector2< T > &right) + + + Vector2< T > + operator* + classsf_1_1Vector2.html + a5f48ca928995b41c89f155afe8d16b02 + (const Vector2< T > &left, T right) + + + Vector2< T > + operator* + classsf_1_1Vector2.html + ad8b3e1cf7b156a984bc1427539ca8605 + (T left, const Vector2< T > &right) + + + Vector2< T > & + operator*= + classsf_1_1Vector2.html + abea24cb28c0d6e2957e259ba4e65d70e + (Vector2< T > &left, T right) + + + Vector2< T > + operator/ + classsf_1_1Vector2.html + a7409dd89cb3aad6c3bc6622311107311 + (const Vector2< T > &left, T right) + + + Vector2< T > & + operator/= + classsf_1_1Vector2.html + ac4d293c9dc7954ccfd5e373972f38b03 + (Vector2< T > &left, T right) + + + bool + operator== + classsf_1_1Vector2.html + a9a7b2d36c3850828fdb651facfd25136 + (const Vector2< T > &left, const Vector2< T > &right) + + + bool + operator!= + classsf_1_1Vector2.html + a01673da35ef9c52d0e54b8263549a956 + (const Vector2< T > &left, const Vector2< T > &right) + + + + sf::Vector3 + classsf_1_1Vector3.html + typename T + + + Vector3 + classsf_1_1Vector3.html + aee8be1985c6e45e381ad4071265636f9 + () + + + + Vector3 + classsf_1_1Vector3.html + a99ed75b68f58adfa3e9fa0561b424bf6 + (T X, T Y, T Z) + + + + Vector3 + classsf_1_1Vector3.html + adb2b2e150025e97ccfa96219bbed59d1 + (const Vector3< U > &vector) + + + T + x + classsf_1_1Vector3.html + a3cb0c769390bc37c346bb1a69e510d16 + + + + T + y + classsf_1_1Vector3.html + a6590d50ccb862c5efc5512e974e9b794 + + + + T + z + classsf_1_1Vector3.html + a2f36ab4b552c028e3a9734c1ad4df7d1 + + + + Vector3< T > + operator- + classsf_1_1Vector3.html + a9b75d2fb9b0f2fd9fe33f8f06f9dda75 + (const Vector3< T > &left) + + + Vector3< T > & + operator+= + classsf_1_1Vector3.html + abc28859af163c63318ea2723b81c5ad9 + (Vector3< T > &left, const Vector3< T > &right) + + + Vector3< T > & + operator-= + classsf_1_1Vector3.html + aa465672d2a4ee5fd354e585cf08d2ab9 + (Vector3< T > &left, const Vector3< T > &right) + + + Vector3< T > + operator+ + classsf_1_1Vector3.html + a6500a0cb00e07801e9e9d7e96852ddd3 + (const Vector3< T > &left, const Vector3< T > &right) + + + Vector3< T > + operator- + classsf_1_1Vector3.html + abe0b9411c00cf807bf8a5f835874bd2a + (const Vector3< T > &left, const Vector3< T > &right) + + + Vector3< T > + operator* + classsf_1_1Vector3.html + a44ec312b31c1a85dcff4863795f98329 + (const Vector3< T > &left, T right) + + + Vector3< T > + operator* + classsf_1_1Vector3.html + aa6f2b0d9f79c1b9774759b7087affbb1 + (T left, const Vector3< T > &right) + + + Vector3< T > & + operator*= + classsf_1_1Vector3.html + ad5fb972775ce8ab58cd9670789e806a7 + (Vector3< T > &left, T right) + + + Vector3< T > + operator/ + classsf_1_1Vector3.html + ad4ba4a83de236ddeb92a7b759187e90d + (const Vector3< T > &left, T right) + + + Vector3< T > & + operator/= + classsf_1_1Vector3.html + a8995a700f9dffccc6dddb3696ae17b64 + (Vector3< T > &left, T right) + + + bool + operator== + classsf_1_1Vector3.html + a388d72db973306a35ba467016b3dee30 + (const Vector3< T > &left, const Vector3< T > &right) + + + bool + operator!= + classsf_1_1Vector3.html + a608500d1ad3b78082cb5bb4356742bd4 + (const Vector3< T > &left, const Vector3< T > &right) + + + + sf::Vertex + classsf_1_1Vertex.html + + + Vertex + classsf_1_1Vertex.html + a6b4c79cd69f7ec1296fede536f39e9c8 + () + + + + Vertex + classsf_1_1Vertex.html + a4dccc5c351b73b6fac169fe442535b40 + (const Vector2f &thePosition) + + + + Vertex + classsf_1_1Vertex.html + a70b0679b4ec531d5bd1a7d0225c7321a + (const Vector2f &thePosition, const Color &theColor) + + + + Vertex + classsf_1_1Vertex.html + ab9bf849c4c0d82d09bf5bece23d2456a + (const Vector2f &thePosition, const Vector2f &theTexCoords) + + + + Vertex + classsf_1_1Vertex.html + ad5943f2b3cbc64b6e714bb37ccaf4960 + (const Vector2f &thePosition, const Color &theColor, const Vector2f &theTexCoords) + + + Vector2f + position + classsf_1_1Vertex.html + a8a4e0f4dfa7f1eb215c92e93d04f0ac0 + + + + Color + color + classsf_1_1Vertex.html + a799faa0629442e90f07cd2edb568ff80 + + + + Vector2f + texCoords + classsf_1_1Vertex.html + a9e79bd05818d36c4789751908037097c + + + + + sf::VertexArray + classsf_1_1VertexArray.html + sf::Drawable + + + VertexArray + classsf_1_1VertexArray.html + a15729e01df8fc0021f9774dfb56295c1 + () + + + + VertexArray + classsf_1_1VertexArray.html + a4bb1c29a0e3354a035075899d84f02f9 + (PrimitiveType type, std::size_t vertexCount=0) + + + std::size_t + getVertexCount + classsf_1_1VertexArray.html + abda90e8d841a273d93164f0c0032bd8d + () const + + + Vertex & + operator[] + classsf_1_1VertexArray.html + a913953848726c1c65f8617497e8fccd6 + (std::size_t index) + + + const Vertex & + operator[] + classsf_1_1VertexArray.html + a8336081e73a14a5e4ad0aa9f926d82be + (std::size_t index) const + + + void + clear + classsf_1_1VertexArray.html + a3654c424aca1f9e468f369bc777c839c + () + + + void + resize + classsf_1_1VertexArray.html + a0c0fe239e8f9a54e64d3bbc96bf548c0 + (std::size_t vertexCount) + + + void + append + classsf_1_1VertexArray.html + a80c8f6865e53bd21fc6cb10fffa10035 + (const Vertex &vertex) + + + void + setPrimitiveType + classsf_1_1VertexArray.html + aa38c10707c28a97f4627ae8b2f3ad969 + (PrimitiveType type) + + + PrimitiveType + getPrimitiveType + classsf_1_1VertexArray.html + aa1a60d84543aa6e220683349b645f130 + () const + + + FloatRect + getBounds + classsf_1_1VertexArray.html + abd57744c732abfc7d4c98d8e1d4ccca1 + () const + + + + sf::VertexBuffer + classsf_1_1VertexBuffer.html + sf::Drawable + sf::GlResource + + + Usage + classsf_1_1VertexBuffer.html + a3a531528684e63ecb45edd51282f5cb7 + + + + Stream + classsf_1_1VertexBuffer.html + a3a531528684e63ecb45edd51282f5cb7aeed06a391698772af58a9cfdff77deaf + + + + Dynamic + classsf_1_1VertexBuffer.html + a3a531528684e63ecb45edd51282f5cb7a13365282a5933ecd9cc6a3ef39ba58f7 + + + + Static + classsf_1_1VertexBuffer.html + a3a531528684e63ecb45edd51282f5cb7a041ab564f6cd1b6775bd0ebff06b6d7e + + + + Stream + classsf_1_1VertexBuffer.html + a3a531528684e63ecb45edd51282f5cb7aeed06a391698772af58a9cfdff77deaf + + + + Dynamic + classsf_1_1VertexBuffer.html + a3a531528684e63ecb45edd51282f5cb7a13365282a5933ecd9cc6a3ef39ba58f7 + + + + Static + classsf_1_1VertexBuffer.html + a3a531528684e63ecb45edd51282f5cb7a041ab564f6cd1b6775bd0ebff06b6d7e + + + + + VertexBuffer + classsf_1_1VertexBuffer.html + aba8836c571cef25a0f80e478add1560a + () + + + + VertexBuffer + classsf_1_1VertexBuffer.html + a3f51dcd61dac52be54ba7b22ebdea7c8 + (PrimitiveType type) + + + + VertexBuffer + classsf_1_1VertexBuffer.html + af2dce0a43e061e5f91b97cf7267427e3 + (Usage usage) + + + + VertexBuffer + classsf_1_1VertexBuffer.html + a326a5c89f1ba01b51b323535494434e8 + (PrimitiveType type, Usage usage) + + + + VertexBuffer + classsf_1_1VertexBuffer.html + a2f2ff1e218cfc749b87f8873e23c016b + (const VertexBuffer &copy) + + + + ~VertexBuffer + classsf_1_1VertexBuffer.html + acfbb3b16221bfb9406fcaa18cfcac3e7 + () + + + bool + create + classsf_1_1VertexBuffer.html + aa68e128d59c7f7d5eb0d4d94125439a5 + (std::size_t vertexCount) + + + std::size_t + getVertexCount + classsf_1_1VertexBuffer.html + a6c534536ed186a2ad65e75484c8abafe + () const + + + bool + update + classsf_1_1VertexBuffer.html + ad100a5f578a91c49a9009e3c6956c82d + (const Vertex *vertices) + + + bool + update + classsf_1_1VertexBuffer.html + ae6c8649a64861507010d21e77fbd53fa + (const Vertex *vertices, std::size_t vertexCount, unsigned int offset) + + + bool + update + classsf_1_1VertexBuffer.html + a41f8bbcf07f403e7fe29b1b905dc7544 + (const VertexBuffer &vertexBuffer) + + + VertexBuffer & + operator= + classsf_1_1VertexBuffer.html + ae9d19f938e30e1bb1788067e3c134653 + (const VertexBuffer &right) + + + void + swap + classsf_1_1VertexBuffer.html + a3954d696848dc4c921c15a6b4459c8e6 + (VertexBuffer &right) + + + unsigned int + getNativeHandle + classsf_1_1VertexBuffer.html + a343fa0a240c91bc4203a6727fcd9b920 + () const + + + void + setPrimitiveType + classsf_1_1VertexBuffer.html + a7c429dbef94224a86d605cf4c68aa02d + (PrimitiveType type) + + + PrimitiveType + getPrimitiveType + classsf_1_1VertexBuffer.html + a02061d85472ff69e7ad14dc72f8fcaa4 + () const + + + void + setUsage + classsf_1_1VertexBuffer.html + ace40070db1fccf12a025383b23e81cad + (Usage usage) + + + Usage + getUsage + classsf_1_1VertexBuffer.html + a5e36f2b3955bb35648c17550a9c096e1 + () const + + + static void + bind + classsf_1_1VertexBuffer.html + a1c623e9701b43125e4b3661bc0d0b65b + (const VertexBuffer *vertexBuffer) + + + static bool + isAvailable + classsf_1_1VertexBuffer.html + a6304bc4134dc0164dc94eff887b08847 + () + + + + sf::VideoMode + classsf_1_1VideoMode.html + + + VideoMode + classsf_1_1VideoMode.html + a04c9417e5c304510bef5f6aeb03f6ce1 + () + + + + VideoMode + classsf_1_1VideoMode.html + a46c35ed41de9e115661dcd529d64e9d3 + (unsigned int modeWidth, unsigned int modeHeight, unsigned int modeBitsPerPixel=32) + + + bool + isValid + classsf_1_1VideoMode.html + ad5e04c044b0925523c75ecb173d2129a + () const + + + static VideoMode + getDesktopMode + classsf_1_1VideoMode.html + ac1be160a4342e6eafb2cb0e8c9b18d44 + () + + + static const std::vector< VideoMode > & + getFullscreenModes + classsf_1_1VideoMode.html + a0f99e67ef2b51fbdc335d9991232609e + () + + + unsigned int + width + classsf_1_1VideoMode.html + a9b3b2ad2cac6b9c266823fb5ed506d90 + + + + unsigned int + height + classsf_1_1VideoMode.html + a5a88d44c9470db7474361a42a189342d + + + + unsigned int + bitsPerPixel + classsf_1_1VideoMode.html + aa080f1ef96a1008d58b1920eceb189df + + + + bool + operator== + classsf_1_1VideoMode.html + aca24086fd94d11014f3a0b5ca9a3acd6 + (const VideoMode &left, const VideoMode &right) + + + bool + operator!= + classsf_1_1VideoMode.html + a34b5c266a7b9cd5bc95de62f8beafc5a + (const VideoMode &left, const VideoMode &right) + + + bool + operator< + classsf_1_1VideoMode.html + a54cc77c0b6c4b133e0147a43d6829b13 + (const VideoMode &left, const VideoMode &right) + + + bool + operator> + classsf_1_1VideoMode.html + a5b894cab5f2a3a14597e4c6d200179a4 + (const VideoMode &left, const VideoMode &right) + + + bool + operator<= + classsf_1_1VideoMode.html + aa094b7b9ae4c0194892ebda7b4b9bb37 + (const VideoMode &left, const VideoMode &right) + + + bool + operator>= + classsf_1_1VideoMode.html + a6e3d91683fcabb88c5b640e9884fe3df + (const VideoMode &left, const VideoMode &right) + + + + sf::View + classsf_1_1View.html + + + View + classsf_1_1View.html + a28c38308ff089ae5bdacd001d12286d3 + () + + + + View + classsf_1_1View.html + a1d63bc49e041b3b1ff992bb6430e1326 + (const FloatRect &rectangle) + + + + View + classsf_1_1View.html + afdaf84cfc910ef160450d63603457ea4 + (const Vector2f &center, const Vector2f &size) + + + void + setCenter + classsf_1_1View.html + aa8e3fedb008306ff9811163545fb75f2 + (float x, float y) + + + void + setCenter + classsf_1_1View.html + ab0296b03793e0873e6ae9e15311f3e78 + (const Vector2f &center) + + + void + setSize + classsf_1_1View.html + a9525b73fe9fbaceb9568faf56b399dab + (float width, float height) + + + void + setSize + classsf_1_1View.html + a9e08d471ce21aa0e69ce55ff9de66d29 + (const Vector2f &size) + + + void + setRotation + classsf_1_1View.html + a24d0503c9c51f5ef5918612786d325c1 + (float angle) + + + void + setViewport + classsf_1_1View.html + a8eaec46b7d332fe834f016d0187d4b4a + (const FloatRect &viewport) + + + void + reset + classsf_1_1View.html + ac95b636eafab3922b7e8304fb6c00d7d + (const FloatRect &rectangle) + + + const Vector2f & + getCenter + classsf_1_1View.html + a8bd01cd2bcad03e547232b190c215b09 + () const + + + const Vector2f & + getSize + classsf_1_1View.html + a57e4a87cf0d724678675d22a0093719a + () const + + + float + getRotation + classsf_1_1View.html + a324d8885f4ab17f1f7b0313580c9b84e + () const + + + const FloatRect & + getViewport + classsf_1_1View.html + aa2006fa4269078be4fd5ca999dcb6244 + () const + + + void + move + classsf_1_1View.html + a0c82144b837caf812f7cb25a43d80c41 + (float offsetX, float offsetY) + + + void + move + classsf_1_1View.html + a4c98a6e04fed756dfaff8f629de50862 + (const Vector2f &offset) + + + void + rotate + classsf_1_1View.html + a5fd3901aae1845586ca40add94faa378 + (float angle) + + + void + zoom + classsf_1_1View.html + a4a72a360a5792fbe4e99cd6feaf7726e + (float factor) + + + const Transform & + getTransform + classsf_1_1View.html + ac9c1dab0cb8c1ac143b031035d821ce5 + () const + + + const Transform & + getInverseTransform + classsf_1_1View.html + aa685c17a56aae7c7df4c90ea6285fd46 + () const + + + + sf::Vulkan + classsf_1_1Vulkan.html + + static bool + isAvailable + classsf_1_1Vulkan.html + a88ddd65cc8732316e3066541084c32a0 + (bool requireGraphics=true) + + + static VulkanFunctionPointer + getFunction + classsf_1_1Vulkan.html + af5b575941e5976af33c6447046e7fefe + (const char *name) + + + static const std::vector< const char * > & + getGraphicsRequiredInstanceExtensions + classsf_1_1Vulkan.html + a295895b452031cf58fadbf3205db6149 + () + + + + sf::Window + classsf_1_1Window.html + sf::WindowBase + sf::GlResource + + + Window + classsf_1_1Window.html + a5359122166b4dc492c3d25caf08ccfc4 + () + + + + Window + classsf_1_1Window.html + a1bee771baecbae6d357871929dc042a2 + (VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings()) + + + + Window + classsf_1_1Window.html + a6d60912633bff9d33cf3ade4e0201de4 + (WindowHandle handle, const ContextSettings &settings=ContextSettings()) + + + virtual + ~Window + classsf_1_1Window.html + ac30eb6ea5f5594204944d09d4bd69a97 + () + + + virtual void + create + classsf_1_1Window.html + ac6a58d9c26a18f0e70888d0f53e154c1 + (VideoMode mode, const String &title, Uint32 style=Style::Default) + + + virtual void + create + classsf_1_1Window.html + a6518b989614750e90d9784f4d05ce02c + (VideoMode mode, const String &title, Uint32 style, const ContextSettings &settings) + + + virtual void + create + classsf_1_1Window.html + a5ee0c5262df6cc4e1a8031ae6848437f + (WindowHandle handle) + + + virtual void + create + classsf_1_1Window.html + a064dd5dd7bb337fb9f5635f580081a1e + (WindowHandle handle, const ContextSettings &settings) + + + virtual void + close + classsf_1_1Window.html + a7355b916852af56cfe3cc00feed9f419 + () + + + const ContextSettings & + getSettings + classsf_1_1Window.html + a0605afbaceb02b098f9d731b7ab4203d + () const + + + void + setVerticalSyncEnabled + classsf_1_1Window.html + a59041c4556e0351048f8aff366034f61 + (bool enabled) + + + void + setFramerateLimit + classsf_1_1Window.html + af4322d315baf93405bf0d5087ad5e784 + (unsigned int limit) + + + bool + setActive + classsf_1_1Window.html + aaab549da64cedf74fa6f1ae7a3cc79e0 + (bool active=true) const + + + void + display + classsf_1_1Window.html + adabf839cb103ac96cfc82f781638772a + () + + + bool + isOpen + classsf_1_1WindowBase.html + aa43559822564ef958dc664a90c57cba0 + () const + + + bool + pollEvent + classsf_1_1WindowBase.html + a6a143de089c8716bd42c38c781268f7f + (Event &event) + + + bool + waitEvent + classsf_1_1WindowBase.html + aa1c100a69b5bc0c84e23a4652d51ac41 + (Event &event) + + + Vector2i + getPosition + classsf_1_1WindowBase.html + a5ddaa5943f547645079f081422e45c81 + () const + + + void + setPosition + classsf_1_1WindowBase.html + ab5b8d500fa5acd3ac2908c9221fe2019 + (const Vector2i &position) + + + Vector2u + getSize + classsf_1_1WindowBase.html + a188a482d916a972d59d6b0700132e379 + () const + + + void + setSize + classsf_1_1WindowBase.html + a7edca32bca3000d2e241dba720034bd6 + (const Vector2u &size) + + + void + setTitle + classsf_1_1WindowBase.html + accd36ae6244ae1e6d643f6c109e983f8 + (const String &title) + + + void + setIcon + classsf_1_1WindowBase.html + add42ae12c13012e6aab74d9e34591719 + (unsigned int width, unsigned int height, const Uint8 *pixels) + + + void + setVisible + classsf_1_1WindowBase.html + a576488ad202cb2cd4359af94eaba4dd8 + (bool visible) + + + void + setMouseCursorVisible + classsf_1_1WindowBase.html + afa4a3372b2870294d1579d8621fe3c1a + (bool visible) + + + void + setMouseCursorGrabbed + classsf_1_1WindowBase.html + a0023344922a1e854175c8ca22b072020 + (bool grabbed) + + + void + setMouseCursor + classsf_1_1WindowBase.html + a07487a3c7e04472b19e96d3a602213ec + (const Cursor &cursor) + + + void + setKeyRepeatEnabled + classsf_1_1WindowBase.html + afd1199a64d459ba531deb65f093050a6 + (bool enabled) + + + void + setJoystickThreshold + classsf_1_1WindowBase.html + ad37f939b492c7ea046d4f7b45ac46df1 + (float threshold) + + + void + requestFocus + classsf_1_1WindowBase.html + a448770d2372d8df0a1ad6b1c7cce3c89 + () + + + bool + hasFocus + classsf_1_1WindowBase.html + ad87bd19e979c426cb819ccde8c95232e + () const + + + WindowHandle + getSystemHandle + classsf_1_1WindowBase.html + af9e56181556545bf6e6d7ed969edae21 + () const + + + bool + createVulkanSurface + classsf_1_1WindowBase.html + a4bcb435cdb954f991f493976263a2fc1 + (const VkInstance &instance, VkSurfaceKHR &surface, const VkAllocationCallbacks *allocator=0) + + + virtual void + onCreate + classsf_1_1WindowBase.html + a3397a7265f654be7ce9ccde3a53a39df + () + + + virtual void + onResize + classsf_1_1WindowBase.html + a8be41815cbeb89bc49e8752b62283192 + () + + + + sf::WindowBase + classsf_1_1WindowBase.html + sf::NonCopyable + + + WindowBase + classsf_1_1WindowBase.html + a0cfe9d015cc95b89ef862c8d8050a964 + () + + + + WindowBase + classsf_1_1WindowBase.html + ab150dbdb19eead86bcecb42cf3609e63 + (VideoMode mode, const String &title, Uint32 style=Style::Default) + + + + WindowBase + classsf_1_1WindowBase.html + ab4e3667dddddfeda57d124de24f93ac1 + (WindowHandle handle) + + + virtual + ~WindowBase + classsf_1_1WindowBase.html + a7aac2a828b6bbd39b7195bb0545a2c47 + () + + + virtual void + create + classsf_1_1WindowBase.html + a3b888387b7bd4be38d6db1234c8d7ad4 + (VideoMode mode, const String &title, Uint32 style=Style::Default) + + + virtual void + create + classsf_1_1WindowBase.html + a4e4968e15e33fd70629983f635bcc21c + (WindowHandle handle) + + + virtual void + close + classsf_1_1WindowBase.html + a9a5ea0ba0ab584dbd11bbfea233b457f + () + + + bool + isOpen + classsf_1_1WindowBase.html + aa43559822564ef958dc664a90c57cba0 + () const + + + bool + pollEvent + classsf_1_1WindowBase.html + a6a143de089c8716bd42c38c781268f7f + (Event &event) + + + bool + waitEvent + classsf_1_1WindowBase.html + aa1c100a69b5bc0c84e23a4652d51ac41 + (Event &event) + + + Vector2i + getPosition + classsf_1_1WindowBase.html + a5ddaa5943f547645079f081422e45c81 + () const + + + void + setPosition + classsf_1_1WindowBase.html + ab5b8d500fa5acd3ac2908c9221fe2019 + (const Vector2i &position) + + + Vector2u + getSize + classsf_1_1WindowBase.html + a188a482d916a972d59d6b0700132e379 + () const + + + void + setSize + classsf_1_1WindowBase.html + a7edca32bca3000d2e241dba720034bd6 + (const Vector2u &size) + + + void + setTitle + classsf_1_1WindowBase.html + accd36ae6244ae1e6d643f6c109e983f8 + (const String &title) + + + void + setIcon + classsf_1_1WindowBase.html + add42ae12c13012e6aab74d9e34591719 + (unsigned int width, unsigned int height, const Uint8 *pixels) + + + void + setVisible + classsf_1_1WindowBase.html + a576488ad202cb2cd4359af94eaba4dd8 + (bool visible) + + + void + setMouseCursorVisible + classsf_1_1WindowBase.html + afa4a3372b2870294d1579d8621fe3c1a + (bool visible) + + + void + setMouseCursorGrabbed + classsf_1_1WindowBase.html + a0023344922a1e854175c8ca22b072020 + (bool grabbed) + + + void + setMouseCursor + classsf_1_1WindowBase.html + a07487a3c7e04472b19e96d3a602213ec + (const Cursor &cursor) + + + void + setKeyRepeatEnabled + classsf_1_1WindowBase.html + afd1199a64d459ba531deb65f093050a6 + (bool enabled) + + + void + setJoystickThreshold + classsf_1_1WindowBase.html + ad37f939b492c7ea046d4f7b45ac46df1 + (float threshold) + + + void + requestFocus + classsf_1_1WindowBase.html + a448770d2372d8df0a1ad6b1c7cce3c89 + () + + + bool + hasFocus + classsf_1_1WindowBase.html + ad87bd19e979c426cb819ccde8c95232e + () const + + + WindowHandle + getSystemHandle + classsf_1_1WindowBase.html + af9e56181556545bf6e6d7ed969edae21 + () const + + + bool + createVulkanSurface + classsf_1_1WindowBase.html + a4bcb435cdb954f991f493976263a2fc1 + (const VkInstance &instance, VkSurfaceKHR &surface, const VkAllocationCallbacks *allocator=0) + + + virtual void + onCreate + classsf_1_1WindowBase.html + a3397a7265f654be7ce9ccde3a53a39df + () + + + virtual void + onResize + classsf_1_1WindowBase.html + a8be41815cbeb89bc49e8752b62283192 + () + + + + sf::Glsl + namespacesf_1_1Glsl.html + + Vector2< float > + Vec2 + namespacesf_1_1Glsl.html + adeed356d346d87634b4c197a530e4edf + + + + Vector2< int > + Ivec2 + namespacesf_1_1Glsl.html + aab803ee70c4b7bfcd63ec09e10408fd3 + + + + Vector2< bool > + Bvec2 + namespacesf_1_1Glsl.html + a59d8cf909c3d71ebf3db057480b464da + + + + Vector3< float > + Vec3 + namespacesf_1_1Glsl.html + a9bdd0463b7cb5316244a082007bd50f0 + + + + Vector3< int > + Ivec3 + namespacesf_1_1Glsl.html + a64f403dd0219e7f128ffddca641394df + + + + Vector3< bool > + Bvec3 + namespacesf_1_1Glsl.html + a4166ffc506619b4912d576e6eba2c957 + + + + implementation defined + Vec4 + namespacesf_1_1Glsl.html + a7c67253548c58adb77cb14f847f18f83 + + + + implementation defined + Ivec4 + namespacesf_1_1Glsl.html + a778682c4f085d2daeb90c724791f3f68 + + + + implementation defined + Bvec4 + namespacesf_1_1Glsl.html + a8b1f0ac369666c48a9eafc9d3f5618e6 + + + + implementation defined + Mat3 + namespacesf_1_1Glsl.html + a9e984ebdc1cebc693a12f01a32b2d28d + + + + implementation defined + Mat4 + namespacesf_1_1Glsl.html + a769de806596348a8e56ed6506c688271 + + + + + audio + Audio module + group__audio.html + sf::AlResource + sf::InputSoundFile + sf::Listener + sf::Music + sf::OutputSoundFile + sf::Sound + sf::SoundBuffer + sf::SoundBufferRecorder + sf::SoundFileFactory + sf::SoundFileReader + sf::SoundFileWriter + sf::SoundRecorder + sf::SoundSource + sf::SoundStream + + + graphics + Graphics module + group__graphics.html + sf::Glsl + sf::BlendMode + sf::CircleShape + sf::Color + sf::ConvexShape + sf::Drawable + sf::Font + sf::Glyph + sf::Image + sf::Rect + sf::RectangleShape + sf::RenderStates + sf::RenderTarget + sf::RenderTexture + sf::RenderWindow + sf::Shader + sf::Shape + sf::Sprite + sf::Text + sf::Texture + sf::Transform + sf::Transformable + sf::Vertex + sf::VertexArray + sf::VertexBuffer + sf::View + + + sf::PrimitiveType + group__graphics.html + ga5ee56ac1339984909610713096283b1b + + + + sf::Points + group__graphics.html + gga5ee56ac1339984909610713096283b1bac7097d3e01778b9318def1f7ac35a785 + + + + sf::Lines + group__graphics.html + gga5ee56ac1339984909610713096283b1ba2bf015eeff9f798dfc3d6d744d669f1e + + + + sf::LineStrip + group__graphics.html + gga5ee56ac1339984909610713096283b1ba14d9eeec2c7c314f239a57bde35949fa + + + + sf::Triangles + group__graphics.html + gga5ee56ac1339984909610713096283b1ba880a7aa72c20b9f9beb7eb64d2434670 + + + + sf::TriangleStrip + group__graphics.html + gga5ee56ac1339984909610713096283b1ba05e55fec6d32c2fc8328f94d07f91184 + + + + sf::TriangleFan + group__graphics.html + gga5ee56ac1339984909610713096283b1ba363f7762b33706c805c6a451ad554f5e + + + + sf::Quads + group__graphics.html + gga5ee56ac1339984909610713096283b1ba5041359b76b4bd3d3e6ef738826b8743 + + + + sf::LinesStrip + group__graphics.html + gga5ee56ac1339984909610713096283b1ba5b09910f5d0f39641342184ccd0d1de3 + + + + sf::TrianglesStrip + group__graphics.html + gga5ee56ac1339984909610713096283b1ba66643dbbb24bbacb405973ed80eebae0 + + + + sf::TrianglesFan + group__graphics.html + gga5ee56ac1339984909610713096283b1ba5338a2c6d922151fe50f235036af8a20 + + + + + network + Network module + group__network.html + sf::Ftp + sf::Http + sf::IpAddress + sf::Packet + sf::Socket + sf::SocketSelector + sf::TcpListener + sf::TcpSocket + sf::UdpSocket + + + system + System module + group__system.html + sf::Clock + sf::FileInputStream + sf::InputStream + sf::Lock + sf::MemoryInputStream + sf::Mutex + sf::NonCopyable + sf::String + sf::Thread + sf::ThreadLocal + sf::ThreadLocalPtr + sf::Time + sf::Utf + sf::Vector2 + sf::Vector3 + + ANativeActivity * + sf::getNativeActivity + group__system.html + ga666414341ce8396227f5a125ee5b7053 + () + + + void + sf::sleep + group__system.html + gab8c0d1f966b4e5110fd370b662d8c11b + (Time duration) + + + std::ostream & + sf::err + group__system.html + ga7fe7f475639e26334606b5142c29551f + () + + + + window + Window module + group__window.html + sf::Clipboard + sf::Context + sf::ContextSettings + sf::Cursor + sf::Event + sf::GlResource + sf::Joystick + sf::Keyboard + sf::Mouse + sf::Sensor + sf::Touch + sf::VideoMode + sf::Vulkan + sf::Window + sf::WindowBase + + platform specific + sf::WindowHandle + group__window.html + gaed947028b0698a812cad2f97bfe9caa3 + + + + sf::Style::None + group__window.html + gga97d7ee508bea4507ab40271518c732ffa8c35a9c8507559e455387fc4a83ce422 + + + + sf::Style::Titlebar + group__window.html + gga97d7ee508bea4507ab40271518c732ffab4c8b32b05ed715928513787cb1e85b6 + + + + sf::Style::Resize + group__window.html + gga97d7ee508bea4507ab40271518c732ffaccff967648ebcd5db2007eff7352b50f + + + + sf::Style::Close + group__window.html + gga97d7ee508bea4507ab40271518c732ffae07a7d411d5acf28f4a9a4b76a3a9493 + + + + sf::Style::Fullscreen + group__window.html + gga97d7ee508bea4507ab40271518c732ffa6288ec86830245cf957e2d234f79f50d + + + + sf::Style::Default + group__window.html + gga97d7ee508bea4507ab40271518c732ffa5597cd420fc461807e4a201c92adea37 + + + + + index + SFML Documentation + index.html + welcome + example + + diff --git a/Space-Invaders/sfml/doc/html/AlResource_8hpp_source.html b/Space-Invaders/sfml/doc/html/AlResource_8hpp_source.html new file mode 100644 index 000000000..1bcdea688 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/AlResource_8hpp_source.html @@ -0,0 +1,152 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
AlResource.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_ALRESOURCE_HPP
+
26#define SFML_ALRESOURCE_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32
+
33
+
34namespace sf
+
35{
+
40class SFML_AUDIO_API AlResource
+
41{
+
42protected:
+
43
+
48 AlResource();
+
49
+
54 ~AlResource();
+
55};
+
56
+
57} // namespace sf
+
58
+
59
+
60#endif // SFML_ALRESOURCE_HPP
+
61
+
sf::AlResource
Base class for classes that require an OpenAL context.
Definition: AlResource.hpp:41
+
sf::AlResource::AlResource
AlResource()
Default constructor.
+
sf::AlResource::~AlResource
~AlResource()
Destructor.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Audio_2Export_8hpp_source.html b/Space-Invaders/sfml/doc/html/Audio_2Export_8hpp_source.html new file mode 100644 index 000000000..b29769153 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Audio_2Export_8hpp_source.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Audio/Export.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_AUDIO_EXPORT_HPP
+
26#define SFML_AUDIO_EXPORT_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32
+
33
+
35// Define portable import / export macros
+
37#if defined(SFML_AUDIO_EXPORTS)
+
38
+
39 #define SFML_AUDIO_API SFML_API_EXPORT
+
40
+
41#else
+
42
+
43 #define SFML_AUDIO_API SFML_API_IMPORT
+
44
+
45#endif
+
46
+
47
+
48#endif // SFML_AUDIO_EXPORT_HPP
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Audio_8hpp_source.html b/Space-Invaders/sfml/doc/html/Audio_8hpp_source.html new file mode 100644 index 000000000..ad7e83bb5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Audio_8hpp_source.html @@ -0,0 +1,149 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Audio.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_AUDIO_HPP
+
26#define SFML_AUDIO_HPP
+
27
+
29// Headers
+
31
+
32#include <SFML/System.hpp>
+
33#include <SFML/Audio/InputSoundFile.hpp>
+
34#include <SFML/Audio/Listener.hpp>
+
35#include <SFML/Audio/Music.hpp>
+
36#include <SFML/Audio/OutputSoundFile.hpp>
+
37#include <SFML/Audio/Sound.hpp>
+
38#include <SFML/Audio/SoundBuffer.hpp>
+
39#include <SFML/Audio/SoundBufferRecorder.hpp>
+
40#include <SFML/Audio/SoundFileFactory.hpp>
+
41#include <SFML/Audio/SoundFileReader.hpp>
+
42#include <SFML/Audio/SoundFileWriter.hpp>
+
43#include <SFML/Audio/SoundRecorder.hpp>
+
44#include <SFML/Audio/SoundSource.hpp>
+
45#include <SFML/Audio/SoundStream.hpp>
+
46
+
47
+
48#endif // SFML_AUDIO_HPP
+
49
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/BlendMode_8hpp_source.html b/Space-Invaders/sfml/doc/html/BlendMode_8hpp_source.html new file mode 100644 index 000000000..3781d6064 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/BlendMode_8hpp_source.html @@ -0,0 +1,221 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
BlendMode.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_BLENDMODE_HPP
+
26#define SFML_BLENDMODE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32
+
33
+
34namespace sf
+
35{
+
36
+
41struct SFML_GRAPHICS_API BlendMode
+
42{
+
49 enum Factor
+
50 {
+
51 Zero,
+
52 One,
+
53 SrcColor,
+
54 OneMinusSrcColor,
+
55 DstColor,
+
56 OneMinusDstColor,
+
57 SrcAlpha,
+
58 OneMinusSrcAlpha,
+
59 DstAlpha,
+
60 OneMinusDstAlpha
+
61 };
+
62
+
69 enum Equation
+
70 {
+
71 Add,
+
72 Subtract,
+
73 ReverseSubtract,
+
74 Min,
+
75 Max
+
76 };
+
77
+
84 BlendMode();
+
85
+
97 BlendMode(Factor sourceFactor, Factor destinationFactor, Equation blendEquation = Add);
+
98
+
110 BlendMode(Factor colorSourceFactor, Factor colorDestinationFactor,
+
111 Equation colorBlendEquation, Factor alphaSourceFactor,
+
112 Factor alphaDestinationFactor, Equation alphaBlendEquation);
+
113
+
115 // Member Data
+
117 Factor colorSrcFactor;
+
118 Factor colorDstFactor;
+
119 Equation colorEquation;
+
120 Factor alphaSrcFactor;
+
121 Factor alphaDstFactor;
+
122 Equation alphaEquation;
+
123};
+
124
+
135SFML_GRAPHICS_API bool operator ==(const BlendMode& left, const BlendMode& right);
+
136
+
147SFML_GRAPHICS_API bool operator !=(const BlendMode& left, const BlendMode& right);
+
148
+
150// Commonly used blending modes
+
152SFML_GRAPHICS_API extern const BlendMode BlendAlpha;
+
153SFML_GRAPHICS_API extern const BlendMode BlendAdd;
+
154SFML_GRAPHICS_API extern const BlendMode BlendMultiply;
+
155SFML_GRAPHICS_API extern const BlendMode BlendMin;
+
156SFML_GRAPHICS_API extern const BlendMode BlendMax;
+
157SFML_GRAPHICS_API extern const BlendMode BlendNone;
+
158
+
159} // namespace sf
+
160
+
161
+
162#endif // SFML_BLENDMODE_HPP
+
163
+
164
+
sf::BlendMode
Blending modes for drawing.
Definition: BlendMode.hpp:42
+
sf::BlendMode::BlendMode
BlendMode(Factor sourceFactor, Factor destinationFactor, Equation blendEquation=Add)
Construct the blend mode given the factors and equation.
+
sf::BlendMode::colorSrcFactor
Factor colorSrcFactor
Source blending factor for the color channels.
Definition: BlendMode.hpp:117
+
sf::BlendMode::alphaEquation
Equation alphaEquation
Blending equation for the alpha channel.
Definition: BlendMode.hpp:122
+
sf::BlendMode::BlendMode
BlendMode(Factor colorSourceFactor, Factor colorDestinationFactor, Equation colorBlendEquation, Factor alphaSourceFactor, Factor alphaDestinationFactor, Equation alphaBlendEquation)
Construct the blend mode given the factors and equation.
+
sf::BlendMode::Equation
Equation
Enumeration of the blending equations.
Definition: BlendMode.hpp:70
+
sf::BlendMode::Subtract
@ Subtract
Pixel = Src * SrcFactor - Dst * DstFactor.
Definition: BlendMode.hpp:72
+
sf::BlendMode::ReverseSubtract
@ ReverseSubtract
Pixel = Dst * DstFactor - Src * SrcFactor.
Definition: BlendMode.hpp:73
+
sf::BlendMode::Add
@ Add
Pixel = Src * SrcFactor + Dst * DstFactor.
Definition: BlendMode.hpp:71
+
sf::BlendMode::Min
@ Min
Pixel = min(Dst, Src)
Definition: BlendMode.hpp:74
+
sf::BlendMode::BlendMode
BlendMode()
Default constructor.
+
sf::BlendMode::alphaSrcFactor
Factor alphaSrcFactor
Source blending factor for the alpha channel.
Definition: BlendMode.hpp:120
+
sf::BlendMode::alphaDstFactor
Factor alphaDstFactor
Destination blending factor for the alpha channel.
Definition: BlendMode.hpp:121
+
sf::BlendMode::colorDstFactor
Factor colorDstFactor
Destination blending factor for the color channels.
Definition: BlendMode.hpp:118
+
sf::BlendMode::colorEquation
Equation colorEquation
Blending equation for the color channels.
Definition: BlendMode.hpp:119
+
sf::BlendMode::Factor
Factor
Enumeration of the blending factors.
Definition: BlendMode.hpp:50
+
sf::BlendMode::DstColor
@ DstColor
(dst.r, dst.g, dst.b, dst.a)
Definition: BlendMode.hpp:55
+
sf::BlendMode::OneMinusSrcColor
@ OneMinusSrcColor
(1, 1, 1, 1) - (src.r, src.g, src.b, src.a)
Definition: BlendMode.hpp:54
+
sf::BlendMode::DstAlpha
@ DstAlpha
(dst.a, dst.a, dst.a, dst.a)
Definition: BlendMode.hpp:59
+
sf::BlendMode::One
@ One
(1, 1, 1, 1)
Definition: BlendMode.hpp:52
+
sf::BlendMode::OneMinusSrcAlpha
@ OneMinusSrcAlpha
(1, 1, 1, 1) - (src.a, src.a, src.a, src.a)
Definition: BlendMode.hpp:58
+
sf::BlendMode::SrcAlpha
@ SrcAlpha
(src.a, src.a, src.a, src.a)
Definition: BlendMode.hpp:57
+
sf::BlendMode::OneMinusDstColor
@ OneMinusDstColor
(1, 1, 1, 1) - (dst.r, dst.g, dst.b, dst.a)
Definition: BlendMode.hpp:56
+
sf::BlendMode::SrcColor
@ SrcColor
(src.r, src.g, src.b, src.a)
Definition: BlendMode.hpp:53
+
sf::BlendMode::Zero
@ Zero
(0, 0, 0, 0)
Definition: BlendMode.hpp:51
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/CircleShape_8hpp_source.html b/Space-Invaders/sfml/doc/html/CircleShape_8hpp_source.html new file mode 100644 index 000000000..de22b62ff --- /dev/null +++ b/Space-Invaders/sfml/doc/html/CircleShape_8hpp_source.html @@ -0,0 +1,174 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
CircleShape.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_CIRCLESHAPE_HPP
+
26#define SFML_CIRCLESHAPE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Shape.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
41class SFML_GRAPHICS_API CircleShape : public Shape
+
42{
+
43public:
+
44
+
52 explicit CircleShape(float radius = 0, std::size_t pointCount = 30);
+
53
+
62 void setRadius(float radius);
+
63
+
72 float getRadius() const;
+
73
+
82 void setPointCount(std::size_t count);
+
83
+
92 virtual std::size_t getPointCount() const;
+
93
+
107 virtual Vector2f getPoint(std::size_t index) const;
+
108
+
109private:
+
110
+
112 // Member data
+
114 float m_radius;
+
115 std::size_t m_pointCount;
+
116};
+
117
+
118} // namespace sf
+
119
+
120
+
121#endif // SFML_CIRCLESHAPE_HPP
+
122
+
123
+
sf::CircleShape
Specialized shape representing a circle.
Definition: CircleShape.hpp:42
+
sf::CircleShape::getPointCount
virtual std::size_t getPointCount() const
Get the number of points of the circle.
+
sf::CircleShape::setPointCount
void setPointCount(std::size_t count)
Set the number of points of the circle.
+
sf::CircleShape::setRadius
void setRadius(float radius)
Set the radius of the circle.
+
sf::CircleShape::getPoint
virtual Vector2f getPoint(std::size_t index) const
Get a point of the circle.
+
sf::CircleShape::getRadius
float getRadius() const
Get the radius of the circle.
+
sf::CircleShape::CircleShape
CircleShape(float radius=0, std::size_t pointCount=30)
Default constructor.
+
sf::Shape
Base class for textured shapes with outline.
Definition: Shape.hpp:45
+ +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Clipboard_8hpp_source.html b/Space-Invaders/sfml/doc/html/Clipboard_8hpp_source.html new file mode 100644 index 000000000..44982c503 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Clipboard_8hpp_source.html @@ -0,0 +1,155 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Clipboard.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_CLIPBOARD_HPP
+
26#define SFML_CLIPBOARD_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32#include <SFML/System/String.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
41class SFML_WINDOW_API Clipboard
+
42{
+
43public:
+
44
+
55 static String getString();
+
56
+
72 static void setString(const String& text);
+
73};
+
74
+
75} // namespace sf
+
76
+
77
+
78#endif // SFML_CLIPBOARD_HPP
+
79
+
80
+
sf::Clipboard
Give access to the system clipboard.
Definition: Clipboard.hpp:42
+
sf::Clipboard::setString
static void setString(const String &text)
Set the content of the clipboard as string data.
+
sf::Clipboard::getString
static String getString()
Get the content of the clipboard as string data.
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Clock_8hpp_source.html b/Space-Invaders/sfml/doc/html/Clock_8hpp_source.html new file mode 100644 index 000000000..cfda91355 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Clock_8hpp_source.html @@ -0,0 +1,163 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Clock.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_CLOCK_HPP
+
26#define SFML_CLOCK_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Export.hpp>
+
32#include <SFML/System/Time.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
41class SFML_SYSTEM_API Clock
+
42{
+
43public:
+
44
+
51 Clock();
+
52
+
63 Time getElapsedTime() const;
+
64
+
74 Time restart();
+
75
+
76private:
+
77
+
79 // Member data
+
81 Time m_startTime;
+
82};
+
83
+
84} // namespace sf
+
85
+
86
+
87#endif // SFML_CLOCK_HPP
+
88
+
89
+
sf::Clock
Utility class that measures the elapsed time.
Definition: Clock.hpp:42
+
sf::Clock::restart
Time restart()
Restart the clock.
+
sf::Clock::Clock
Clock()
Default constructor.
+
sf::Clock::getElapsedTime
Time getElapsedTime() const
Get the elapsed time.
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Color_8hpp_source.html b/Space-Invaders/sfml/doc/html/Color_8hpp_source.html new file mode 100644 index 000000000..4e3bbae26 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Color_8hpp_source.html @@ -0,0 +1,205 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Color.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_COLOR_HPP
+
26#define SFML_COLOR_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32
+
33
+
34namespace sf
+
35{
+
40class SFML_GRAPHICS_API Color
+
41{
+
42public:
+
43
+
51 Color();
+
52
+
62 Color(Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha = 255);
+
63
+
70 explicit Color(Uint32 color);
+
71
+
78 Uint32 toInteger() const;
+
79
+
81 // Static member data
+
83 static const Color Black;
+
84 static const Color White;
+
85 static const Color Red;
+
86 static const Color Green;
+
87 static const Color Blue;
+
88 static const Color Yellow;
+
89 static const Color Magenta;
+
90 static const Color Cyan;
+
91 static const Color Transparent;
+
92
+
94 // Member data
+
96 Uint8 r;
+
97 Uint8 g;
+
98 Uint8 b;
+
99 Uint8 a;
+
100};
+
101
+
114SFML_GRAPHICS_API bool operator ==(const Color& left, const Color& right);
+
115
+
128SFML_GRAPHICS_API bool operator !=(const Color& left, const Color& right);
+
129
+
143SFML_GRAPHICS_API Color operator +(const Color& left, const Color& right);
+
144
+
158SFML_GRAPHICS_API Color operator -(const Color& left, const Color& right);
+
159
+
175SFML_GRAPHICS_API Color operator *(const Color& left, const Color& right);
+
176
+
191SFML_GRAPHICS_API Color& operator +=(Color& left, const Color& right);
+
192
+
207SFML_GRAPHICS_API Color& operator -=(Color& left, const Color& right);
+
208
+
225SFML_GRAPHICS_API Color& operator *=(Color& left, const Color& right);
+
226
+
227} // namespace sf
+
228
+
229
+
230#endif // SFML_COLOR_HPP
+
231
+
232
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+
sf::Color::Red
static const Color Red
Red predefined color.
Definition: Color.hpp:85
+
sf::Color::White
static const Color White
White predefined color.
Definition: Color.hpp:84
+
sf::Color::Color
Color(Uint32 color)
Construct the color from 32-bit unsigned integer.
+
sf::Color::Transparent
static const Color Transparent
Transparent (black) predefined color.
Definition: Color.hpp:91
+
sf::Color::a
Uint8 a
Alpha (opacity) component.
Definition: Color.hpp:99
+
sf::Color::g
Uint8 g
Green component.
Definition: Color.hpp:97
+
sf::Color::Cyan
static const Color Cyan
Cyan predefined color.
Definition: Color.hpp:90
+
sf::Color::b
Uint8 b
Blue component.
Definition: Color.hpp:98
+
sf::Color::r
Uint8 r
Red component.
Definition: Color.hpp:96
+
sf::Color::Magenta
static const Color Magenta
Magenta predefined color.
Definition: Color.hpp:89
+
sf::Color::Black
static const Color Black
Black predefined color.
Definition: Color.hpp:83
+
sf::Color::Green
static const Color Green
Green predefined color.
Definition: Color.hpp:86
+
sf::Color::Blue
static const Color Blue
Blue predefined color.
Definition: Color.hpp:87
+
sf::Color::toInteger
Uint32 toInteger() const
Retrieve the color as a 32-bit unsigned integer.
+
sf::Color::Color
Color()
Default constructor.
+
sf::Color::Color
Color(Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha=255)
Construct the color from its 4 RGBA components.
+
sf::Color::Yellow
static const Color Yellow
Yellow predefined color.
Definition: Color.hpp:88
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Config_8hpp_source.html b/Space-Invaders/sfml/doc/html/Config_8hpp_source.html new file mode 100644 index 000000000..9b031f506 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Config_8hpp_source.html @@ -0,0 +1,338 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Config.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_CONFIG_HPP
+
26#define SFML_CONFIG_HPP
+
27
+
28
+
30// Define the SFML version
+
32#define SFML_VERSION_MAJOR 2
+
33#define SFML_VERSION_MINOR 6
+
34#define SFML_VERSION_PATCH 1
+
35
+
36
+
38// Identify the operating system
+
39// see https://sourceforge.net/p/predef/wiki/Home/
+
41#if defined(_WIN32)
+
42
+
43 // Windows
+
44 #define SFML_SYSTEM_WINDOWS
+
45 #ifndef NOMINMAX
+
46 #define NOMINMAX
+
47 #endif
+
48
+
49#elif defined(__APPLE__) && defined(__MACH__)
+
50
+
51 // Apple platform, see which one it is
+
52 #include "TargetConditionals.h"
+
53
+
54 #if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
+
55
+
56 // iOS
+
57 #define SFML_SYSTEM_IOS
+
58
+
59 #elif TARGET_OS_MAC
+
60
+
61 // MacOS
+
62 #define SFML_SYSTEM_MACOS
+
63
+
64 #else
+
65
+
66 // Unsupported Apple system
+
67 #error This Apple operating system is not supported by SFML library
+
68
+
69 #endif
+
70
+
71#elif defined(__unix__)
+
72
+
73 // UNIX system, see which one it is
+
74 #if defined(__ANDROID__)
+
75
+
76 // Android
+
77 #define SFML_SYSTEM_ANDROID
+
78
+
79 #elif defined(__linux__)
+
80
+
81 // Linux
+
82 #define SFML_SYSTEM_LINUX
+
83
+
84 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+
85
+
86 // FreeBSD
+
87 #define SFML_SYSTEM_FREEBSD
+
88
+
89 #elif defined(__OpenBSD__)
+
90
+
91 // OpenBSD
+
92 #define SFML_SYSTEM_OPENBSD
+
93
+
94 #elif defined(__NetBSD__)
+
95
+
96 // NetBSD
+
97 #define SFML_SYSTEM_NETBSD
+
98
+
99 #else
+
100
+
101 // Unsupported UNIX system
+
102 #error This UNIX operating system is not supported by SFML library
+
103
+
104 #endif
+
105
+
106#else
+
107
+
108 // Unsupported system
+
109 #error This operating system is not supported by SFML library
+
110
+
111#endif
+
112
+
113
+
115// Define a portable debug macro
+
117#if !defined(NDEBUG)
+
118
+
119 #define SFML_DEBUG
+
120
+
121#endif
+
122
+
123
+
125// Define helpers to create portable import / export macros for each module
+
127#if !defined(SFML_STATIC)
+
128
+
129 #if defined(SFML_SYSTEM_WINDOWS)
+
130
+
131 // Windows compilers need specific (and different) keywords for export and import
+
132 #define SFML_API_EXPORT __declspec(dllexport)
+
133 #define SFML_API_IMPORT __declspec(dllimport)
+
134
+
135 // For Visual C++ compilers, we also need to turn off this annoying C4251 warning
+
136 #ifdef _MSC_VER
+
137
+
138 #pragma warning(disable: 4251)
+
139
+
140 #endif
+
141
+
142 #else // Linux, FreeBSD, Mac OS X
+
143
+
144 #if __GNUC__ >= 4
+
145
+
146 // GCC 4 has special keywords for showing/hidding symbols,
+
147 // the same keyword is used for both importing and exporting
+
148 #define SFML_API_EXPORT __attribute__ ((__visibility__ ("default")))
+
149 #define SFML_API_IMPORT __attribute__ ((__visibility__ ("default")))
+
150
+
151 #else
+
152
+
153 // GCC < 4 has no mechanism to explicitely hide symbols, everything's exported
+
154 #define SFML_API_EXPORT
+
155 #define SFML_API_IMPORT
+
156
+
157 #endif
+
158
+
159 #endif
+
160
+
161#else
+
162
+
163 // Static build doesn't need import/export macros
+
164 #define SFML_API_EXPORT
+
165 #define SFML_API_IMPORT
+
166
+
167#endif
+
168
+
169
+
171// Cross-platform warning for deprecated functions and classes
+
172//
+
173// Usage:
+
174// class SFML_DEPRECATED MyClass
+
175// {
+
176// SFML_DEPRECATED void memberFunc();
+
177// };
+
178//
+
179// SFML_DEPRECATED void globalFunc();
+
181#if defined(SFML_NO_DEPRECATED_WARNINGS)
+
182
+
183 // User explicitly requests to disable deprecation warnings
+
184 #define SFML_DEPRECATED
+
185
+
186#elif defined(_MSC_VER)
+
187
+
188 // Microsoft C++ compiler
+
189 // Note: On newer MSVC versions, using deprecated functions causes a compiler error. In order to
+
190 // trigger a warning instead of an error, the compiler flag /sdl- (instead of /sdl) must be specified.
+
191 #define SFML_DEPRECATED __declspec(deprecated)
+
192
+
193#elif defined(__GNUC__)
+
194
+
195 // g++ and Clang
+
196 #define SFML_DEPRECATED __attribute__ ((deprecated))
+
197
+
198#else
+
199
+
200 // Other compilers are not supported, leave class or function as-is.
+
201 // With a bit of luck, the #pragma directive works, otherwise users get a warning (no error!) for unrecognized #pragma.
+
202 #pragma message("SFML_DEPRECATED is not supported for your compiler, please contact the SFML team")
+
203 #define SFML_DEPRECATED
+
204
+
205#endif
+
206
+
207
+
209// Define portable fixed-size types
+
211namespace sf
+
212{
+
213 // All "common" platforms use the same size for char, short and int
+
214 // (basically there are 3 types for 3 sizes, so no other match is possible),
+
215 // we can use them without doing any kind of check
+
216
+
217 // 8 bits integer types
+
218 typedef signed char Int8;
+
219 typedef unsigned char Uint8;
+
220
+
221 // 16 bits integer types
+
222 typedef signed short Int16;
+
223 typedef unsigned short Uint16;
+
224
+
225 // 32 bits integer types
+
226 typedef signed int Int32;
+
227 typedef unsigned int Uint32;
+
228
+
229 // 64 bits integer types
+
230 #if defined(_MSC_VER)
+
231 typedef signed __int64 Int64;
+
232 typedef unsigned __int64 Uint64;
+
233 #else
+
234 #if defined(__clang__)
+
235 #pragma clang diagnostic push
+
236 #pragma clang diagnostic ignored "-Wc++11-long-long"
+
237 #endif
+
238 typedef signed long long Int64;
+
239 typedef unsigned long long Uint64;
+
240 #if defined(__clang__)
+
241 #pragma clang diagnostic pop
+
242 #endif
+
243 #endif
+
244
+
245} // namespace sf
+
246
+
247
+
248#endif // SFML_CONFIG_HPP
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/ContextSettings_8hpp_source.html b/Space-Invaders/sfml/doc/html/ContextSettings_8hpp_source.html new file mode 100644 index 000000000..28671b273 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/ContextSettings_8hpp_source.html @@ -0,0 +1,182 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
ContextSettings.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_CONTEXTSETTINGS_HPP
+
26#define SFML_CONTEXTSETTINGS_HPP
+
27
+
28#include <SFML/Config.hpp>
+
29
+
30namespace sf
+
31{
+
37struct ContextSettings
+
38{
+
43 enum Attribute
+
44 {
+
45 Default = 0,
+
46 Core = 1 << 0,
+
47 Debug = 1 << 2
+
48 };
+
49
+
62 explicit ContextSettings(unsigned int depth = 0, unsigned int stencil = 0, unsigned int antialiasing = 0, unsigned int major = 1, unsigned int minor = 1, unsigned int attributes = Default, bool sRgb = false) :
+
63 depthBits (depth),
+
64 stencilBits (stencil),
+
65 antialiasingLevel(antialiasing),
+
66 majorVersion (major),
+
67 minorVersion (minor),
+
68 attributeFlags (attributes),
+
69 sRgbCapable (sRgb)
+
70 {
+
71 }
+
72
+
74 // Member data
+
76 unsigned int depthBits;
+
77 unsigned int stencilBits;
+
78 unsigned int antialiasingLevel;
+
79 unsigned int majorVersion;
+
80 unsigned int minorVersion;
+
81 Uint32 attributeFlags;
+
82 bool sRgbCapable;
+
83};
+
84
+
85} // namespace sf
+
86
+
87
+
88#endif // SFML_CONTEXTSETTINGS_HPP
+
89
+
90
+
sf::ContextSettings
Structure defining the settings of the OpenGL context attached to a window.
Definition: ContextSettings.hpp:38
+
sf::ContextSettings::attributeFlags
Uint32 attributeFlags
The attribute flags to create the context with.
Definition: ContextSettings.hpp:81
+
sf::ContextSettings::depthBits
unsigned int depthBits
Bits of the depth buffer.
Definition: ContextSettings.hpp:76
+
sf::ContextSettings::majorVersion
unsigned int majorVersion
Major number of the context version to create.
Definition: ContextSettings.hpp:79
+
sf::ContextSettings::minorVersion
unsigned int minorVersion
Minor number of the context version to create.
Definition: ContextSettings.hpp:80
+
sf::ContextSettings::stencilBits
unsigned int stencilBits
Bits of the stencil buffer.
Definition: ContextSettings.hpp:77
+
sf::ContextSettings::antialiasingLevel
unsigned int antialiasingLevel
Level of antialiasing.
Definition: ContextSettings.hpp:78
+
sf::ContextSettings::ContextSettings
ContextSettings(unsigned int depth=0, unsigned int stencil=0, unsigned int antialiasing=0, unsigned int major=1, unsigned int minor=1, unsigned int attributes=Default, bool sRgb=false)
Default constructor.
Definition: ContextSettings.hpp:62
+
sf::ContextSettings::sRgbCapable
bool sRgbCapable
Whether the context framebuffer is sRGB capable.
Definition: ContextSettings.hpp:82
+
sf::ContextSettings::Attribute
Attribute
Enumeration of the context attribute flags.
Definition: ContextSettings.hpp:44
+
sf::ContextSettings::Debug
@ Debug
Debug attribute.
Definition: ContextSettings.hpp:47
+
sf::ContextSettings::Default
@ Default
Non-debug, compatibility context (this and the core attribute are mutually exclusive)
Definition: ContextSettings.hpp:45
+
sf::ContextSettings::Core
@ Core
Core attribute.
Definition: ContextSettings.hpp:46
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Context_8hpp_source.html b/Space-Invaders/sfml/doc/html/Context_8hpp_source.html new file mode 100644 index 000000000..c74b6d438 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Context_8hpp_source.html @@ -0,0 +1,191 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Context.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_CONTEXT_HPP
+
26#define SFML_CONTEXT_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32#include <SFML/Window/GlResource.hpp>
+
33#include <SFML/Window/ContextSettings.hpp>
+
34#include <SFML/System/NonCopyable.hpp>
+
35
+
36
+
37namespace sf
+
38{
+
39namespace priv
+
40{
+
41 class GlContext;
+
42}
+
43
+
44typedef void (*GlFunctionPointer)();
+
45
+
50class SFML_WINDOW_API Context : GlResource, NonCopyable
+
51{
+
52public:
+
53
+
60 Context();
+
61
+
68 ~Context();
+
69
+
78 bool setActive(bool active);
+
79
+
90 const ContextSettings& getSettings() const;
+
91
+
100 static bool isExtensionAvailable(const char* name);
+
101
+
110 static GlFunctionPointer getFunction(const char* name);
+
111
+
122 static const Context* getActiveContext();
+
123
+
133 static Uint64 getActiveContextId();
+
134
+
146 Context(const ContextSettings& settings, unsigned int width, unsigned int height);
+
147
+
148private:
+
149
+
151 // Member data
+
153 priv::GlContext* m_context;
+
154};
+
155
+
156} // namespace sf
+
157
+
158
+
159#endif // SFML_CONTEXT_HPP
+
160
+
sf::Context
Class holding a valid drawing context.
Definition: Context.hpp:51
+
sf::Context::setActive
bool setActive(bool active)
Activate or deactivate explicitly the context.
+
sf::Context::isExtensionAvailable
static bool isExtensionAvailable(const char *name)
Check whether a given OpenGL extension is available.
+
sf::Context::Context
Context(const ContextSettings &settings, unsigned int width, unsigned int height)
Construct a in-memory context.
+
sf::Context::getActiveContext
static const Context * getActiveContext()
Get the currently active context.
+
sf::Context::getSettings
const ContextSettings & getSettings() const
Get the settings of the context.
+
sf::Context::getActiveContextId
static Uint64 getActiveContextId()
Get the currently active context's ID.
+
sf::Context::~Context
~Context()
Destructor.
+
sf::Context::getFunction
static GlFunctionPointer getFunction(const char *name)
Get the address of an OpenGL function.
+
sf::Context::Context
Context()
Default constructor.
+
sf::GlResource
Base class for classes that require an OpenGL context.
Definition: GlResource.hpp:47
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::ContextSettings
Structure defining the settings of the OpenGL context attached to a window.
Definition: ContextSettings.hpp:38
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/ConvexShape_8hpp_source.html b/Space-Invaders/sfml/doc/html/ConvexShape_8hpp_source.html new file mode 100644 index 000000000..5a736f834 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/ConvexShape_8hpp_source.html @@ -0,0 +1,171 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
ConvexShape.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_CONVEXSHAPE_HPP
+
26#define SFML_CONVEXSHAPE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Shape.hpp>
+
33#include <vector>
+
34
+
35
+
36namespace sf
+
37{
+
42class SFML_GRAPHICS_API ConvexShape : public Shape
+
43{
+
44public:
+
45
+
52 explicit ConvexShape(std::size_t pointCount = 0);
+
53
+
64 void setPointCount(std::size_t count);
+
65
+
74 virtual std::size_t getPointCount() const;
+
75
+
91 void setPoint(std::size_t index, const Vector2f& point);
+
92
+
108 virtual Vector2f getPoint(std::size_t index) const;
+
109
+
110private:
+
111
+
113 // Member data
+
115 std::vector<Vector2f> m_points;
+
116};
+
117
+
118} // namespace sf
+
119
+
120
+
121#endif // SFML_CONVEXSHAPE_HPP
+
122
+
123
+
sf::ConvexShape
Specialized shape representing a convex polygon.
Definition: ConvexShape.hpp:43
+
sf::ConvexShape::getPointCount
virtual std::size_t getPointCount() const
Get the number of points of the polygon.
+
sf::ConvexShape::setPointCount
void setPointCount(std::size_t count)
Set the number of points of the polygon.
+
sf::ConvexShape::setPoint
void setPoint(std::size_t index, const Vector2f &point)
Set the position of a point.
+
sf::ConvexShape::getPoint
virtual Vector2f getPoint(std::size_t index) const
Get the position of a point.
+
sf::ConvexShape::ConvexShape
ConvexShape(std::size_t pointCount=0)
Default constructor.
+
sf::Shape
Base class for textured shapes with outline.
Definition: Shape.hpp:45
+ +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Cursor_8hpp_source.html b/Space-Invaders/sfml/doc/html/Cursor_8hpp_source.html new file mode 100644 index 000000000..b8335785d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Cursor_8hpp_source.html @@ -0,0 +1,227 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Cursor.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_CURSOR_HPP
+
26#define SFML_CURSOR_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32#include <SFML/System/NonCopyable.hpp>
+
33#include <SFML/System/Vector2.hpp>
+
34
+
35namespace sf
+
36{
+
37namespace priv
+
38{
+
39 class CursorImpl;
+
40}
+
41
+
46class SFML_WINDOW_API Cursor : NonCopyable
+
47{
+
48public:
+
49
+
86 enum Type
+
87 {
+
88 Arrow,
+
89 ArrowWait,
+
90 Wait,
+
91 Text,
+
92 Hand,
+
93 SizeHorizontal,
+
94 SizeVertical,
+
95 SizeTopLeftBottomRight,
+
96 SizeBottomLeftTopRight,
+
97 SizeLeft,
+
98 SizeRight,
+
99 SizeTop,
+
100 SizeBottom,
+
101 SizeTopLeft,
+
102 SizeBottomRight,
+
103 SizeBottomLeft,
+
104 SizeTopRight,
+
105 SizeAll,
+
106 Cross,
+
107 Help,
+
108 NotAllowed
+
109 };
+
110
+
111public:
+
112
+
122 Cursor();
+
123
+
131 ~Cursor();
+
132
+
163 bool loadFromPixels(const Uint8* pixels, Vector2u size, Vector2u hotspot);
+
164
+
179 bool loadFromSystem(Type type);
+
180
+
181private:
+
182
+
183 friend class WindowBase;
+
184
+
194 const priv::CursorImpl& getImpl() const;
+
195
+
196private:
+
197
+
199 // Member data
+
201 priv::CursorImpl* m_impl;
+
202};
+
203
+
204} // namespace sf
+
205
+
206
+
207#endif // SFML_CURSOR_HPP
+
208
+
209
+
sf::Cursor
Cursor defines the appearance of a system cursor.
Definition: Cursor.hpp:47
+
sf::Cursor::Cursor
Cursor()
Default constructor.
+
sf::Cursor::~Cursor
~Cursor()
Destructor.
+
sf::Cursor::Type
Type
Enumeration of the native system cursor types.
Definition: Cursor.hpp:87
+
sf::Cursor::SizeHorizontal
@ SizeHorizontal
Horizontal double arrow cursor.
Definition: Cursor.hpp:93
+
sf::Cursor::ArrowWait
@ ArrowWait
Busy arrow cursor.
Definition: Cursor.hpp:89
+
sf::Cursor::Text
@ Text
I-beam, cursor when hovering over a field allowing text entry.
Definition: Cursor.hpp:91
+
sf::Cursor::SizeAll
@ SizeAll
Combination of SizeHorizontal and SizeVertical.
Definition: Cursor.hpp:105
+
sf::Cursor::SizeTopLeft
@ SizeTopLeft
Top-left arrow cursor on Linux, same as SizeTopLeftBottomRight on other platforms.
Definition: Cursor.hpp:101
+
sf::Cursor::SizeLeft
@ SizeLeft
Left arrow cursor on Linux, same as SizeHorizontal on other platforms.
Definition: Cursor.hpp:97
+
sf::Cursor::SizeBottomRight
@ SizeBottomRight
Bottom-right arrow cursor on Linux, same as SizeTopLeftBottomRight on other platforms.
Definition: Cursor.hpp:102
+
sf::Cursor::SizeTop
@ SizeTop
Up arrow cursor on Linux, same as SizeVertical on other platforms.
Definition: Cursor.hpp:99
+
sf::Cursor::SizeBottomLeft
@ SizeBottomLeft
Bottom-left arrow cursor on Linux, same as SizeBottomLeftTopRight on other platforms.
Definition: Cursor.hpp:103
+
sf::Cursor::SizeTopRight
@ SizeTopRight
Top-right arrow cursor on Linux, same as SizeBottomLeftTopRight on other platforms.
Definition: Cursor.hpp:104
+
sf::Cursor::Arrow
@ Arrow
Arrow cursor (default)
Definition: Cursor.hpp:88
+
sf::Cursor::SizeTopLeftBottomRight
@ SizeTopLeftBottomRight
Double arrow cursor going from top-left to bottom-right.
Definition: Cursor.hpp:95
+
sf::Cursor::SizeBottom
@ SizeBottom
Down arrow cursor on Linux, same as SizeVertical on other platforms.
Definition: Cursor.hpp:100
+
sf::Cursor::SizeVertical
@ SizeVertical
Vertical double arrow cursor.
Definition: Cursor.hpp:94
+
sf::Cursor::Wait
@ Wait
Busy cursor.
Definition: Cursor.hpp:90
+
sf::Cursor::SizeBottomLeftTopRight
@ SizeBottomLeftTopRight
Double arrow cursor going from bottom-left to top-right.
Definition: Cursor.hpp:96
+
sf::Cursor::Hand
@ Hand
Pointing hand cursor.
Definition: Cursor.hpp:92
+
sf::Cursor::SizeRight
@ SizeRight
Right arrow cursor on Linux, same as SizeHorizontal on other platforms.
Definition: Cursor.hpp:98
+
sf::Cursor::Help
@ Help
Help cursor.
Definition: Cursor.hpp:107
+
sf::Cursor::Cross
@ Cross
Crosshair cursor.
Definition: Cursor.hpp:106
+
sf::Cursor::loadFromPixels
bool loadFromPixels(const Uint8 *pixels, Vector2u size, Vector2u hotspot)
Create a cursor with the provided image.
+
sf::Cursor::loadFromSystem
bool loadFromSystem(Type type)
Create a native system cursor.
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+ +
sf::WindowBase
Window that serves as a base for other windows.
Definition: WindowBase.hpp:57
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Drawable_8hpp_source.html b/Space-Invaders/sfml/doc/html/Drawable_8hpp_source.html new file mode 100644 index 000000000..17f518fee --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Drawable_8hpp_source.html @@ -0,0 +1,162 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Drawable.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_DRAWABLE_HPP
+
26#define SFML_DRAWABLE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/RenderStates.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
37class RenderTarget;
+
38
+
44class SFML_GRAPHICS_API Drawable
+
45{
+
46public:
+
47
+
52 virtual ~Drawable() {}
+
53
+
54protected:
+
55
+
56 friend class RenderTarget;
+
57
+
69 virtual void draw(RenderTarget& target, RenderStates states) const = 0;
+
70};
+
71
+
72} // namespace sf
+
73
+
74
+
75#endif // SFML_DRAWABLE_HPP
+
76
+
77
+
sf::Drawable
Abstract base class for objects that can be drawn to a render target.
Definition: Drawable.hpp:45
+
sf::Drawable::~Drawable
virtual ~Drawable()
Virtual destructor.
Definition: Drawable.hpp:52
+
sf::Drawable::draw
virtual void draw(RenderTarget &target, RenderStates states) const =0
Draw the object to a render target.
+
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Err_8hpp_source.html b/Space-Invaders/sfml/doc/html/Err_8hpp_source.html new file mode 100644 index 000000000..51fb8e3a9 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Err_8hpp_source.html @@ -0,0 +1,145 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Err.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_ERR_HPP
+
26#define SFML_ERR_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Export.hpp>
+
32#include <ostream>
+
33
+
34
+
35namespace sf
+
36{
+
41SFML_SYSTEM_API std::ostream& err();
+
42
+
43} // namespace sf
+
44
+
45
+
46#endif // SFML_ERR_HPP
+
47
+
48
+
sf::err
std::ostream & err()
Standard stream used by SFML to output warnings and errors.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Event_8hpp_source.html b/Space-Invaders/sfml/doc/html/Event_8hpp_source.html new file mode 100644 index 000000000..5d839580d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Event_8hpp_source.html @@ -0,0 +1,371 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Event.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_EVENT_HPP
+
26#define SFML_EVENT_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32#include <SFML/Window/Joystick.hpp>
+
33#include <SFML/Window/Keyboard.hpp>
+
34#include <SFML/Window/Mouse.hpp>
+
35#include <SFML/Window/Sensor.hpp>
+
36
+
37
+
38namespace sf
+
39{
+
44class Event
+
45{
+
46public:
+
47
+
52 struct SizeEvent
+
53 {
+
54 unsigned int width;
+
55 unsigned int height;
+
56 };
+
57
+
62 struct KeyEvent
+
63 {
+
64 Keyboard::Key code;
+
65 Keyboard::Scancode scancode;
+
66 bool alt;
+
67 bool control;
+
68 bool shift;
+
69 bool system;
+
70 };
+
71
+
76 struct TextEvent
+
77 {
+
78 Uint32 unicode;
+
79 };
+
80
+
85 struct MouseMoveEvent
+
86 {
+
87 int x;
+
88 int y;
+
89 };
+
90
+
96 struct MouseButtonEvent
+
97 {
+
98 Mouse::Button button;
+
99 int x;
+
100 int y;
+
101 };
+
102
+
110 struct MouseWheelEvent
+
111 {
+
112 int delta;
+
113 int x;
+
114 int y;
+
115 };
+
116
+
121 struct MouseWheelScrollEvent
+
122 {
+
123 Mouse::Wheel wheel;
+
124 float delta;
+
125 int x;
+
126 int y;
+
127 };
+
128
+
134 struct JoystickConnectEvent
+
135 {
+
136 unsigned int joystickId;
+
137 };
+
138
+
143 struct JoystickMoveEvent
+
144 {
+
145 unsigned int joystickId;
+
146 Joystick::Axis axis;
+
147 float position;
+
148 };
+
149
+
155 struct JoystickButtonEvent
+
156 {
+
157 unsigned int joystickId;
+
158 unsigned int button;
+
159 };
+
160
+
165 struct TouchEvent
+
166 {
+
167 unsigned int finger;
+
168 int x;
+
169 int y;
+
170 };
+
171
+
176 struct SensorEvent
+
177 {
+
178 Sensor::Type type;
+
179 float x;
+
180 float y;
+
181 float z;
+
182 };
+
183
+
188 enum EventType
+
189 {
+
190 Closed,
+
191 Resized,
+
192 LostFocus,
+
193 GainedFocus,
+
194 TextEntered,
+
195 KeyPressed,
+
196 KeyReleased,
+
197 MouseWheelMoved,
+
198 MouseWheelScrolled,
+
199 MouseButtonPressed,
+
200 MouseButtonReleased,
+
201 MouseMoved,
+
202 MouseEntered,
+
203 MouseLeft,
+
204 JoystickButtonPressed,
+
205 JoystickButtonReleased,
+
206 JoystickMoved,
+
207 JoystickConnected,
+
208 JoystickDisconnected,
+
209 TouchBegan,
+
210 TouchMoved,
+
211 TouchEnded,
+
212 SensorChanged,
+
213
+
214 Count
+
215 };
+
216
+
218 // Member data
+
220 EventType type;
+
221
+
222 union
+
223 {
+
224 SizeEvent size;
+
225 KeyEvent key;
+
226 TextEvent text;
+
227 MouseMoveEvent mouseMove;
+
228 MouseButtonEvent mouseButton;
+
229 MouseWheelEvent mouseWheel;
+
230 MouseWheelScrollEvent mouseWheelScroll;
+
231 JoystickMoveEvent joystickMove;
+
232 JoystickButtonEvent joystickButton;
+
233 JoystickConnectEvent joystickConnect;
+
234 TouchEvent touch;
+
235 SensorEvent sensor;
+
236 };
+
237};
+
238
+
239} // namespace sf
+
240
+
241
+
242#endif // SFML_EVENT_HPP
+
243
+
244
+
sf::Event
Defines a system event and its parameters.
Definition: Event.hpp:45
+
sf::Event::text
TextEvent text
Text event parameters (Event::TextEntered)
Definition: Event.hpp:226
+
sf::Event::mouseButton
MouseButtonEvent mouseButton
Mouse button event parameters (Event::MouseButtonPressed, Event::MouseButtonReleased)
Definition: Event.hpp:228
+
sf::Event::joystickButton
JoystickButtonEvent joystickButton
Joystick button event parameters (Event::JoystickButtonPressed, Event::JoystickButtonReleased)
Definition: Event.hpp:232
+
sf::Event::key
KeyEvent key
Key event parameters (Event::KeyPressed, Event::KeyReleased)
Definition: Event.hpp:225
+
sf::Event::touch
TouchEvent touch
Touch events parameters (Event::TouchBegan, Event::TouchMoved, Event::TouchEnded)
Definition: Event.hpp:234
+
sf::Event::mouseWheelScroll
MouseWheelScrollEvent mouseWheelScroll
Mouse wheel event parameters (Event::MouseWheelScrolled)
Definition: Event.hpp:230
+
sf::Event::mouseMove
MouseMoveEvent mouseMove
Mouse move event parameters (Event::MouseMoved)
Definition: Event.hpp:227
+
sf::Event::size
SizeEvent size
Size event parameters (Event::Resized)
Definition: Event.hpp:224
+
sf::Event::mouseWheel
MouseWheelEvent mouseWheel
Mouse wheel event parameters (Event::MouseWheelMoved) (deprecated)
Definition: Event.hpp:229
+
sf::Event::joystickConnect
JoystickConnectEvent joystickConnect
Joystick (dis)connect event parameters (Event::JoystickConnected, Event::JoystickDisconnected)
Definition: Event.hpp:233
+
sf::Event::joystickMove
JoystickMoveEvent joystickMove
Joystick move event parameters (Event::JoystickMoved)
Definition: Event.hpp:231
+
sf::Event::sensor
SensorEvent sensor
Sensor event parameters (Event::SensorChanged)
Definition: Event.hpp:235
+
sf::Event::type
EventType type
Type of the event.
Definition: Event.hpp:220
+
sf::Event::EventType
EventType
Enumeration of the different types of events.
Definition: Event.hpp:189
+
sf::Event::JoystickButtonReleased
@ JoystickButtonReleased
A joystick button was released (data in event.joystickButton)
Definition: Event.hpp:205
+
sf::Event::MouseWheelScrolled
@ MouseWheelScrolled
The mouse wheel was scrolled (data in event.mouseWheelScroll)
Definition: Event.hpp:198
+
sf::Event::Closed
@ Closed
The window requested to be closed (no data)
Definition: Event.hpp:190
+
sf::Event::JoystickMoved
@ JoystickMoved
The joystick moved along an axis (data in event.joystickMove)
Definition: Event.hpp:206
+
sf::Event::MouseMoved
@ MouseMoved
The mouse cursor moved (data in event.mouseMove)
Definition: Event.hpp:201
+
sf::Event::MouseEntered
@ MouseEntered
The mouse cursor entered the area of the window (no data)
Definition: Event.hpp:202
+
sf::Event::MouseButtonPressed
@ MouseButtonPressed
A mouse button was pressed (data in event.mouseButton)
Definition: Event.hpp:199
+
sf::Event::MouseWheelMoved
@ MouseWheelMoved
The mouse wheel was scrolled (data in event.mouseWheel) (deprecated)
Definition: Event.hpp:197
+
sf::Event::Resized
@ Resized
The window was resized (data in event.size)
Definition: Event.hpp:191
+
sf::Event::JoystickButtonPressed
@ JoystickButtonPressed
A joystick button was pressed (data in event.joystickButton)
Definition: Event.hpp:204
+
sf::Event::TextEntered
@ TextEntered
A character was entered (data in event.text)
Definition: Event.hpp:194
+
sf::Event::GainedFocus
@ GainedFocus
The window gained the focus (no data)
Definition: Event.hpp:193
+
sf::Event::TouchMoved
@ TouchMoved
A touch moved (data in event.touch)
Definition: Event.hpp:210
+
sf::Event::MouseButtonReleased
@ MouseButtonReleased
A mouse button was released (data in event.mouseButton)
Definition: Event.hpp:200
+
sf::Event::KeyReleased
@ KeyReleased
A key was released (data in event.key)
Definition: Event.hpp:196
+
sf::Event::MouseLeft
@ MouseLeft
The mouse cursor left the area of the window (no data)
Definition: Event.hpp:203
+
sf::Event::JoystickConnected
@ JoystickConnected
A joystick was connected (data in event.joystickConnect)
Definition: Event.hpp:207
+
sf::Event::SensorChanged
@ SensorChanged
A sensor value changed (data in event.sensor)
Definition: Event.hpp:212
+
sf::Event::JoystickDisconnected
@ JoystickDisconnected
A joystick was disconnected (data in event.joystickConnect)
Definition: Event.hpp:208
+
sf::Event::TouchEnded
@ TouchEnded
A touch event ended (data in event.touch)
Definition: Event.hpp:211
+
sf::Event::LostFocus
@ LostFocus
The window lost the focus (no data)
Definition: Event.hpp:192
+
sf::Event::KeyPressed
@ KeyPressed
A key was pressed (data in event.key)
Definition: Event.hpp:195
+
sf::Event::Count
@ Count
Keep last – the total number of event types.
Definition: Event.hpp:214
+
sf::Event::TouchBegan
@ TouchBegan
A touch event began (data in event.touch)
Definition: Event.hpp:209
+
sf::Joystick::Axis
Axis
Axes supported by SFML joysticks.
Definition: Joystick.hpp:61
+
sf::Keyboard::Key
Key
Key codes.
Definition: Keyboard.hpp:55
+
sf::Mouse::Button
Button
Mouse buttons.
Definition: Mouse.hpp:52
+
sf::Mouse::Wheel
Wheel
Mouse wheels.
Definition: Mouse.hpp:67
+
sf::Sensor::Type
Type
Sensor type.
Definition: Sensor.hpp:51
+
sf::Event::JoystickButtonEvent
Joystick buttons events parameters (JoystickButtonPressed, JoystickButtonReleased)
Definition: Event.hpp:156
+
sf::Event::JoystickButtonEvent::joystickId
unsigned int joystickId
Index of the joystick (in range [0 .. Joystick::Count - 1])
Definition: Event.hpp:157
+
sf::Event::JoystickButtonEvent::button
unsigned int button
Index of the button that has been pressed (in range [0 .. Joystick::ButtonCount - 1])
Definition: Event.hpp:158
+
sf::Event::JoystickConnectEvent
Joystick connection events parameters (JoystickConnected, JoystickDisconnected)
Definition: Event.hpp:135
+
sf::Event::JoystickConnectEvent::joystickId
unsigned int joystickId
Index of the joystick (in range [0 .. Joystick::Count - 1])
Definition: Event.hpp:136
+
sf::Event::JoystickMoveEvent
Joystick axis move event parameters (JoystickMoved)
Definition: Event.hpp:144
+
sf::Event::JoystickMoveEvent::joystickId
unsigned int joystickId
Index of the joystick (in range [0 .. Joystick::Count - 1])
Definition: Event.hpp:145
+
sf::Event::JoystickMoveEvent::position
float position
New position on the axis (in range [-100 .. 100])
Definition: Event.hpp:147
+
sf::Event::JoystickMoveEvent::axis
Joystick::Axis axis
Axis on which the joystick moved.
Definition: Event.hpp:146
+
sf::Event::KeyEvent
Keyboard event parameters (KeyPressed, KeyReleased)
Definition: Event.hpp:63
+
sf::Event::KeyEvent::scancode
Keyboard::Scancode scancode
Physical code of the key that has been pressed.
Definition: Event.hpp:65
+
sf::Event::KeyEvent::code
Keyboard::Key code
Code of the key that has been pressed.
Definition: Event.hpp:64
+
sf::Event::KeyEvent::shift
bool shift
Is the Shift key pressed?
Definition: Event.hpp:68
+
sf::Event::KeyEvent::alt
bool alt
Is the Alt key pressed?
Definition: Event.hpp:66
+
sf::Event::KeyEvent::control
bool control
Is the Control key pressed?
Definition: Event.hpp:67
+
sf::Event::KeyEvent::system
bool system
Is the System key pressed?
Definition: Event.hpp:69
+
sf::Event::MouseButtonEvent
Mouse buttons events parameters (MouseButtonPressed, MouseButtonReleased)
Definition: Event.hpp:97
+
sf::Event::MouseButtonEvent::x
int x
X position of the mouse pointer, relative to the left of the owner window.
Definition: Event.hpp:99
+
sf::Event::MouseButtonEvent::button
Mouse::Button button
Code of the button that has been pressed.
Definition: Event.hpp:98
+
sf::Event::MouseButtonEvent::y
int y
Y position of the mouse pointer, relative to the top of the owner window.
Definition: Event.hpp:100
+
sf::Event::MouseMoveEvent
Mouse move event parameters (MouseMoved)
Definition: Event.hpp:86
+
sf::Event::MouseMoveEvent::y
int y
Y position of the mouse pointer, relative to the top of the owner window.
Definition: Event.hpp:88
+
sf::Event::MouseMoveEvent::x
int x
X position of the mouse pointer, relative to the left of the owner window.
Definition: Event.hpp:87
+
sf::Event::MouseWheelEvent
Mouse wheel events parameters (MouseWheelMoved)
Definition: Event.hpp:111
+
sf::Event::MouseWheelEvent::x
int x
X position of the mouse pointer, relative to the left of the owner window.
Definition: Event.hpp:113
+
sf::Event::MouseWheelEvent::delta
int delta
Number of ticks the wheel has moved (positive is up, negative is down)
Definition: Event.hpp:112
+
sf::Event::MouseWheelEvent::y
int y
Y position of the mouse pointer, relative to the top of the owner window.
Definition: Event.hpp:114
+
sf::Event::MouseWheelScrollEvent
Mouse wheel events parameters (MouseWheelScrolled)
Definition: Event.hpp:122
+
sf::Event::MouseWheelScrollEvent::wheel
Mouse::Wheel wheel
Which wheel (for mice with multiple ones)
Definition: Event.hpp:123
+
sf::Event::MouseWheelScrollEvent::x
int x
X position of the mouse pointer, relative to the left of the owner window.
Definition: Event.hpp:125
+
sf::Event::MouseWheelScrollEvent::y
int y
Y position of the mouse pointer, relative to the top of the owner window.
Definition: Event.hpp:126
+
sf::Event::MouseWheelScrollEvent::delta
float delta
Wheel offset (positive is up/left, negative is down/right). High-precision mice may use non-integral ...
Definition: Event.hpp:124
+
sf::Event::SensorEvent
Sensor event parameters (SensorChanged)
Definition: Event.hpp:177
+
sf::Event::SensorEvent::z
float z
Current value of the sensor on Z axis.
Definition: Event.hpp:181
+
sf::Event::SensorEvent::x
float x
Current value of the sensor on X axis.
Definition: Event.hpp:179
+
sf::Event::SensorEvent::type
Sensor::Type type
Type of the sensor.
Definition: Event.hpp:178
+
sf::Event::SensorEvent::y
float y
Current value of the sensor on Y axis.
Definition: Event.hpp:180
+
sf::Event::SizeEvent
Size events parameters (Resized)
Definition: Event.hpp:53
+
sf::Event::SizeEvent::width
unsigned int width
New width, in pixels.
Definition: Event.hpp:54
+
sf::Event::SizeEvent::height
unsigned int height
New height, in pixels.
Definition: Event.hpp:55
+
sf::Event::TextEvent
Text event parameters (TextEntered)
Definition: Event.hpp:77
+
sf::Event::TextEvent::unicode
Uint32 unicode
UTF-32 Unicode value of the character.
Definition: Event.hpp:78
+
sf::Event::TouchEvent
Touch events parameters (TouchBegan, TouchMoved, TouchEnded)
Definition: Event.hpp:166
+
sf::Event::TouchEvent::x
int x
X position of the touch, relative to the left of the owner window.
Definition: Event.hpp:168
+
sf::Event::TouchEvent::finger
unsigned int finger
Index of the finger in case of multi-touch events.
Definition: Event.hpp:167
+
sf::Event::TouchEvent::y
int y
Y position of the touch, relative to the top of the owner window.
Definition: Event.hpp:169
+ +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/FileInputStream_8hpp_source.html b/Space-Invaders/sfml/doc/html/FileInputStream_8hpp_source.html new file mode 100644 index 000000000..df81ed158 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/FileInputStream_8hpp_source.html @@ -0,0 +1,193 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
FileInputStream.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_FILEINPUTSTREAM_HPP
+
26#define SFML_FILEINPUTSTREAM_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32#include <SFML/System/Export.hpp>
+
33#include <SFML/System/InputStream.hpp>
+
34#include <SFML/System/NonCopyable.hpp>
+
35#include <cstdio>
+
36#include <string>
+
37
+
38#ifdef SFML_SYSTEM_ANDROID
+
39namespace sf
+
40{
+
41namespace priv
+
42{
+
43class SFML_SYSTEM_API ResourceStream;
+
44}
+
45}
+
46#endif
+
47
+
48
+
49namespace sf
+
50{
+
55class SFML_SYSTEM_API FileInputStream : public InputStream, NonCopyable
+
56{
+
57public:
+
62 FileInputStream();
+
63
+
68 virtual ~FileInputStream();
+
69
+
78 bool open(const std::string& filename);
+
79
+
92 virtual Int64 read(void* data, Int64 size);
+
93
+
102 virtual Int64 seek(Int64 position);
+
103
+
110 virtual Int64 tell();
+
111
+
118 virtual Int64 getSize();
+
119
+
120private:
+
121
+
123 // Member data
+
125#ifdef SFML_SYSTEM_ANDROID
+
126 priv::ResourceStream* m_file;
+
127#else
+
128 std::FILE* m_file;
+
129#endif
+
130};
+
131
+
132} // namespace sf
+
133
+
134
+
135#endif // SFML_FILEINPUTSTREAM_HPP
+
136
+
137
+
sf::FileInputStream
Implementation of input stream based on a file.
Definition: FileInputStream.hpp:56
+
sf::FileInputStream::tell
virtual Int64 tell()
Get the current reading position in the stream.
+
sf::FileInputStream::open
bool open(const std::string &filename)
Open the stream from a file path.
+
sf::FileInputStream::FileInputStream
FileInputStream()
Default constructor.
+
sf::FileInputStream::getSize
virtual Int64 getSize()
Return the size of the stream.
+
sf::FileInputStream::seek
virtual Int64 seek(Int64 position)
Change the current reading position.
+
sf::FileInputStream::read
virtual Int64 read(void *data, Int64 size)
Read data from the stream.
+
sf::FileInputStream::~FileInputStream
virtual ~FileInputStream()
Default destructor.
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Font_8hpp_source.html b/Space-Invaders/sfml/doc/html/Font_8hpp_source.html new file mode 100644 index 000000000..b245e2b13 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Font_8hpp_source.html @@ -0,0 +1,268 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Font.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_FONT_HPP
+
26#define SFML_FONT_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Glyph.hpp>
+
33#include <SFML/Graphics/Texture.hpp>
+
34#include <SFML/Graphics/Rect.hpp>
+
35#include <map>
+
36#include <string>
+
37#include <vector>
+
38
+
39
+
40namespace sf
+
41{
+
42class InputStream;
+
43
+
48class SFML_GRAPHICS_API Font
+
49{
+
50public:
+
51
+
56 struct Info
+
57 {
+
58 std::string family;
+
59 };
+
60
+
61public:
+
62
+
69 Font();
+
70
+
77 Font(const Font& copy);
+
78
+
85 ~Font();
+
86
+
107 bool loadFromFile(const std::string& filename);
+
108
+
128 bool loadFromMemory(const void* data, std::size_t sizeInBytes);
+
129
+
150 bool loadFromStream(InputStream& stream);
+
151
+
158 const Info& getInfo() const;
+
159
+
182 const Glyph& getGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness = 0) const;
+
183
+
200 bool hasGlyph(Uint32 codePoint) const;
+
201
+
218 float getKerning(Uint32 first, Uint32 second, unsigned int characterSize, bool bold = false) const;
+
219
+
231 float getLineSpacing(unsigned int characterSize) const;
+
232
+
246 float getUnderlinePosition(unsigned int characterSize) const;
+
247
+
260 float getUnderlineThickness(unsigned int characterSize) const;
+
261
+
274 const Texture& getTexture(unsigned int characterSize) const;
+
275
+
290 void setSmooth(bool smooth);
+
291
+
300 bool isSmooth() const;
+
301
+
310 Font& operator =(const Font& right);
+
311
+
312private:
+
313
+
318 struct Row
+
319 {
+
320 Row(unsigned int rowTop, unsigned int rowHeight) : width(0), top(rowTop), height(rowHeight) {}
+
321
+
322 unsigned int width;
+
323 unsigned int top;
+
324 unsigned int height;
+
325 };
+
326
+
328 // Types
+
330 typedef std::map<Uint64, Glyph> GlyphTable;
+
331
+
336 struct Page
+
337 {
+
338 explicit Page(bool smooth);
+
339
+
340 GlyphTable glyphs;
+
341 Texture texture;
+
342 unsigned int nextRow;
+
343 std::vector<Row> rows;
+
344 };
+
345
+
350 void cleanup();
+
351
+
360 Page& loadPage(unsigned int characterSize) const;
+
361
+
373 Glyph loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness) const;
+
374
+
385 IntRect findGlyphRect(Page& page, unsigned int width, unsigned int height) const;
+
386
+
395 bool setCurrentSize(unsigned int characterSize) const;
+
396
+
398 // Types
+
400 typedef std::map<unsigned int, Page> PageTable;
+
401
+
403 // Member data
+
405 void* m_library;
+
406 void* m_face;
+
407 void* m_streamRec;
+
408 void* m_stroker;
+
409 int* m_refCount;
+
410 bool m_isSmooth;
+
411 Info m_info;
+
412 mutable PageTable m_pages;
+
413 mutable std::vector<Uint8> m_pixelBuffer;
+
414 #ifdef SFML_SYSTEM_ANDROID
+
415 void* m_stream;
+
416 #endif
+
417};
+
418
+
419} // namespace sf
+
420
+
421
+
422#endif // SFML_FONT_HPP
+
423
+
424
+
sf::Font
Class for loading and manipulating character fonts.
Definition: Font.hpp:49
+
sf::Font::getLineSpacing
float getLineSpacing(unsigned int characterSize) const
Get the line spacing.
+
sf::Font::getGlyph
const Glyph & getGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness=0) const
Retrieve a glyph of the font.
+
sf::Font::Font
Font()
Default constructor.
+
sf::Font::getTexture
const Texture & getTexture(unsigned int characterSize) const
Retrieve the texture containing the loaded glyphs of a certain size.
+
sf::Font::getUnderlinePosition
float getUnderlinePosition(unsigned int characterSize) const
Get the position of the underline.
+
sf::Font::Font
Font(const Font &copy)
Copy constructor.
+
sf::Font::setSmooth
void setSmooth(bool smooth)
Enable or disable the smooth filter.
+
sf::Font::getInfo
const Info & getInfo() const
Get the font information.
+
sf::Font::~Font
~Font()
Destructor.
+
sf::Font::loadFromFile
bool loadFromFile(const std::string &filename)
Load the font from a file.
+
sf::Font::getKerning
float getKerning(Uint32 first, Uint32 second, unsigned int characterSize, bool bold=false) const
Get the kerning offset of two glyphs.
+
sf::Font::loadFromStream
bool loadFromStream(InputStream &stream)
Load the font from a custom stream.
+
sf::Font::loadFromMemory
bool loadFromMemory(const void *data, std::size_t sizeInBytes)
Load the font from a file in memory.
+
sf::Font::getUnderlineThickness
float getUnderlineThickness(unsigned int characterSize) const
Get the thickness of the underline.
+
sf::Font::hasGlyph
bool hasGlyph(Uint32 codePoint) const
Determine if this font has a glyph representing the requested code point.
+
sf::Font::isSmooth
bool isSmooth() const
Tell whether the smooth filter is enabled or not.
+
sf::Glyph
Structure describing a glyph.
Definition: Glyph.hpp:42
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Font::Info
Holds various information about a font.
Definition: Font.hpp:57
+
sf::Font::Info::family
std::string family
The font family.
Definition: Font.hpp:58
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Ftp_8hpp_source.html b/Space-Invaders/sfml/doc/html/Ftp_8hpp_source.html new file mode 100644 index 000000000..0dcfc1ab8 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Ftp_8hpp_source.html @@ -0,0 +1,354 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Ftp.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_FTP_HPP
+
26#define SFML_FTP_HPP
+
27
+
29// Headers
+
31#include <SFML/Network/Export.hpp>
+
32#include <SFML/Network/TcpSocket.hpp>
+
33#include <SFML/System/NonCopyable.hpp>
+
34#include <SFML/System/Time.hpp>
+
35#include <string>
+
36#include <vector>
+
37
+
38
+
39namespace sf
+
40{
+
41class IpAddress;
+
42
+
47class SFML_NETWORK_API Ftp : NonCopyable
+
48{
+
49public:
+
50
+
55 enum TransferMode
+
56 {
+
57 Binary,
+
58 Ascii,
+
59 Ebcdic
+
60 };
+
61
+
66 class SFML_NETWORK_API Response
+
67 {
+
68 public:
+
69
+
74 enum Status
+
75 {
+
76 // 1xx: the requested action is being initiated,
+
77 // expect another reply before proceeding with a new command
+
78 RestartMarkerReply = 110,
+
79 ServiceReadySoon = 120,
+
80 DataConnectionAlreadyOpened = 125,
+
81 OpeningDataConnection = 150,
+
82
+
83 // 2xx: the requested action has been successfully completed
+
84 Ok = 200,
+
85 PointlessCommand = 202,
+
86 SystemStatus = 211,
+
87 DirectoryStatus = 212,
+
88 FileStatus = 213,
+
89 HelpMessage = 214,
+
90 SystemType = 215,
+
91 ServiceReady = 220,
+
92 ClosingConnection = 221,
+
93 DataConnectionOpened = 225,
+
94 ClosingDataConnection = 226,
+
95 EnteringPassiveMode = 227,
+
96 LoggedIn = 230,
+
97 FileActionOk = 250,
+
98 DirectoryOk = 257,
+
99
+
100 // 3xx: the command has been accepted, but the requested action
+
101 // is dormant, pending receipt of further information
+
102 NeedPassword = 331,
+
103 NeedAccountToLogIn = 332,
+
104 NeedInformation = 350,
+
105
+
106 // 4xx: the command was not accepted and the requested action did not take place,
+
107 // but the error condition is temporary and the action may be requested again
+
108 ServiceUnavailable = 421,
+
109 DataConnectionUnavailable = 425,
+
110 TransferAborted = 426,
+
111 FileActionAborted = 450,
+
112 LocalError = 451,
+
113 InsufficientStorageSpace = 452,
+
114
+
115 // 5xx: the command was not accepted and
+
116 // the requested action did not take place
+
117 CommandUnknown = 500,
+
118 ParametersUnknown = 501,
+
119 CommandNotImplemented = 502,
+
120 BadCommandSequence = 503,
+
121 ParameterNotImplemented = 504,
+
122 NotLoggedIn = 530,
+
123 NeedAccountToStore = 532,
+
124 FileUnavailable = 550,
+
125 PageTypeUnknown = 551,
+
126 NotEnoughMemory = 552,
+
127 FilenameNotAllowed = 553,
+
128
+
129 // 10xx: SFML custom codes
+
130 InvalidResponse = 1000,
+
131 ConnectionFailed = 1001,
+
132 ConnectionClosed = 1002,
+
133 InvalidFile = 1003
+
134 };
+
135
+
146 explicit Response(Status code = InvalidResponse, const std::string& message = "");
+
147
+
157 bool isOk() const;
+
158
+
165 Status getStatus() const;
+
166
+
173 const std::string& getMessage() const;
+
174
+
175 private:
+
176
+
178 // Member data
+
180 Status m_status;
+
181 std::string m_message;
+
182 };
+
183
+
188 class SFML_NETWORK_API DirectoryResponse : public Response
+
189 {
+
190 public:
+
191
+
198 DirectoryResponse(const Response& response);
+
199
+
206 const std::string& getDirectory() const;
+
207
+
208 private:
+
209
+
211 // Member data
+
213 std::string m_directory;
+
214 };
+
215
+
216
+
221 class SFML_NETWORK_API ListingResponse : public Response
+
222 {
+
223 public:
+
224
+
232 ListingResponse(const Response& response, const std::string& data);
+
233
+
240 const std::vector<std::string>& getListing() const;
+
241
+
242 private:
+
243
+
245 // Member data
+
247 std::vector<std::string> m_listing;
+
248 };
+
249
+
250
+
258 ~Ftp();
+
259
+
281 Response connect(const IpAddress& server, unsigned short port = 21, Time timeout = Time::Zero);
+
282
+
291 Response disconnect();
+
292
+
302 Response login();
+
303
+
316 Response login(const std::string& name, const std::string& password);
+
317
+
327 Response keepAlive();
+
328
+
340 DirectoryResponse getWorkingDirectory();
+
341
+
357 ListingResponse getDirectoryListing(const std::string& directory = "");
+
358
+
371 Response changeDirectory(const std::string& directory);
+
372
+
381 Response parentDirectory();
+
382
+
396 Response createDirectory(const std::string& name);
+
397
+
413 Response deleteDirectory(const std::string& name);
+
414
+
429 Response renameFile(const std::string& file, const std::string& newName);
+
430
+
446 Response deleteFile(const std::string& name);
+
447
+
468 Response download(const std::string& remoteFile, const std::string& localPath, TransferMode mode = Binary);
+
469
+
491 Response upload(const std::string& localFile, const std::string& remotePath, TransferMode mode = Binary, bool append = false);
+
492
+
509 Response sendCommand(const std::string& command, const std::string& parameter = "");
+
510
+
511private:
+
512
+
522 Response getResponse();
+
523
+
529 class DataChannel;
+
530
+
531 friend class DataChannel;
+
532
+
534 // Member data
+
536 TcpSocket m_commandSocket;
+
537 std::string m_receiveBuffer;
+
538};
+
539
+
540} // namespace sf
+
541
+
542
+
543#endif // SFML_FTP_HPP
+
544
+
545
+
sf::Ftp::DirectoryResponse
Specialization of FTP response returning a directory.
Definition: Ftp.hpp:189
+
sf::Ftp::DirectoryResponse::DirectoryResponse
DirectoryResponse(const Response &response)
Default constructor.
+
sf::Ftp::DirectoryResponse::getDirectory
const std::string & getDirectory() const
Get the directory returned in the response.
+
sf::Ftp::ListingResponse
Specialization of FTP response returning a filename listing.
Definition: Ftp.hpp:222
+
sf::Ftp::ListingResponse::getListing
const std::vector< std::string > & getListing() const
Return the array of directory/file names.
+
sf::Ftp::ListingResponse::ListingResponse
ListingResponse(const Response &response, const std::string &data)
Default constructor.
+
sf::Ftp::Response
Define a FTP response.
Definition: Ftp.hpp:67
+
sf::Ftp::Response::isOk
bool isOk() const
Check if the status code means a success.
+
sf::Ftp::Response::getStatus
Status getStatus() const
Get the status code of the response.
+
sf::Ftp::Response::getMessage
const std::string & getMessage() const
Get the full message contained in the response.
+
sf::Ftp::Response::Response
Response(Status code=InvalidResponse, const std::string &message="")
Default constructor.
+
sf::Ftp::Response::Status
Status
Status codes possibly returned by a FTP response.
Definition: Ftp.hpp:75
+
sf::Ftp
A FTP client.
Definition: Ftp.hpp:48
+
sf::Ftp::upload
Response upload(const std::string &localFile, const std::string &remotePath, TransferMode mode=Binary, bool append=false)
Upload a file to the server.
+
sf::Ftp::TransferMode
TransferMode
Enumeration of transfer modes.
Definition: Ftp.hpp:56
+
sf::Ftp::Binary
@ Binary
Binary mode (file is transfered as a sequence of bytes)
Definition: Ftp.hpp:57
+
sf::Ftp::Ascii
@ Ascii
Text mode using ASCII encoding.
Definition: Ftp.hpp:58
+
sf::Ftp::download
Response download(const std::string &remoteFile, const std::string &localPath, TransferMode mode=Binary)
Download a file from the server.
+
sf::Ftp::createDirectory
Response createDirectory(const std::string &name)
Create a new directory.
+
sf::Ftp::deleteDirectory
Response deleteDirectory(const std::string &name)
Remove an existing directory.
+
sf::Ftp::~Ftp
~Ftp()
Destructor.
+
sf::Ftp::sendCommand
Response sendCommand(const std::string &command, const std::string &parameter="")
Send a command to the FTP server.
+
sf::Ftp::login
Response login()
Log in using an anonymous account.
+
sf::Ftp::getWorkingDirectory
DirectoryResponse getWorkingDirectory()
Get the current working directory.
+
sf::Ftp::changeDirectory
Response changeDirectory(const std::string &directory)
Change the current working directory.
+
sf::Ftp::deleteFile
Response deleteFile(const std::string &name)
Remove an existing file.
+
sf::Ftp::getDirectoryListing
ListingResponse getDirectoryListing(const std::string &directory="")
Get the contents of the given directory.
+
sf::Ftp::renameFile
Response renameFile(const std::string &file, const std::string &newName)
Rename an existing file.
+
sf::Ftp::login
Response login(const std::string &name, const std::string &password)
Log in using a username and a password.
+
sf::Ftp::keepAlive
Response keepAlive()
Send a null command to keep the connection alive.
+
sf::Ftp::disconnect
Response disconnect()
Close the connection with the server.
+
sf::Ftp::parentDirectory
Response parentDirectory()
Go to the parent directory of the current one.
+
sf::Ftp::connect
Response connect(const IpAddress &server, unsigned short port=21, Time timeout=Time::Zero)
Connect to the specified FTP server.
+
sf::IpAddress
Encapsulate an IPv4 network address.
Definition: IpAddress.hpp:45
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::TcpSocket
Specialized socket using the TCP protocol.
Definition: TcpSocket.hpp:47
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/GlResource_8hpp_source.html b/Space-Invaders/sfml/doc/html/GlResource_8hpp_source.html new file mode 100644 index 000000000..49666832d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/GlResource_8hpp_source.html @@ -0,0 +1,173 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
GlResource.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_GLRESOURCE_HPP
+
26#define SFML_GLRESOURCE_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32#include <SFML/System/NonCopyable.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
37
+
38class Context;
+
39
+
40typedef void(*ContextDestroyCallback)(void*);
+
41
+
46class SFML_WINDOW_API GlResource
+
47{
+
48protected:
+
49
+
54 GlResource();
+
55
+
60 ~GlResource();
+
61
+
73 static void registerContextDestroyCallback(ContextDestroyCallback callback, void* arg);
+
74
+
79 class SFML_WINDOW_API TransientContextLock : NonCopyable
+
80 {
+
81 public:
+
86 TransientContextLock();
+
87
+
92 ~TransientContextLock();
+
93 };
+
94};
+
95
+
96} // namespace sf
+
97
+
98
+
99#endif // SFML_GLRESOURCE_HPP
+
100
+
sf::GlResource::TransientContextLock
RAII helper class to temporarily lock an available context for use.
Definition: GlResource.hpp:80
+ +
sf::GlResource::TransientContextLock::TransientContextLock
TransientContextLock()
Default constructor.
+
sf::GlResource
Base class for classes that require an OpenGL context.
Definition: GlResource.hpp:47
+
sf::GlResource::registerContextDestroyCallback
static void registerContextDestroyCallback(ContextDestroyCallback callback, void *arg)
Register a function to be called when a context is destroyed.
+
sf::GlResource::~GlResource
~GlResource()
Destructor.
+
sf::GlResource::GlResource
GlResource()
Default constructor.
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Glsl_8hpp_source.html b/Space-Invaders/sfml/doc/html/Glsl_8hpp_source.html new file mode 100644 index 000000000..b3db6b402 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Glsl_8hpp_source.html @@ -0,0 +1,208 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Glsl.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_GLSL_HPP
+
26#define SFML_GLSL_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Transform.hpp>
+
32#include <SFML/Graphics/Color.hpp>
+
33#include <SFML/System/Vector2.hpp>
+
34#include <SFML/System/Vector3.hpp>
+
35
+
36
+
37namespace sf
+
38{
+
39namespace priv
+
40{
+
41 // Forward declarations
+
42 template <std::size_t Columns, std::size_t Rows>
+
43 struct Matrix;
+
44
+
45 template <typename T>
+
46 struct Vector4;
+
47
+
48#include <SFML/Graphics/Glsl.inl>
+
49
+
50} // namespace priv
+
51
+
52
+
57namespace Glsl
+
58{
+
59
+
64 typedef Vector2<float> Vec2;
+
65
+
70 typedef Vector2<int> Ivec2;
+
71
+
76 typedef Vector2<bool> Bvec2;
+
77
+
82 typedef Vector3<float> Vec3;
+
83
+
88 typedef Vector3<int> Ivec3;
+
89
+
94 typedef Vector3<bool> Bvec3;
+
95
+
96#ifdef SFML_DOXYGEN
+
97
+
110 typedef implementation-defined Vec4;
+
111
+
124 typedef implementation-defined Ivec4;
+
125
+
130 typedef implementation-defined Bvec4;
+
131
+
155 typedef implementation-defined Mat3;
+
156
+
181 typedef implementation-defined Mat4;
+
182
+
183#else // SFML_DOXYGEN
+
184
+
185 typedef priv::Vector4<float> Vec4;
+
186 typedef priv::Vector4<int> Ivec4;
+
187 typedef priv::Vector4<bool> Bvec4;
+
188 typedef priv::Matrix<3, 3> Mat3;
+
189 typedef priv::Matrix<4, 4> Mat4;
+
190
+
191#endif // SFML_DOXYGEN
+
192
+
193} // namespace Glsl
+
194} // namespace sf
+
195
+
196#endif // SFML_GLSL_HPP
+
197
+
198
+
sf::Vector2
Utility template class for manipulating 2-dimensional vectors.
Definition: Vector2.hpp:38
+
sf::Vector3
Utility template class for manipulating 3-dimensional vectors.
Definition: Vector3.hpp:38
+
sf::Glsl::Bvec3
Vector3< bool > Bvec3
3D bool vector (bvec3 in GLSL)
Definition: Glsl.hpp:94
+
sf::Glsl::Bvec2
Vector2< bool > Bvec2
2D bool vector (bvec2 in GLSL)
Definition: Glsl.hpp:76
+
sf::Glsl::Ivec3
Vector3< int > Ivec3
3D int vector (ivec3 in GLSL)
Definition: Glsl.hpp:88
+
sf::Glsl::Mat4
implementation defined Mat4
4x4 float matrix (mat4 in GLSL)
Definition: Glsl.hpp:181
+
sf::Glsl::Ivec4
implementation defined Ivec4
4D int vector (ivec4 in GLSL)
Definition: Glsl.hpp:124
+
sf::Glsl::Vec4
implementation defined Vec4
4D float vector (vec4 in GLSL)
Definition: Glsl.hpp:110
+
sf::Glsl::Bvec4
implementation defined Bvec4
4D bool vector (bvec4 in GLSL)
Definition: Glsl.hpp:130
+
sf::Glsl::Vec3
Vector3< float > Vec3
3D float vector (vec3 in GLSL)
Definition: Glsl.hpp:82
+
sf::Glsl::Mat3
implementation defined Mat3
3x3 float matrix (mat3 in GLSL)
Definition: Glsl.hpp:155
+
sf::Glsl::Ivec2
Vector2< int > Ivec2
2D int vector (ivec2 in GLSL)
Definition: Glsl.hpp:70
+
sf::Glsl::Vec2
Vector2< float > Vec2
2D float vector (vec2 in GLSL)
Definition: Glsl.hpp:64
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Glyph_8hpp_source.html b/Space-Invaders/sfml/doc/html/Glyph_8hpp_source.html new file mode 100644 index 000000000..a78909292 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Glyph_8hpp_source.html @@ -0,0 +1,164 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Glyph.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_GLYPH_HPP
+
26#define SFML_GLYPH_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Rect.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
41class SFML_GRAPHICS_API Glyph
+
42{
+
43public:
+
44
+
49 Glyph() : advance(0) {}
+
50
+
52 // Member data
+
54 float advance;
+
55 int lsbDelta;
+
56 int rsbDelta;
+
57 FloatRect bounds;
+
58 IntRect textureRect;
+
59};
+
60
+
61} // namespace sf
+
62
+
63
+
64#endif // SFML_GLYPH_HPP
+
65
+
66
+
sf::Glyph
Structure describing a glyph.
Definition: Glyph.hpp:42
+
sf::Glyph::textureRect
IntRect textureRect
Texture coordinates of the glyph inside the font's texture.
Definition: Glyph.hpp:58
+
sf::Glyph::bounds
FloatRect bounds
Bounding rectangle of the glyph, in coordinates relative to the baseline.
Definition: Glyph.hpp:57
+
sf::Glyph::Glyph
Glyph()
Default constructor.
Definition: Glyph.hpp:49
+
sf::Glyph::lsbDelta
int lsbDelta
Left offset after forced autohint. Internally used by getKerning()
Definition: Glyph.hpp:55
+
sf::Glyph::advance
float advance
Offset to move horizontally to the next character.
Definition: Glyph.hpp:54
+
sf::Glyph::rsbDelta
int rsbDelta
Right offset after forced autohint. Internally used by getKerning()
Definition: Glyph.hpp:56
+ +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/GpuPreference_8hpp.html b/Space-Invaders/sfml/doc/html/GpuPreference_8hpp.html new file mode 100644 index 000000000..bd5a26dea --- /dev/null +++ b/Space-Invaders/sfml/doc/html/GpuPreference_8hpp.html @@ -0,0 +1,145 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Macros
+
GpuPreference.hpp File Reference
+
+
+ +

Headers. +More...

+
#include <SFML/Config.hpp>
+
+

Go to the source code of this file.

+ + + + + +

+Macros

#define SFML_DEFINE_DISCRETE_GPU_PREFERENCE
 A macro to encourage usage of the discrete GPU.
 
+

Detailed Description

+

Headers.

+

File containing SFML_DEFINE_DISCRETE_GPU_PREFERENCE

+ +

Definition in file GpuPreference.hpp.

+

Macro Definition Documentation

+ +

◆ SFML_DEFINE_DISCRETE_GPU_PREFERENCE

+ +
+
+ + + + +
#define SFML_DEFINE_DISCRETE_GPU_PREFERENCE
+
+ +

A macro to encourage usage of the discrete GPU.

+

In order to inform the Nvidia/AMD driver that an SFML application could benefit from using the more powerful discrete GPU, special symbols have to be publicly exported from the final executable.

+

SFML defines a helper macro to easily do this.

+

Place SFML_DEFINE_DISCRETE_GPU_PREFERENCE in the global scope of a source file that will be linked into the final executable. Typically it is best to place it where the main function is also defined.

+ +

Definition at line 69 of file GpuPreference.hpp.

+ +
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/GpuPreference_8hpp_source.html b/Space-Invaders/sfml/doc/html/GpuPreference_8hpp_source.html new file mode 100644 index 000000000..e6b585dc3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/GpuPreference_8hpp_source.html @@ -0,0 +1,149 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
GpuPreference.hpp
+
+
+Go to the documentation of this file.
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_GPUPREFERENCE_HPP
+
26#define SFML_GPUPREFERENCE_HPP
+
27
+
28
+
32#include <SFML/Config.hpp>
+
33
+
34
+
41
+
42
+
61#if defined(SFML_SYSTEM_WINDOWS)
+
62
+
63 #define SFML_DEFINE_DISCRETE_GPU_PREFERENCE \
+
64 extern "C" __declspec(dllexport) unsigned long NvOptimusEnablement = 1; \
+
65 extern "C" __declspec(dllexport) unsigned long AmdPowerXpressRequestHighPerformance = 1;
+
66
+
67#else
+
68
+
69 #define SFML_DEFINE_DISCRETE_GPU_PREFERENCE
+
70
+
71#endif
+
72
+
73
+
74#endif // SFML_GPUPREFERENCE_HPP
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Graphics_2Export_8hpp_source.html b/Space-Invaders/sfml/doc/html/Graphics_2Export_8hpp_source.html new file mode 100644 index 000000000..02832c885 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Graphics_2Export_8hpp_source.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Graphics/Export.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_GRAPHICS_EXPORT_HPP
+
26#define SFML_GRAPHICS_EXPORT_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32
+
33
+
35// Define portable import / export macros
+
37#if defined(SFML_GRAPHICS_EXPORTS)
+
38
+
39 #define SFML_GRAPHICS_API SFML_API_EXPORT
+
40
+
41#else
+
42
+
43 #define SFML_GRAPHICS_API SFML_API_IMPORT
+
44
+
45#endif
+
46
+
47
+
48#endif // SFML_GRAPHICS_EXPORT_HPP
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Graphics_8hpp_source.html b/Space-Invaders/sfml/doc/html/Graphics_8hpp_source.html new file mode 100644 index 000000000..362069b4b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Graphics_8hpp_source.html @@ -0,0 +1,162 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Graphics.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_GRAPHICS_HPP
+
26#define SFML_GRAPHICS_HPP
+
27
+
29// Headers
+
31
+
32#include <SFML/Window.hpp>
+
33#include <SFML/Graphics/BlendMode.hpp>
+
34#include <SFML/Graphics/CircleShape.hpp>
+
35#include <SFML/Graphics/Color.hpp>
+
36#include <SFML/Graphics/ConvexShape.hpp>
+
37#include <SFML/Graphics/Drawable.hpp>
+
38#include <SFML/Graphics/Font.hpp>
+
39#include <SFML/Graphics/Glyph.hpp>
+
40#include <SFML/Graphics/Image.hpp>
+
41#include <SFML/Graphics/PrimitiveType.hpp>
+
42#include <SFML/Graphics/Rect.hpp>
+
43#include <SFML/Graphics/RectangleShape.hpp>
+
44#include <SFML/Graphics/RenderStates.hpp>
+
45#include <SFML/Graphics/RenderTarget.hpp>
+
46#include <SFML/Graphics/RenderTexture.hpp>
+
47#include <SFML/Graphics/RenderWindow.hpp>
+
48#include <SFML/Graphics/Shader.hpp>
+
49#include <SFML/Graphics/Shape.hpp>
+
50#include <SFML/Graphics/Sprite.hpp>
+
51#include <SFML/Graphics/Text.hpp>
+
52#include <SFML/Graphics/Texture.hpp>
+
53#include <SFML/Graphics/Transform.hpp>
+
54#include <SFML/Graphics/Transformable.hpp>
+
55#include <SFML/Graphics/Vertex.hpp>
+
56#include <SFML/Graphics/VertexArray.hpp>
+
57#include <SFML/Graphics/VertexBuffer.hpp>
+
58#include <SFML/Graphics/View.hpp>
+
59
+
60
+
61#endif // SFML_GRAPHICS_HPP
+
62
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Http_8hpp_source.html b/Space-Invaders/sfml/doc/html/Http_8hpp_source.html new file mode 100644 index 000000000..c5806377e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Http_8hpp_source.html @@ -0,0 +1,314 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Http.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_HTTP_HPP
+
26#define SFML_HTTP_HPP
+
27
+
29// Headers
+
31#include <SFML/Network/Export.hpp>
+
32#include <SFML/Network/IpAddress.hpp>
+
33#include <SFML/Network/TcpSocket.hpp>
+
34#include <SFML/System/NonCopyable.hpp>
+
35#include <SFML/System/Time.hpp>
+
36#include <map>
+
37#include <string>
+
38
+
39
+
40namespace sf
+
41{
+
46class SFML_NETWORK_API Http : NonCopyable
+
47{
+
48public:
+
49
+
54 class SFML_NETWORK_API Request
+
55 {
+
56 public:
+
57
+
62 enum Method
+
63 {
+
64 Get,
+
65 Post,
+
66 Head,
+
67 Put,
+
68 Delete
+
69 };
+
70
+
82 Request(const std::string& uri = "/", Method method = Get, const std::string& body = "");
+
83
+
97 void setField(const std::string& field, const std::string& value);
+
98
+
109 void setMethod(Method method);
+
110
+
121 void setUri(const std::string& uri);
+
122
+
132 void setHttpVersion(unsigned int major, unsigned int minor);
+
133
+
144 void setBody(const std::string& body);
+
145
+
146 private:
+
147
+
148 friend class Http;
+
149
+
159 std::string prepare() const;
+
160
+
171 bool hasField(const std::string& field) const;
+
172
+
174 // Types
+
176 typedef std::map<std::string, std::string> FieldTable;
+
177
+
179 // Member data
+
181 FieldTable m_fields;
+
182 Method m_method;
+
183 std::string m_uri;
+
184 unsigned int m_majorVersion;
+
185 unsigned int m_minorVersion;
+
186 std::string m_body;
+
187 };
+
188
+
193 class SFML_NETWORK_API Response
+
194 {
+
195 public:
+
196
+
201 enum Status
+
202 {
+
203 // 2xx: success
+
204 Ok = 200,
+
205 Created = 201,
+
206 Accepted = 202,
+
207 NoContent = 204,
+
208 ResetContent = 205,
+
209 PartialContent = 206,
+
210
+
211 // 3xx: redirection
+
212 MultipleChoices = 300,
+
213 MovedPermanently = 301,
+
214 MovedTemporarily = 302,
+
215 NotModified = 304,
+
216
+
217 // 4xx: client error
+
218 BadRequest = 400,
+
219 Unauthorized = 401,
+
220 Forbidden = 403,
+
221 NotFound = 404,
+
222 RangeNotSatisfiable = 407,
+
223
+
224 // 5xx: server error
+
225 InternalServerError = 500,
+
226 NotImplemented = 501,
+
227 BadGateway = 502,
+
228 ServiceNotAvailable = 503,
+
229 GatewayTimeout = 504,
+
230 VersionNotSupported = 505,
+
231
+
232 // 10xx: SFML custom codes
+
233 InvalidResponse = 1000,
+
234 ConnectionFailed = 1001
+
235 };
+
236
+
243 Response();
+
244
+
257 const std::string& getField(const std::string& field) const;
+
258
+
270 Status getStatus() const;
+
271
+
280 unsigned int getMajorHttpVersion() const;
+
281
+
290 unsigned int getMinorHttpVersion() const;
+
291
+
304 const std::string& getBody() const;
+
305
+
306 private:
+
307
+
308 friend class Http;
+
309
+
319 void parse(const std::string& data);
+
320
+
321
+
331 void parseFields(std::istream &in);
+
332
+
334 // Types
+
336 typedef std::map<std::string, std::string> FieldTable;
+
337
+
339 // Member data
+
341 FieldTable m_fields;
+
342 Status m_status;
+
343 unsigned int m_majorVersion;
+
344 unsigned int m_minorVersion;
+
345 std::string m_body;
+
346 };
+
347
+
352 Http();
+
353
+
368 Http(const std::string& host, unsigned short port = 0);
+
369
+
385 void setHost(const std::string& host, unsigned short port = 0);
+
386
+
405 Response sendRequest(const Request& request, Time timeout = Time::Zero);
+
406
+
407private:
+
408
+
410 // Member data
+
412 TcpSocket m_connection;
+
413 IpAddress m_host;
+
414 std::string m_hostName;
+
415 unsigned short m_port;
+
416};
+
417
+
418} // namespace sf
+
419
+
420
+
421#endif // SFML_HTTP_HPP
+
422
+
423
+
sf::Http::Request
Define a HTTP request.
Definition: Http.hpp:55
+
sf::Http::Request::setUri
void setUri(const std::string &uri)
Set the requested URI.
+
sf::Http::Request::Method
Method
Enumerate the available HTTP methods for a request.
Definition: Http.hpp:63
+
sf::Http::Request::Head
@ Head
Request a page's header only.
Definition: Http.hpp:66
+
sf::Http::Request::Put
@ Put
Request in put mode, useful for a REST API.
Definition: Http.hpp:67
+
sf::Http::Request::Get
@ Get
Request in get mode, standard method to retrieve a page.
Definition: Http.hpp:64
+
sf::Http::Request::Post
@ Post
Request in post mode, usually to send data to a page.
Definition: Http.hpp:65
+
sf::Http::Request::Request
Request(const std::string &uri="/", Method method=Get, const std::string &body="")
Default constructor.
+
sf::Http::Request::setHttpVersion
void setHttpVersion(unsigned int major, unsigned int minor)
Set the HTTP version for the request.
+
sf::Http::Request::setMethod
void setMethod(Method method)
Set the request method.
+
sf::Http::Request::setBody
void setBody(const std::string &body)
Set the body of the request.
+
sf::Http::Request::setField
void setField(const std::string &field, const std::string &value)
Set the value of a field.
+
sf::Http::Response
Define a HTTP response.
Definition: Http.hpp:194
+
sf::Http::Response::Response
Response()
Default constructor.
+
sf::Http::Response::getStatus
Status getStatus() const
Get the response status code.
+
sf::Http::Response::Status
Status
Enumerate all the valid status codes for a response.
Definition: Http.hpp:202
+
sf::Http::Response::getMajorHttpVersion
unsigned int getMajorHttpVersion() const
Get the major HTTP version number of the response.
+
sf::Http::Response::getBody
const std::string & getBody() const
Get the body of the response.
+
sf::Http::Response::getField
const std::string & getField(const std::string &field) const
Get the value of a field.
+
sf::Http::Response::getMinorHttpVersion
unsigned int getMinorHttpVersion() const
Get the minor HTTP version number of the response.
+
sf::Http
A HTTP client.
Definition: Http.hpp:47
+
sf::Http::setHost
void setHost(const std::string &host, unsigned short port=0)
Set the target host.
+
sf::Http::Http
Http(const std::string &host, unsigned short port=0)
Construct the HTTP client with the target host.
+
sf::Http::sendRequest
Response sendRequest(const Request &request, Time timeout=Time::Zero)
Send a HTTP request and return the server's response.
+
sf::Http::Http
Http()
Default constructor.
+
sf::IpAddress
Encapsulate an IPv4 network address.
Definition: IpAddress.hpp:45
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::TcpSocket
Specialized socket using the TCP protocol.
Definition: TcpSocket.hpp:47
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Image_8hpp_source.html b/Space-Invaders/sfml/doc/html/Image_8hpp_source.html new file mode 100644 index 000000000..b15b8a671 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Image_8hpp_source.html @@ -0,0 +1,214 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Image.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_IMAGE_HPP
+
26#define SFML_IMAGE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Color.hpp>
+
33#include <SFML/Graphics/Rect.hpp>
+
34#include <string>
+
35#include <vector>
+
36
+
37
+
38namespace sf
+
39{
+
40class InputStream;
+
41
+
46class SFML_GRAPHICS_API Image
+
47{
+
48public:
+
49
+
56 Image();
+
57
+
62 ~Image();
+
63
+
72 void create(unsigned int width, unsigned int height, const Color& color = Color(0, 0, 0));
+
73
+
87 void create(unsigned int width, unsigned int height, const Uint8* pixels);
+
88
+
104 bool loadFromFile(const std::string& filename);
+
105
+
122 bool loadFromMemory(const void* data, std::size_t size);
+
123
+
139 bool loadFromStream(InputStream& stream);
+
140
+
156 bool saveToFile(const std::string& filename) const;
+
157
+
174 bool saveToMemory(std::vector<sf::Uint8>& output, const std::string& format) const;
+
175
+
182 Vector2u getSize() const;
+
183
+
195 void createMaskFromColor(const Color& color, Uint8 alpha = 0);
+
196
+
221 void copy(const Image& source, unsigned int destX, unsigned int destY, const IntRect& sourceRect = IntRect(0, 0, 0, 0), bool applyAlpha = false);
+
222
+
237 void setPixel(unsigned int x, unsigned int y, const Color& color);
+
238
+
254 Color getPixel(unsigned int x, unsigned int y) const;
+
255
+
269 const Uint8* getPixelsPtr() const;
+
270
+
275 void flipHorizontally();
+
276
+
281 void flipVertically();
+
282
+
283private:
+
284
+
286 // Member data
+
288 Vector2u m_size;
+
289 std::vector<Uint8> m_pixels;
+
290};
+
291
+
292} // namespace sf
+
293
+
294
+
295#endif // SFML_IMAGE_HPP
+
296
+
297
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+
sf::Image
Class for loading, manipulating and saving images.
Definition: Image.hpp:47
+
sf::Image::~Image
~Image()
Destructor.
+
sf::Image::create
void create(unsigned int width, unsigned int height, const Uint8 *pixels)
Create the image from an array of pixels.
+
sf::Image::loadFromStream
bool loadFromStream(InputStream &stream)
Load the image from a custom stream.
+
sf::Image::createMaskFromColor
void createMaskFromColor(const Color &color, Uint8 alpha=0)
Create a transparency mask from a specified color-key.
+
sf::Image::create
void create(unsigned int width, unsigned int height, const Color &color=Color(0, 0, 0))
Create the image and fill it with a unique color.
+
sf::Image::getPixelsPtr
const Uint8 * getPixelsPtr() const
Get a read-only pointer to the array of pixels.
+
sf::Image::saveToFile
bool saveToFile(const std::string &filename) const
Save the image to a file on disk.
+
sf::Image::flipHorizontally
void flipHorizontally()
Flip the image horizontally (left <-> right)
+
sf::Image::flipVertically
void flipVertically()
Flip the image vertically (top <-> bottom)
+
sf::Image::getSize
Vector2u getSize() const
Return the size (width and height) of the image.
+
sf::Image::loadFromFile
bool loadFromFile(const std::string &filename)
Load the image from a file on disk.
+
sf::Image::setPixel
void setPixel(unsigned int x, unsigned int y, const Color &color)
Change the color of a pixel.
+
sf::Image::loadFromMemory
bool loadFromMemory(const void *data, std::size_t size)
Load the image from a file in memory.
+
sf::Image::copy
void copy(const Image &source, unsigned int destX, unsigned int destY, const IntRect &sourceRect=IntRect(0, 0, 0, 0), bool applyAlpha=false)
Copy pixels from another image onto this one.
+
sf::Image::Image
Image()
Default constructor.
+
sf::Image::getPixel
Color getPixel(unsigned int x, unsigned int y) const
Get the color of a pixel.
+
sf::Image::saveToMemory
bool saveToMemory(std::vector< sf::Uint8 > &output, const std::string &format) const
Save the image to a buffer in memory.
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+ + +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/InputSoundFile_8hpp_source.html b/Space-Invaders/sfml/doc/html/InputSoundFile_8hpp_source.html new file mode 100644 index 000000000..5016ce909 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/InputSoundFile_8hpp_source.html @@ -0,0 +1,214 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
InputSoundFile.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_INPUTSOUNDFILE_HPP
+
26#define SFML_INPUTSOUNDFILE_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <SFML/System/NonCopyable.hpp>
+
33#include <SFML/System/Time.hpp>
+
34#include <string>
+
35#include <cstddef>
+
36
+
37
+
38namespace sf
+
39{
+
40class InputStream;
+
41class SoundFileReader;
+
42
+
47class SFML_AUDIO_API InputSoundFile : NonCopyable
+
48{
+
49public:
+
50
+
55 InputSoundFile();
+
56
+
61 ~InputSoundFile();
+
62
+
79 bool openFromFile(const std::string& filename);
+
80
+
93 bool openFromMemory(const void* data, std::size_t sizeInBytes);
+
94
+
106 bool openFromStream(InputStream& stream);
+
107
+
114 Uint64 getSampleCount() const;
+
115
+
122 unsigned int getChannelCount() const;
+
123
+
130 unsigned int getSampleRate() const;
+
131
+
141 Time getDuration() const;
+
142
+
149 Time getTimeOffset() const;
+
150
+
157 Uint64 getSampleOffset() const;
+
158
+
176 void seek(Uint64 sampleOffset);
+
177
+
190 void seek(Time timeOffset);
+
191
+
201 Uint64 read(Int16* samples, Uint64 maxCount);
+
202
+
207 void close();
+
208
+
209private:
+
210
+
212 // Member data
+
214 SoundFileReader* m_reader;
+
215 InputStream* m_stream;
+
216 bool m_streamOwned;
+
217 Uint64 m_sampleOffset;
+
218 Uint64 m_sampleCount;
+
219 unsigned int m_channelCount;
+
220 unsigned int m_sampleRate;
+
221};
+
222
+
223} // namespace sf
+
224
+
225
+
226#endif // SFML_INPUTSOUNDFILE_HPP
+
227
+
228
+
sf::InputSoundFile
Provide read access to sound files.
Definition: InputSoundFile.hpp:48
+
sf::InputSoundFile::~InputSoundFile
~InputSoundFile()
Destructor.
+
sf::InputSoundFile::openFromStream
bool openFromStream(InputStream &stream)
Open a sound file from a custom stream for reading.
+
sf::InputSoundFile::InputSoundFile
InputSoundFile()
Default constructor.
+
sf::InputSoundFile::openFromMemory
bool openFromMemory(const void *data, std::size_t sizeInBytes)
Open a sound file in memory for reading.
+
sf::InputSoundFile::getChannelCount
unsigned int getChannelCount() const
Get the number of channels used by the sound.
+
sf::InputSoundFile::getSampleCount
Uint64 getSampleCount() const
Get the total number of audio samples in the file.
+
sf::InputSoundFile::getSampleRate
unsigned int getSampleRate() const
Get the sample rate of the sound.
+
sf::InputSoundFile::getSampleOffset
Uint64 getSampleOffset() const
Get the read offset of the file in samples.
+
sf::InputSoundFile::read
Uint64 read(Int16 *samples, Uint64 maxCount)
Read audio samples from the open file.
+
sf::InputSoundFile::seek
void seek(Time timeOffset)
Change the current read position to the given time offset.
+
sf::InputSoundFile::getDuration
Time getDuration() const
Get the total duration of the sound file.
+
sf::InputSoundFile::seek
void seek(Uint64 sampleOffset)
Change the current read position to the given sample offset.
+
sf::InputSoundFile::getTimeOffset
Time getTimeOffset() const
Get the read offset of the file in time.
+
sf::InputSoundFile::close
void close()
Close the current file.
+
sf::InputSoundFile::openFromFile
bool openFromFile(const std::string &filename)
Open a sound file from the disk for reading.
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::SoundFileReader
Abstract base class for sound file decoding.
Definition: SoundFileReader.hpp:44
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/InputStream_8hpp_source.html b/Space-Invaders/sfml/doc/html/InputStream_8hpp_source.html new file mode 100644 index 000000000..d66885244 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/InputStream_8hpp_source.html @@ -0,0 +1,163 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
InputStream.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_INPUTSTREAM_HPP
+
26#define SFML_INPUTSTREAM_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32#include <SFML/System/Export.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
41class SFML_SYSTEM_API InputStream
+
42{
+
43public:
+
44
+
49 virtual ~InputStream() {}
+
50
+
63 virtual Int64 read(void* data, Int64 size) = 0;
+
64
+
73 virtual Int64 seek(Int64 position) = 0;
+
74
+
81 virtual Int64 tell() = 0;
+
82
+
89 virtual Int64 getSize() = 0;
+
90};
+
91
+
92} // namespace sf
+
93
+
94
+
95#endif // SFML_INPUTSTREAM_HPP
+
96
+
97
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::InputStream::getSize
virtual Int64 getSize()=0
Return the size of the stream.
+
sf::InputStream::~InputStream
virtual ~InputStream()
Virtual destructor.
Definition: InputStream.hpp:49
+
sf::InputStream::tell
virtual Int64 tell()=0
Get the current reading position in the stream.
+
sf::InputStream::seek
virtual Int64 seek(Int64 position)=0
Change the current reading position.
+
sf::InputStream::read
virtual Int64 read(void *data, Int64 size)=0
Read data from the stream.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/IpAddress_8hpp_source.html b/Space-Invaders/sfml/doc/html/IpAddress_8hpp_source.html new file mode 100644 index 000000000..c9e104fc9 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/IpAddress_8hpp_source.html @@ -0,0 +1,215 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
IpAddress.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_IPADDRESS_HPP
+
26#define SFML_IPADDRESS_HPP
+
27
+
29// Headers
+
31#include <SFML/Network/Export.hpp>
+
32#include <SFML/System/Time.hpp>
+
33#include <istream>
+
34#include <ostream>
+
35#include <string>
+
36
+
37
+
38namespace sf
+
39{
+
44class SFML_NETWORK_API IpAddress
+
45{
+
46public:
+
47
+
54 IpAddress();
+
55
+
65 IpAddress(const std::string& address);
+
66
+
79 IpAddress(const char* address);
+
80
+
94 IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3);
+
95
+
109 explicit IpAddress(Uint32 address);
+
110
+
123 std::string toString() const;
+
124
+
139 Uint32 toInteger() const;
+
140
+
155 static IpAddress getLocalAddress();
+
156
+
179 static IpAddress getPublicAddress(Time timeout = Time::Zero);
+
180
+
182 // Static member data
+
184 static const IpAddress None;
+
185 static const IpAddress Any;
+
186 static const IpAddress LocalHost;
+
187 static const IpAddress Broadcast;
+
188
+
189private:
+
190
+
191 friend SFML_NETWORK_API bool operator <(const IpAddress& left, const IpAddress& right);
+
192
+
199 void resolve(const std::string& address);
+
200
+
202 // Member data
+
204 Uint32 m_address;
+
205 bool m_valid;
+
206};
+
207
+
217SFML_NETWORK_API bool operator ==(const IpAddress& left, const IpAddress& right);
+
218
+
228SFML_NETWORK_API bool operator !=(const IpAddress& left, const IpAddress& right);
+
229
+
239SFML_NETWORK_API bool operator <(const IpAddress& left, const IpAddress& right);
+
240
+
250SFML_NETWORK_API bool operator >(const IpAddress& left, const IpAddress& right);
+
251
+
261SFML_NETWORK_API bool operator <=(const IpAddress& left, const IpAddress& right);
+
262
+
272SFML_NETWORK_API bool operator >=(const IpAddress& left, const IpAddress& right);
+
273
+
283SFML_NETWORK_API std::istream& operator >>(std::istream& stream, IpAddress& address);
+
284
+
294SFML_NETWORK_API std::ostream& operator <<(std::ostream& stream, const IpAddress& address);
+
295
+
296} // namespace sf
+
297
+
298
+
299#endif // SFML_IPADDRESS_HPP
+
300
+
301
+
sf::IpAddress
Encapsulate an IPv4 network address.
Definition: IpAddress.hpp:45
+
sf::IpAddress::IpAddress
IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3)
Construct the address from 4 bytes.
+
sf::IpAddress::Any
static const IpAddress Any
Value representing any address (0.0.0.0)
Definition: IpAddress.hpp:185
+
sf::IpAddress::None
static const IpAddress None
Value representing an empty/invalid address.
Definition: IpAddress.hpp:184
+
sf::IpAddress::getLocalAddress
static IpAddress getLocalAddress()
Get the computer's local address.
+
sf::IpAddress::LocalHost
static const IpAddress LocalHost
The "localhost" address (for connecting a computer to itself locally)
Definition: IpAddress.hpp:186
+
sf::IpAddress::getPublicAddress
static IpAddress getPublicAddress(Time timeout=Time::Zero)
Get the computer's public address.
+
sf::IpAddress::IpAddress
IpAddress(const std::string &address)
Construct the address from a string.
+
sf::IpAddress::toString
std::string toString() const
Get a string representation of the address.
+
sf::IpAddress::IpAddress
IpAddress(Uint32 address)
Construct the address from a 32-bits integer.
+
sf::IpAddress::IpAddress
IpAddress(const char *address)
Construct the address from a string.
+
sf::IpAddress::Broadcast
static const IpAddress Broadcast
The "broadcast" address (for sending UDP messages to everyone on a local network)
Definition: IpAddress.hpp:187
+
sf::IpAddress::toInteger
Uint32 toInteger() const
Get an integer representation of the address.
+
sf::IpAddress::IpAddress
IpAddress()
Default constructor.
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Joystick_8hpp_source.html b/Space-Invaders/sfml/doc/html/Joystick_8hpp_source.html new file mode 100644 index 000000000..2edd91e40 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Joystick_8hpp_source.html @@ -0,0 +1,210 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Joystick.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_JOYSTICK_HPP
+
26#define SFML_JOYSTICK_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32#include <SFML/System/String.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
41class SFML_WINDOW_API Joystick
+
42{
+
43public:
+
44
+
49 enum
+
50 {
+
51 Count = 8,
+
52 ButtonCount = 32,
+
53 AxisCount = 8
+
54 };
+
55
+
60 enum Axis
+
61 {
+
62 X,
+
63 Y,
+
64 Z,
+
65 R,
+
66 U,
+
67 V,
+
68 PovX,
+
69 PovY
+
70 };
+
71
+
76 struct SFML_WINDOW_API Identification
+
77 {
+
78 Identification();
+
79
+
80 String name;
+
81 unsigned int vendorId;
+
82 unsigned int productId;
+
83 };
+
84
+
93 static bool isConnected(unsigned int joystick);
+
94
+
105 static unsigned int getButtonCount(unsigned int joystick);
+
106
+
118 static bool hasAxis(unsigned int joystick, Axis axis);
+
119
+
131 static bool isButtonPressed(unsigned int joystick, unsigned int button);
+
132
+
144 static float getAxisPosition(unsigned int joystick, Axis axis);
+
145
+
154 static Identification getIdentification(unsigned int joystick);
+
155
+
165 static void update();
+
166};
+
167
+
168} // namespace sf
+
169
+
170
+
171#endif // SFML_JOYSTICK_HPP
+
172
+
173
+
sf::Joystick
Give access to the real-time state of the joysticks.
Definition: Joystick.hpp:42
+
sf::Joystick::hasAxis
static bool hasAxis(unsigned int joystick, Axis axis)
Check if a joystick supports a given axis.
+
sf::Joystick::Axis
Axis
Axes supported by SFML joysticks.
Definition: Joystick.hpp:61
+
sf::Joystick::PovX
@ PovX
The X axis of the point-of-view hat.
Definition: Joystick.hpp:68
+
sf::Joystick::U
@ U
The U axis.
Definition: Joystick.hpp:66
+
sf::Joystick::Y
@ Y
The Y axis.
Definition: Joystick.hpp:63
+
sf::Joystick::Z
@ Z
The Z axis.
Definition: Joystick.hpp:64
+
sf::Joystick::X
@ X
The X axis.
Definition: Joystick.hpp:62
+
sf::Joystick::V
@ V
The V axis.
Definition: Joystick.hpp:67
+
sf::Joystick::R
@ R
The R axis.
Definition: Joystick.hpp:65
+
sf::Joystick::getButtonCount
static unsigned int getButtonCount(unsigned int joystick)
Return the number of buttons supported by a joystick.
+
sf::Joystick::getIdentification
static Identification getIdentification(unsigned int joystick)
Get the joystick information.
+
sf::Joystick::update
static void update()
Update the states of all joysticks.
+
sf::Joystick::isConnected
static bool isConnected(unsigned int joystick)
Check if a joystick is connected.
+
sf::Joystick::isButtonPressed
static bool isButtonPressed(unsigned int joystick, unsigned int button)
Check if a joystick button is pressed.
+
sf::Joystick::getAxisPosition
static float getAxisPosition(unsigned int joystick, Axis axis)
Get the current position of a joystick axis.
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+
sf::Joystick::Identification
Structure holding a joystick's identification.
Definition: Joystick.hpp:77
+
sf::Joystick::Identification::name
String name
Name of the joystick.
Definition: Joystick.hpp:80
+
sf::Joystick::Identification::productId
unsigned int productId
Product identifier.
Definition: Joystick.hpp:82
+
sf::Joystick::Identification::vendorId
unsigned int vendorId
Manufacturer identifier.
Definition: Joystick.hpp:81
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Keyboard_8hpp_source.html b/Space-Invaders/sfml/doc/html/Keyboard_8hpp_source.html new file mode 100644 index 000000000..784656535 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Keyboard_8hpp_source.html @@ -0,0 +1,713 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Keyboard.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_KEYBOARD_HPP
+
26#define SFML_KEYBOARD_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32
+
33
+
34namespace sf
+
35{
+
36class String;
+
37
+
42class SFML_WINDOW_API Keyboard
+
43{
+
44public:
+
45
+
54 enum Key
+
55 {
+
56 Unknown = -1,
+
57 A = 0,
+
58 B,
+
59 C,
+
60 D,
+
61 E,
+
62 F,
+
63 G,
+
64 H,
+
65 I,
+
66 J,
+
67 K,
+
68 L,
+
69 M,
+
70 N,
+
71 O,
+
72 P,
+
73 Q,
+
74 R,
+
75 S,
+
76 T,
+
77 U,
+
78 V,
+
79 W,
+
80 X,
+
81 Y,
+
82 Z,
+
83 Num0,
+
84 Num1,
+
85 Num2,
+
86 Num3,
+
87 Num4,
+
88 Num5,
+
89 Num6,
+
90 Num7,
+
91 Num8,
+
92 Num9,
+
93 Escape,
+
94 LControl,
+
95 LShift,
+
96 LAlt,
+
97 LSystem,
+
98 RControl,
+
99 RShift,
+
100 RAlt,
+
101 RSystem,
+
102 Menu,
+
103 LBracket,
+
104 RBracket,
+
105 Semicolon,
+
106 Comma,
+
107 Period,
+
108 Apostrophe,
+
109 Slash,
+
110 Backslash,
+
111 Grave,
+
112 Equal,
+
113 Hyphen,
+
114 Space,
+
115 Enter,
+
116 Backspace,
+
117 Tab,
+
118 PageUp,
+
119 PageDown,
+
120 End,
+
121 Home,
+
122 Insert,
+
123 Delete,
+
124 Add,
+
125 Subtract,
+
126 Multiply,
+
127 Divide,
+
128 Left,
+
129 Right,
+
130 Up,
+
131 Down,
+
132 Numpad0,
+
133 Numpad1,
+
134 Numpad2,
+
135 Numpad3,
+
136 Numpad4,
+
137 Numpad5,
+
138 Numpad6,
+
139 Numpad7,
+
140 Numpad8,
+
141 Numpad9,
+
142 F1,
+
143 F2,
+
144 F3,
+
145 F4,
+
146 F5,
+
147 F6,
+
148 F7,
+
149 F8,
+
150 F9,
+
151 F10,
+
152 F11,
+
153 F12,
+
154 F13,
+
155 F14,
+
156 F15,
+
157 Pause,
+
158
+
159 KeyCount,
+
160
+
161 // Deprecated values:
+
162
+
163 Tilde = Grave,
+
164 Dash = Hyphen,
+
165 BackSpace = Backspace,
+
166 BackSlash = Backslash,
+
167 SemiColon = Semicolon,
+
168 Return = Enter,
+
169 Quote = Apostrophe
+
170 };
+
171
+
180 struct Scan
+
181 {
+
182 // TODO: replace with enum class in SFML 3.
+
183 // Clang warns us rightfully that Scancode names shadow Key names.
+
184 // A safer solution would be to use a C++11 scoped enumeration (enum class),
+
185 // but it is not possible in SFML 2 which uses C++03.
+
186 // For now, we just ignore those warnings.
+
187 #if defined(__clang__)
+
188 #pragma clang diagnostic push
+
189 #pragma clang diagnostic ignored "-Wshadow"
+
190 #endif
+
191
+
192 enum Scancode
+
193 {
+
194 Unknown = -1,
+
195 A = 0,
+
196 B,
+
197 C,
+
198 D,
+
199 E,
+
200 F,
+
201 G,
+
202 H,
+
203 I,
+
204 J,
+
205 K,
+
206 L,
+
207 M,
+
208 N,
+
209 O,
+
210 P,
+
211 Q,
+
212 R,
+
213 S,
+
214 T,
+
215 U,
+
216 V,
+
217 W,
+
218 X,
+
219 Y,
+
220 Z,
+
221 Num1,
+
222 Num2,
+
223 Num3,
+
224 Num4,
+
225 Num5,
+
226 Num6,
+
227 Num7,
+
228 Num8,
+
229 Num9,
+
230 Num0,
+
231 Enter,
+
232 Escape,
+
233 Backspace,
+
234 Tab,
+
235 Space,
+
236 Hyphen,
+
237 Equal,
+
238 LBracket,
+
239 RBracket,
+
240 // For US keyboards mapped to key 29 (Microsoft Keyboard Scan Code Specification)
+
241 // For Non-US keyboards mapped to key 42 (Microsoft Keyboard Scan Code Specification)
+
242 // Typical language mappings: Belg:£µ` FrCa:<>} Dan:*' Dutch:`´ Fren:µ* Ger:'# Ital:§ù LatAm:[}` Nor:*@ Span:ç} Swed:*' Swiss:$£} UK:~# Brazil:}]
+
243 Backslash,
+
244 Semicolon,
+
245 Apostrophe,
+
246 Grave,
+
247 Comma,
+
248 Period,
+
249 Slash,
+
250 F1,
+
251 F2,
+
252 F3,
+
253 F4,
+
254 F5,
+
255 F6,
+
256 F7,
+
257 F8,
+
258 F9,
+
259 F10,
+
260 F11,
+
261 F12,
+
262 F13,
+
263 F14,
+
264 F15,
+
265 F16,
+
266 F17,
+
267 F18,
+
268 F19,
+
269 F20,
+
270 F21,
+
271 F22,
+
272 F23,
+
273 F24,
+
274 CapsLock,
+
275 PrintScreen,
+
276 ScrollLock,
+
277 Pause,
+
278 Insert,
+
279 Home,
+
280 PageUp,
+
281 Delete,
+
282 End,
+
283 PageDown,
+
284 Right,
+
285 Left,
+
286 Down,
+
287 Up,
+
288 NumLock,
+
289 NumpadDivide,
+
290 NumpadMultiply,
+
291 NumpadMinus,
+
292 NumpadPlus,
+
293 NumpadEqual,
+
294 NumpadEnter,
+
295 NumpadDecimal,
+
296 Numpad1,
+
297 Numpad2,
+
298 Numpad3,
+
299 Numpad4,
+
300 Numpad5,
+
301 Numpad6,
+
302 Numpad7,
+
303 Numpad8,
+
304 Numpad9,
+
305 Numpad0,
+
306 // For US keyboards doesn't exist
+
307 // For Non-US keyboards mapped to key 45 (Microsoft Keyboard Scan Code Specification)
+
308 // Typical language mappings: Belg:<> FrCa:«°» Dan:<> Dutch:]|[ Fren:<> Ger:<|> Ital:<> LatAm:<> Nor:<> Span:<> Swed:<|> Swiss:<> UK:\| Brazil: \|.
+
309 NonUsBackslash,
+
310 Application,
+
311 Execute,
+
312 ModeChange,
+
313 Help,
+
314 Menu,
+
315 Select,
+
316 Redo,
+
317 Undo,
+
318 Cut,
+
319 Copy,
+
320 Paste,
+
321 VolumeMute,
+
322 VolumeUp,
+
323 VolumeDown,
+
324 MediaPlayPause,
+
325 MediaStop,
+
326 MediaNextTrack,
+
327 MediaPreviousTrack,
+
328 LControl,
+
329 LShift,
+
330 LAlt,
+
331 LSystem,
+
332 RControl,
+
333 RShift,
+
334 RAlt,
+
335 RSystem,
+
336 Back,
+
337 Forward,
+
338 Refresh,
+
339 Stop,
+
340 Search,
+
341 Favorites,
+
342 HomePage,
+
343 LaunchApplication1,
+
344 LaunchApplication2,
+
345 LaunchMail,
+
346 LaunchMediaSelect,
+
347
+
348 ScancodeCount
+
349 };
+
350
+
351 #if defined(__clang__)
+
352 #pragma clang diagnostic pop
+
353 #endif
+
354 };
+
355
+
356 typedef Scan::Scancode Scancode;
+
357
+
366 static bool isKeyPressed(Key key);
+
367
+
376 static bool isKeyPressed(Scancode code);
+
377
+
391 static Key localize(Scancode code);
+
392
+
406 static Scancode delocalize(Key key);
+
407
+
427 static String getDescription(Scancode code);
+
428
+
442 static void setVirtualKeyboardVisible(bool visible);
+
443};
+
444
+
445} // namespace sf
+
446
+
447
+
448#endif // SFML_KEYBOARD_HPP
+
449
+
450
+
sf::Keyboard
Give access to the real-time state of the keyboard.
Definition: Keyboard.hpp:43
+
sf::Keyboard::localize
static Key localize(Scancode code)
Localize a physical key to a logical one.
+
sf::Keyboard::isKeyPressed
static bool isKeyPressed(Key key)
Check if a key is pressed.
+
sf::Keyboard::isKeyPressed
static bool isKeyPressed(Scancode code)
Check if a key is pressed.
+
sf::Keyboard::getDescription
static String getDescription(Scancode code)
Provide a string representation for a given scancode.
+
sf::Keyboard::Key
Key
Key codes.
Definition: Keyboard.hpp:55
+
sf::Keyboard::LAlt
@ LAlt
The left Alt key.
Definition: Keyboard.hpp:96
+
sf::Keyboard::X
@ X
The X key.
Definition: Keyboard.hpp:80
+
sf::Keyboard::F5
@ F5
The F5 key.
Definition: Keyboard.hpp:146
+
sf::Keyboard::Numpad1
@ Numpad1
The numpad 1 key.
Definition: Keyboard.hpp:133
+
sf::Keyboard::F7
@ F7
The F7 key.
Definition: Keyboard.hpp:148
+
sf::Keyboard::C
@ C
The C key.
Definition: Keyboard.hpp:59
+
sf::Keyboard::E
@ E
The E key.
Definition: Keyboard.hpp:61
+
sf::Keyboard::Multiply
@ Multiply
The * key.
Definition: Keyboard.hpp:126
+
sf::Keyboard::Add
@ Add
The + key.
Definition: Keyboard.hpp:124
+
sf::Keyboard::T
@ T
The T key.
Definition: Keyboard.hpp:76
+
sf::Keyboard::Num5
@ Num5
The 5 key.
Definition: Keyboard.hpp:88
+
sf::Keyboard::F3
@ F3
The F3 key.
Definition: Keyboard.hpp:144
+
sf::Keyboard::Tab
@ Tab
The Tabulation key.
Definition: Keyboard.hpp:117
+
sf::Keyboard::PageDown
@ PageDown
The Page down key.
Definition: Keyboard.hpp:119
+
sf::Keyboard::RAlt
@ RAlt
The right Alt key.
Definition: Keyboard.hpp:100
+
sf::Keyboard::W
@ W
The W key.
Definition: Keyboard.hpp:79
+
sf::Keyboard::K
@ K
The K key.
Definition: Keyboard.hpp:67
+
sf::Keyboard::Numpad8
@ Numpad8
The numpad 8 key.
Definition: Keyboard.hpp:140
+
sf::Keyboard::LShift
@ LShift
The left Shift key.
Definition: Keyboard.hpp:95
+
sf::Keyboard::RControl
@ RControl
The right Control key.
Definition: Keyboard.hpp:98
+
sf::Keyboard::Q
@ Q
The Q key.
Definition: Keyboard.hpp:73
+
sf::Keyboard::Right
@ Right
Right arrow.
Definition: Keyboard.hpp:129
+
sf::Keyboard::Num2
@ Num2
The 2 key.
Definition: Keyboard.hpp:85
+
sf::Keyboard::Grave
@ Grave
The ` key.
Definition: Keyboard.hpp:111
+
sf::Keyboard::Down
@ Down
Down arrow.
Definition: Keyboard.hpp:131
+
sf::Keyboard::Numpad9
@ Numpad9
The numpad 9 key.
Definition: Keyboard.hpp:141
+
sf::Keyboard::F9
@ F9
The F9 key.
Definition: Keyboard.hpp:150
+
sf::Keyboard::Numpad7
@ Numpad7
The numpad 7 key.
Definition: Keyboard.hpp:139
+
sf::Keyboard::End
@ End
The End key.
Definition: Keyboard.hpp:120
+
sf::Keyboard::Menu
@ Menu
The Menu key.
Definition: Keyboard.hpp:102
+
sf::Keyboard::Z
@ Z
The Z key.
Definition: Keyboard.hpp:82
+
sf::Keyboard::Num1
@ Num1
The 1 key.
Definition: Keyboard.hpp:84
+
sf::Keyboard::RBracket
@ RBracket
The ] key.
Definition: Keyboard.hpp:104
+
sf::Keyboard::Enter
@ Enter
The Enter/Return keys.
Definition: Keyboard.hpp:115
+
sf::Keyboard::Hyphen
@ Hyphen
The - key (hyphen)
Definition: Keyboard.hpp:113
+
sf::Keyboard::RShift
@ RShift
The right Shift key.
Definition: Keyboard.hpp:99
+
sf::Keyboard::Y
@ Y
The Y key.
Definition: Keyboard.hpp:81
+
sf::Keyboard::L
@ L
The L key.
Definition: Keyboard.hpp:68
+
sf::Keyboard::Num4
@ Num4
The 4 key.
Definition: Keyboard.hpp:87
+
sf::Keyboard::Insert
@ Insert
The Insert key.
Definition: Keyboard.hpp:122
+
sf::Keyboard::Escape
@ Escape
The Escape key.
Definition: Keyboard.hpp:93
+
sf::Keyboard::Numpad4
@ Numpad4
The numpad 4 key.
Definition: Keyboard.hpp:136
+
sf::Keyboard::Subtract
@ Subtract
The - key (minus, usually from numpad)
Definition: Keyboard.hpp:125
+
sf::Keyboard::F2
@ F2
The F2 key.
Definition: Keyboard.hpp:143
+
sf::Keyboard::Space
@ Space
The Space key.
Definition: Keyboard.hpp:114
+
sf::Keyboard::F4
@ F4
The F4 key.
Definition: Keyboard.hpp:145
+
sf::Keyboard::LSystem
@ LSystem
The left OS specific key: window (Windows and Linux), apple (macOS), ...
Definition: Keyboard.hpp:97
+
sf::Keyboard::Slash
@ Slash
The / key.
Definition: Keyboard.hpp:109
+
sf::Keyboard::O
@ O
The O key.
Definition: Keyboard.hpp:71
+
sf::Keyboard::Apostrophe
@ Apostrophe
The ' key.
Definition: Keyboard.hpp:108
+
sf::Keyboard::F15
@ F15
The F15 key.
Definition: Keyboard.hpp:156
+
sf::Keyboard::Numpad2
@ Numpad2
The numpad 2 key.
Definition: Keyboard.hpp:134
+
sf::Keyboard::Numpad5
@ Numpad5
The numpad 5 key.
Definition: Keyboard.hpp:137
+
sf::Keyboard::Num7
@ Num7
The 7 key.
Definition: Keyboard.hpp:90
+
sf::Keyboard::KeyCount
@ KeyCount
Keep last – the total number of keyboard keys.
Definition: Keyboard.hpp:159
+
sf::Keyboard::J
@ J
The J key.
Definition: Keyboard.hpp:66
+
sf::Keyboard::Pause
@ Pause
The Pause key.
Definition: Keyboard.hpp:157
+
sf::Keyboard::M
@ M
The M key.
Definition: Keyboard.hpp:69
+
sf::Keyboard::F14
@ F14
The F14 key.
Definition: Keyboard.hpp:155
+
sf::Keyboard::Num9
@ Num9
The 9 key.
Definition: Keyboard.hpp:92
+
sf::Keyboard::F13
@ F13
The F13 key.
Definition: Keyboard.hpp:154
+
sf::Keyboard::PageUp
@ PageUp
The Page up key.
Definition: Keyboard.hpp:118
+
sf::Keyboard::Backspace
@ Backspace
The Backspace key.
Definition: Keyboard.hpp:116
+
sf::Keyboard::P
@ P
The P key.
Definition: Keyboard.hpp:72
+
sf::Keyboard::Numpad6
@ Numpad6
The numpad 6 key.
Definition: Keyboard.hpp:138
+
sf::Keyboard::G
@ G
The G key.
Definition: Keyboard.hpp:63
+
sf::Keyboard::U
@ U
The U key.
Definition: Keyboard.hpp:77
+
sf::Keyboard::Semicolon
@ Semicolon
The ; key.
Definition: Keyboard.hpp:105
+
sf::Keyboard::Numpad3
@ Numpad3
The numpad 3 key.
Definition: Keyboard.hpp:135
+
sf::Keyboard::N
@ N
The N key.
Definition: Keyboard.hpp:70
+
sf::Keyboard::Delete
@ Delete
The Delete key.
Definition: Keyboard.hpp:123
+
sf::Keyboard::Comma
@ Comma
The , key.
Definition: Keyboard.hpp:106
+
sf::Keyboard::F
@ F
The F key.
Definition: Keyboard.hpp:62
+
sf::Keyboard::I
@ I
The I key.
Definition: Keyboard.hpp:65
+
sf::Keyboard::RSystem
@ RSystem
The right OS specific key: window (Windows and Linux), apple (macOS), ...
Definition: Keyboard.hpp:101
+
sf::Keyboard::Left
@ Left
Left arrow.
Definition: Keyboard.hpp:128
+
sf::Keyboard::Up
@ Up
Up arrow.
Definition: Keyboard.hpp:130
+
sf::Keyboard::Period
@ Period
The . key.
Definition: Keyboard.hpp:107
+
sf::Keyboard::F6
@ F6
The F6 key.
Definition: Keyboard.hpp:147
+
sf::Keyboard::S
@ S
The S key.
Definition: Keyboard.hpp:75
+
sf::Keyboard::B
@ B
The B key.
Definition: Keyboard.hpp:58
+
sf::Keyboard::LControl
@ LControl
The left Control key.
Definition: Keyboard.hpp:94
+
sf::Keyboard::Num8
@ Num8
The 8 key.
Definition: Keyboard.hpp:91
+
sf::Keyboard::Backslash
@ Backslash
The \ key.
Definition: Keyboard.hpp:110
+
sf::Keyboard::R
@ R
The R key.
Definition: Keyboard.hpp:74
+
sf::Keyboard::F8
@ F8
The F8 key.
Definition: Keyboard.hpp:149
+
sf::Keyboard::H
@ H
The H key.
Definition: Keyboard.hpp:64
+
sf::Keyboard::Equal
@ Equal
The = key.
Definition: Keyboard.hpp:112
+
sf::Keyboard::F1
@ F1
The F1 key.
Definition: Keyboard.hpp:142
+
sf::Keyboard::D
@ D
The D key.
Definition: Keyboard.hpp:60
+
sf::Keyboard::F10
@ F10
The F10 key.
Definition: Keyboard.hpp:151
+
sf::Keyboard::V
@ V
The V key.
Definition: Keyboard.hpp:78
+
sf::Keyboard::Num3
@ Num3
The 3 key.
Definition: Keyboard.hpp:86
+
sf::Keyboard::Num0
@ Num0
The 0 key.
Definition: Keyboard.hpp:83
+
sf::Keyboard::Numpad0
@ Numpad0
The numpad 0 key.
Definition: Keyboard.hpp:132
+
sf::Keyboard::Home
@ Home
The Home key.
Definition: Keyboard.hpp:121
+
sf::Keyboard::Num6
@ Num6
The 6 key.
Definition: Keyboard.hpp:89
+
sf::Keyboard::F11
@ F11
The F11 key.
Definition: Keyboard.hpp:152
+
sf::Keyboard::F12
@ F12
The F12 key.
Definition: Keyboard.hpp:153
+
sf::Keyboard::Divide
@ Divide
The / key.
Definition: Keyboard.hpp:127
+
sf::Keyboard::LBracket
@ LBracket
The [ key.
Definition: Keyboard.hpp:103
+
sf::Keyboard::setVirtualKeyboardVisible
static void setVirtualKeyboardVisible(bool visible)
Show or hide the virtual keyboard.
+
sf::Keyboard::delocalize
static Scancode delocalize(Key key)
Identify the physical key corresponding to a logical one.
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+ + +
sf::Keyboard::Scan::Backslash
@ Backslash
Keyboard \ and | key OR various keys for Non-US keyboards.
Definition: Keyboard.hpp:243
+
sf::Keyboard::Scan::Comma
@ Comma
Keyboard , and < key.
Definition: Keyboard.hpp:247
+
sf::Keyboard::Scan::Stop
@ Stop
Keyboard Stop key.
Definition: Keyboard.hpp:339
+
sf::Keyboard::Scan::Right
@ Right
Keyboard Right Arrow key.
Definition: Keyboard.hpp:284
+
sf::Keyboard::Scan::F24
@ F24
Keyboard F24 key.
Definition: Keyboard.hpp:273
+
sf::Keyboard::Scan::F20
@ F20
Keyboard F20 key.
Definition: Keyboard.hpp:269
+
sf::Keyboard::Scan::MediaNextTrack
@ MediaNextTrack
Keyboard Media Next Track key.
Definition: Keyboard.hpp:326
+
sf::Keyboard::Scan::P
@ P
Keyboard p and P key.
Definition: Keyboard.hpp:210
+
sf::Keyboard::Scan::PageUp
@ PageUp
Keyboard Page Up key.
Definition: Keyboard.hpp:280
+
sf::Keyboard::Scan::Execute
@ Execute
Keyboard Execute key.
Definition: Keyboard.hpp:311
+
sf::Keyboard::Scan::Num4
@ Num4
Keyboard 4 and $ key.
Definition: Keyboard.hpp:224
+
sf::Keyboard::Scan::Num2
@ Num2
Keyboard 2 and @ key.
Definition: Keyboard.hpp:222
+
sf::Keyboard::Scan::Numpad3
@ Numpad3
Keypad 3 and Page Down key.
Definition: Keyboard.hpp:298
+
sf::Keyboard::Scan::Down
@ Down
Keyboard Down Arrow key.
Definition: Keyboard.hpp:286
+
sf::Keyboard::Scan::Search
@ Search
Keyboard Search key.
Definition: Keyboard.hpp:340
+
sf::Keyboard::Scan::F16
@ F16
Keyboard F16 key.
Definition: Keyboard.hpp:265
+
sf::Keyboard::Scan::K
@ K
Keyboard k and K key.
Definition: Keyboard.hpp:205
+
sf::Keyboard::Scan::LaunchMediaSelect
@ LaunchMediaSelect
Keyboard Launch Media Select key.
Definition: Keyboard.hpp:346
+
sf::Keyboard::Scan::Refresh
@ Refresh
Keyboard Refresh key.
Definition: Keyboard.hpp:338
+
sf::Keyboard::Scan::G
@ G
Keyboard g and G key.
Definition: Keyboard.hpp:201
+
sf::Keyboard::Scan::Left
@ Left
Keyboard Left Arrow key.
Definition: Keyboard.hpp:285
+
sf::Keyboard::Scan::Numpad4
@ Numpad4
Keypad 4 and Left Arrow key.
Definition: Keyboard.hpp:299
+
sf::Keyboard::Scan::W
@ W
Keyboard w and W key.
Definition: Keyboard.hpp:217
+
sf::Keyboard::Scan::Z
@ Z
Keyboard z and Z key.
Definition: Keyboard.hpp:220
+
sf::Keyboard::Scan::RAlt
@ RAlt
Keyboard Right Alt key.
Definition: Keyboard.hpp:334
+
sf::Keyboard::Scan::F
@ F
Keyboard f and F key.
Definition: Keyboard.hpp:200
+
sf::Keyboard::Scan::Delete
@ Delete
Keyboard Delete Forward key.
Definition: Keyboard.hpp:281
+
sf::Keyboard::Scan::Select
@ Select
Keyboard Select key.
Definition: Keyboard.hpp:315
+
sf::Keyboard::Scan::Num3
@ Num3
Keyboard 3 and # key.
Definition: Keyboard.hpp:223
+
sf::Keyboard::Scan::Numpad9
@ Numpad9
Keypad 9 and Page Up key.
Definition: Keyboard.hpp:304
+
sf::Keyboard::Scan::Space
@ Space
Keyboard Space key.
Definition: Keyboard.hpp:235
+
sf::Keyboard::Scan::PageDown
@ PageDown
Keyboard Page Down key.
Definition: Keyboard.hpp:283
+
sf::Keyboard::Scan::VolumeMute
@ VolumeMute
Keyboard Volume Mute key.
Definition: Keyboard.hpp:321
+
sf::Keyboard::Scan::F6
@ F6
Keyboard F6 key.
Definition: Keyboard.hpp:255
+
sf::Keyboard::Scan::S
@ S
Keyboard s and S key.
Definition: Keyboard.hpp:213
+
sf::Keyboard::Scan::Numpad7
@ Numpad7
Keypad 7 and Home key.
Definition: Keyboard.hpp:302
+
sf::Keyboard::Scan::LBracket
@ LBracket
Keyboard [ and { key.
Definition: Keyboard.hpp:238
+
sf::Keyboard::Scan::F2
@ F2
Keyboard F2 key.
Definition: Keyboard.hpp:251
+
sf::Keyboard::Scan::H
@ H
Keyboard h and H key.
Definition: Keyboard.hpp:202
+
sf::Keyboard::Scan::Pause
@ Pause
Keyboard Pause key.
Definition: Keyboard.hpp:277
+
sf::Keyboard::Scan::MediaPlayPause
@ MediaPlayPause
Keyboard Media Play Pause key.
Definition: Keyboard.hpp:324
+
sf::Keyboard::Scan::NonUsBackslash
@ NonUsBackslash
Keyboard Non-US \ and | key.
Definition: Keyboard.hpp:309
+
sf::Keyboard::Scan::Help
@ Help
Keyboard Help key.
Definition: Keyboard.hpp:313
+
sf::Keyboard::Scan::F5
@ F5
Keyboard F5 key.
Definition: Keyboard.hpp:254
+
sf::Keyboard::Scan::F11
@ F11
Keyboard F11 key.
Definition: Keyboard.hpp:260
+
sf::Keyboard::Scan::F19
@ F19
Keyboard F19 key.
Definition: Keyboard.hpp:268
+
sf::Keyboard::Scan::F22
@ F22
Keyboard F22 key.
Definition: Keyboard.hpp:271
+
sf::Keyboard::Scan::Numpad2
@ Numpad2
Keypad 2 and Down Arrow key.
Definition: Keyboard.hpp:297
+
sf::Keyboard::Scan::T
@ T
Keyboard t and T key.
Definition: Keyboard.hpp:214
+
sf::Keyboard::Scan::Numpad6
@ Numpad6
Keypad 6 and Right Arrow key.
Definition: Keyboard.hpp:301
+
sf::Keyboard::Scan::Numpad0
@ Numpad0
Keypad 0 and Insert key.
Definition: Keyboard.hpp:305
+
sf::Keyboard::Scan::B
@ B
Keyboard b and B key.
Definition: Keyboard.hpp:196
+
sf::Keyboard::Scan::Application
@ Application
Keyboard Application key.
Definition: Keyboard.hpp:310
+
sf::Keyboard::Scan::M
@ M
Keyboard m and M key.
Definition: Keyboard.hpp:207
+
sf::Keyboard::Scan::RBracket
@ RBracket
Keyboard ] and } key.
Definition: Keyboard.hpp:239
+
sf::Keyboard::Scan::NumpadEqual
@ NumpadEqual
keypad = key
Definition: Keyboard.hpp:293
+
sf::Keyboard::Scan::Slash
@ Slash
Keyboard / and ? key.
Definition: Keyboard.hpp:249
+
sf::Keyboard::Scan::F7
@ F7
Keyboard F7 key.
Definition: Keyboard.hpp:256
+
sf::Keyboard::Scan::LSystem
@ LSystem
Keyboard Left System key.
Definition: Keyboard.hpp:331
+
sf::Keyboard::Scan::F1
@ F1
Keyboard F1 key.
Definition: Keyboard.hpp:250
+
sf::Keyboard::Scan::End
@ End
Keyboard End key.
Definition: Keyboard.hpp:282
+
sf::Keyboard::Scan::Semicolon
@ Semicolon
Keyboard ; and : key.
Definition: Keyboard.hpp:244
+
sf::Keyboard::Scan::NumpadDecimal
@ NumpadDecimal
Keypad . and Delete key.
Definition: Keyboard.hpp:295
+
sf::Keyboard::Scan::RSystem
@ RSystem
Keyboard Right System key.
Definition: Keyboard.hpp:335
+
sf::Keyboard::Scan::Y
@ Y
Keyboard y and Y key.
Definition: Keyboard.hpp:219
+
sf::Keyboard::Scan::Backspace
@ Backspace
Keyboard Backspace key.
Definition: Keyboard.hpp:233
+
sf::Keyboard::Scan::CapsLock
@ CapsLock
Keyboard Caps Lock key.
Definition: Keyboard.hpp:274
+
sf::Keyboard::Scan::MediaStop
@ MediaStop
Keyboard Media Stop key.
Definition: Keyboard.hpp:325
+
sf::Keyboard::Scan::Up
@ Up
Keyboard Up Arrow key.
Definition: Keyboard.hpp:287
+
sf::Keyboard::Scan::Equal
@ Equal
Keyboard = and +.
Definition: Keyboard.hpp:237
+
sf::Keyboard::Scan::Num6
@ Num6
Keyboard 6 and ^ key.
Definition: Keyboard.hpp:226
+
sf::Keyboard::Scan::N
@ N
Keyboard n and N key.
Definition: Keyboard.hpp:208
+
sf::Keyboard::Scan::Numpad8
@ Numpad8
Keypad 8 and Up Arrow key.
Definition: Keyboard.hpp:303
+
sf::Keyboard::Scan::Copy
@ Copy
Keyboard Copy key.
Definition: Keyboard.hpp:319
+
sf::Keyboard::Scan::LaunchApplication2
@ LaunchApplication2
Keyboard Launch Application 2 key.
Definition: Keyboard.hpp:344
+
sf::Keyboard::Scan::Grave
@ Grave
Keyboard ` and ~ key.
Definition: Keyboard.hpp:246
+
sf::Keyboard::Scan::RShift
@ RShift
Keyboard Right Shift key.
Definition: Keyboard.hpp:333
+
sf::Keyboard::Scan::F14
@ F14
Keyboard F14 key.
Definition: Keyboard.hpp:263
+
sf::Keyboard::Scan::PrintScreen
@ PrintScreen
Keyboard Print Screen key.
Definition: Keyboard.hpp:275
+
sf::Keyboard::Scan::Insert
@ Insert
Keyboard Insert key.
Definition: Keyboard.hpp:278
+
sf::Keyboard::Scan::Numpad5
@ Numpad5
Keypad 5 key.
Definition: Keyboard.hpp:300
+
sf::Keyboard::Scan::D
@ D
Keyboard d and D key.
Definition: Keyboard.hpp:198
+
sf::Keyboard::Scan::HomePage
@ HomePage
Keyboard Home Page key.
Definition: Keyboard.hpp:342
+
sf::Keyboard::Scan::LShift
@ LShift
Keyboard Left Shift key.
Definition: Keyboard.hpp:329
+
sf::Keyboard::Scan::LAlt
@ LAlt
Keyboard Left Alt key.
Definition: Keyboard.hpp:330
+
sf::Keyboard::Scan::F12
@ F12
Keyboard F12 key.
Definition: Keyboard.hpp:261
+
sf::Keyboard::Scan::VolumeDown
@ VolumeDown
Keyboard Volume Down key.
Definition: Keyboard.hpp:323
+
sf::Keyboard::Scan::F17
@ F17
Keyboard F17 key.
Definition: Keyboard.hpp:266
+
sf::Keyboard::Scan::Tab
@ Tab
Keyboard Tab key.
Definition: Keyboard.hpp:234
+
sf::Keyboard::Scan::VolumeUp
@ VolumeUp
Keyboard Volume Up key.
Definition: Keyboard.hpp:322
+
sf::Keyboard::Scan::LControl
@ LControl
Keyboard Left Control key.
Definition: Keyboard.hpp:328
+
sf::Keyboard::Scan::Num7
@ Num7
Keyboard 7 and & key.
Definition: Keyboard.hpp:227
+
sf::Keyboard::Scan::J
@ J
Keyboard j and J key.
Definition: Keyboard.hpp:204
+
sf::Keyboard::Scan::O
@ O
Keyboard o and O key.
Definition: Keyboard.hpp:209
+
sf::Keyboard::Scan::Paste
@ Paste
Keyboard Paste key.
Definition: Keyboard.hpp:320
+
sf::Keyboard::Scan::L
@ L
Keyboard l and L key.
Definition: Keyboard.hpp:206
+
sf::Keyboard::Scan::RControl
@ RControl
Keyboard Right Control key.
Definition: Keyboard.hpp:332
+
sf::Keyboard::Scan::LaunchMail
@ LaunchMail
Keyboard Launch Mail key.
Definition: Keyboard.hpp:345
+
sf::Keyboard::Scan::NumpadPlus
@ NumpadPlus
Keypad + key.
Definition: Keyboard.hpp:292
+
sf::Keyboard::Scan::ScrollLock
@ ScrollLock
Keyboard Scroll Lock key.
Definition: Keyboard.hpp:276
+
sf::Keyboard::Scan::NumpadMultiply
@ NumpadMultiply
Keypad * key.
Definition: Keyboard.hpp:290
+
sf::Keyboard::Scan::Num5
@ Num5
Keyboard 5 and % key.
Definition: Keyboard.hpp:225
+
sf::Keyboard::Scan::Numpad1
@ Numpad1
Keypad 1 and End key.
Definition: Keyboard.hpp:296
+
sf::Keyboard::Scan::LaunchApplication1
@ LaunchApplication1
Keyboard Launch Application 1 key.
Definition: Keyboard.hpp:343
+
sf::Keyboard::Scan::MediaPreviousTrack
@ MediaPreviousTrack
Keyboard Media Previous Track key.
Definition: Keyboard.hpp:327
+
sf::Keyboard::Scan::Apostrophe
@ Apostrophe
Keyboard ' and " key.
Definition: Keyboard.hpp:245
+
sf::Keyboard::Scan::NumpadDivide
@ NumpadDivide
Keypad / key.
Definition: Keyboard.hpp:289
+
sf::Keyboard::Scan::F23
@ F23
Keyboard F23 key.
Definition: Keyboard.hpp:272
+
sf::Keyboard::Scan::Undo
@ Undo
Keyboard Undo key.
Definition: Keyboard.hpp:317
+
sf::Keyboard::Scan::Escape
@ Escape
Keyboard Escape key.
Definition: Keyboard.hpp:232
+
sf::Keyboard::Scan::F15
@ F15
Keyboard F15 key.
Definition: Keyboard.hpp:264
+
sf::Keyboard::Scan::V
@ V
Keyboard v and V key.
Definition: Keyboard.hpp:216
+
sf::Keyboard::Scan::I
@ I
Keyboard i and I key.
Definition: Keyboard.hpp:203
+
sf::Keyboard::Scan::NumLock
@ NumLock
Keypad Num Lock and Clear key.
Definition: Keyboard.hpp:288
+
sf::Keyboard::Scan::C
@ C
Keyboard c and C key.
Definition: Keyboard.hpp:197
+
sf::Keyboard::Scan::Favorites
@ Favorites
Keyboard Favorites key.
Definition: Keyboard.hpp:341
+
sf::Keyboard::Scan::NumpadEnter
@ NumpadEnter
Keypad Enter/Return key.
Definition: Keyboard.hpp:294
+
sf::Keyboard::Scan::Menu
@ Menu
Keyboard Menu key.
Definition: Keyboard.hpp:314
+
sf::Keyboard::Scan::Redo
@ Redo
Keyboard Redo key.
Definition: Keyboard.hpp:316
+
sf::Keyboard::Scan::F21
@ F21
Keyboard F21 key.
Definition: Keyboard.hpp:270
+
sf::Keyboard::Scan::Enter
@ Enter
Keyboard Enter/Return key.
Definition: Keyboard.hpp:231
+
sf::Keyboard::Scan::Forward
@ Forward
Keyboard Forward key.
Definition: Keyboard.hpp:337
+
sf::Keyboard::Scan::Num0
@ Num0
Keyboard 0 and ) key.
Definition: Keyboard.hpp:230
+
sf::Keyboard::Scan::ModeChange
@ ModeChange
Keyboard Mode Change key.
Definition: Keyboard.hpp:312
+
sf::Keyboard::Scan::Num1
@ Num1
Keyboard 1 and ! key.
Definition: Keyboard.hpp:221
+
sf::Keyboard::Scan::E
@ E
Keyboard e and E key.
Definition: Keyboard.hpp:199
+
sf::Keyboard::Scan::Period
@ Period
Keyboard . and > key.
Definition: Keyboard.hpp:248
+
sf::Keyboard::Scan::F9
@ F9
Keyboard F9 key.
Definition: Keyboard.hpp:258
+
sf::Keyboard::Scan::F8
@ F8
Keyboard F8 key.
Definition: Keyboard.hpp:257
+
sf::Keyboard::Scan::NumpadMinus
@ NumpadMinus
Keypad - key.
Definition: Keyboard.hpp:291
+
sf::Keyboard::Scan::F4
@ F4
Keyboard F4 key.
Definition: Keyboard.hpp:253
+
sf::Keyboard::Scan::F18
@ F18
Keyboard F18 key.
Definition: Keyboard.hpp:267
+
sf::Keyboard::Scan::Back
@ Back
Keyboard Back key.
Definition: Keyboard.hpp:336
+
sf::Keyboard::Scan::Home
@ Home
Keyboard Home key.
Definition: Keyboard.hpp:279
+
sf::Keyboard::Scan::Hyphen
@ Hyphen
Keyboard - and _ key.
Definition: Keyboard.hpp:236
+
sf::Keyboard::Scan::U
@ U
Keyboard u and U key.
Definition: Keyboard.hpp:215
+
sf::Keyboard::Scan::F10
@ F10
Keyboard F10 key.
Definition: Keyboard.hpp:259
+
sf::Keyboard::Scan::Num8
@ Num8
Keyboard 8 and * key.
Definition: Keyboard.hpp:228
+
sf::Keyboard::Scan::Num9
@ Num9
Keyboard 9 and ) key.
Definition: Keyboard.hpp:229
+
sf::Keyboard::Scan::R
@ R
Keyboard r and R key.
Definition: Keyboard.hpp:212
+
sf::Keyboard::Scan::F3
@ F3
Keyboard F3 key.
Definition: Keyboard.hpp:252
+
sf::Keyboard::Scan::F13
@ F13
Keyboard F13 key.
Definition: Keyboard.hpp:262
+
sf::Keyboard::Scan::X
@ X
Keyboard x and X key.
Definition: Keyboard.hpp:218
+
sf::Keyboard::Scan::Cut
@ Cut
Keyboard Cut key.
Definition: Keyboard.hpp:318
+
sf::Keyboard::Scan::Q
@ Q
Keyboard q and Q key.
Definition: Keyboard.hpp:211
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Listener_8hpp_source.html b/Space-Invaders/sfml/doc/html/Listener_8hpp_source.html new file mode 100644 index 000000000..74ec6a4a8 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Listener_8hpp_source.html @@ -0,0 +1,182 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Listener.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_LISTENER_HPP
+
26#define SFML_LISTENER_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <SFML/System/Vector3.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
42class SFML_AUDIO_API Listener
+
43{
+
44public:
+
45
+
58 static void setGlobalVolume(float volume);
+
59
+
68 static float getGlobalVolume();
+
69
+
82 static void setPosition(float x, float y, float z);
+
83
+
94 static void setPosition(const Vector3f& position);
+
95
+
104 static Vector3f getPosition();
+
105
+
123 static void setDirection(float x, float y, float z);
+
124
+
140 static void setDirection(const Vector3f& direction);
+
141
+
150 static Vector3f getDirection();
+
151
+
169 static void setUpVector(float x, float y, float z);
+
170
+
186 static void setUpVector(const Vector3f& upVector);
+
187
+
196 static Vector3f getUpVector();
+
197};
+
198
+
199} // namespace sf
+
200
+
201
+
202#endif // SFML_LISTENER_HPP
+
203
+
204
+
sf::Listener
The audio listener is the point in the scene from where all the sounds are heard.
Definition: Listener.hpp:43
+
sf::Listener::setUpVector
static void setUpVector(float x, float y, float z)
Set the upward vector of the listener in the scene.
+
sf::Listener::getGlobalVolume
static float getGlobalVolume()
Get the current value of the global volume.
+
sf::Listener::setDirection
static void setDirection(const Vector3f &direction)
Set the forward vector of the listener in the scene.
+
sf::Listener::setUpVector
static void setUpVector(const Vector3f &upVector)
Set the upward vector of the listener in the scene.
+
sf::Listener::setPosition
static void setPosition(const Vector3f &position)
Set the position of the listener in the scene.
+
sf::Listener::getDirection
static Vector3f getDirection()
Get the current forward vector of the listener in the scene.
+
sf::Listener::setPosition
static void setPosition(float x, float y, float z)
Set the position of the listener in the scene.
+
sf::Listener::setGlobalVolume
static void setGlobalVolume(float volume)
Change the global volume of all the sounds and musics.
+
sf::Listener::getPosition
static Vector3f getPosition()
Get the current position of the listener in the scene.
+
sf::Listener::getUpVector
static Vector3f getUpVector()
Get the current upward vector of the listener in the scene.
+
sf::Listener::setDirection
static void setDirection(float x, float y, float z)
Set the forward vector of the listener in the scene.
+
sf::Vector3
Utility template class for manipulating 3-dimensional vectors.
Definition: Vector3.hpp:38
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Lock_8hpp_source.html b/Space-Invaders/sfml/doc/html/Lock_8hpp_source.html new file mode 100644 index 000000000..99443f1c6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Lock_8hpp_source.html @@ -0,0 +1,163 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Lock.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_LOCK_HPP
+
26#define SFML_LOCK_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Export.hpp>
+
32#include <SFML/System/NonCopyable.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
37class Mutex;
+
38
+
43class SFML_SYSTEM_API Lock : NonCopyable
+
44{
+
45public:
+
46
+
55 explicit Lock(Mutex& mutex);
+
56
+
63 ~Lock();
+
64
+
65private:
+
66
+
68 // Member data
+
70 Mutex& m_mutex;
+
71};
+
72
+
73} // namespace sf
+
74
+
75
+
76#endif // SFML_LOCK_HPP
+
77
+
78
+
sf::Lock
Automatic wrapper for locking and unlocking mutexes.
Definition: Lock.hpp:44
+
sf::Lock::Lock
Lock(Mutex &mutex)
Construct the lock with a target mutex.
+
sf::Lock::~Lock
~Lock()
Destructor.
+
sf::Mutex
Blocks concurrent access to shared resources from multiple threads.
Definition: Mutex.hpp:48
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Main_8hpp_source.html b/Space-Invaders/sfml/doc/html/Main_8hpp_source.html new file mode 100644 index 000000000..40fc0926d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Main_8hpp_source.html @@ -0,0 +1,143 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Main.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_MAIN_HPP
+
26#define SFML_MAIN_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32
+
33
+
34#if defined(SFML_SYSTEM_IOS)
+
35
+
36 // On iOS, we have no choice but to have our own main,
+
37 // so we need to rename the user one and call it later
+
38 #define main sfmlMain
+
39
+
40#endif
+
41
+
42
+
43#endif // SFML_MAIN_HPP
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/MemoryInputStream_8hpp_source.html b/Space-Invaders/sfml/doc/html/MemoryInputStream_8hpp_source.html new file mode 100644 index 000000000..3cd13d93e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/MemoryInputStream_8hpp_source.html @@ -0,0 +1,176 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
MemoryInputStream.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_MEMORYINPUTSTREAM_HPP
+
26#define SFML_MEMORYINPUTSTREAM_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32#include <SFML/System/InputStream.hpp>
+
33#include <SFML/System/Export.hpp>
+
34#include <cstdlib>
+
35
+
36
+
37namespace sf
+
38{
+
43class SFML_SYSTEM_API MemoryInputStream : public InputStream
+
44{
+
45public:
+
46
+
51 MemoryInputStream();
+
52
+
60 void open(const void* data, std::size_t sizeInBytes);
+
61
+
74 virtual Int64 read(void* data, Int64 size);
+
75
+
84 virtual Int64 seek(Int64 position);
+
85
+
92 virtual Int64 tell();
+
93
+
100 virtual Int64 getSize();
+
101
+
102private:
+
103
+
105 // Member data
+
107 const char* m_data;
+
108 Int64 m_size;
+
109 Int64 m_offset;
+
110};
+
111
+
112} // namespace sf
+
113
+
114
+
115#endif // SFML_MEMORYINPUTSTREAM_HPP
+
116
+
117
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::MemoryInputStream
Implementation of input stream based on a memory chunk.
Definition: MemoryInputStream.hpp:44
+
sf::MemoryInputStream::MemoryInputStream
MemoryInputStream()
Default constructor.
+
sf::MemoryInputStream::getSize
virtual Int64 getSize()
Return the size of the stream.
+
sf::MemoryInputStream::tell
virtual Int64 tell()
Get the current reading position in the stream.
+
sf::MemoryInputStream::seek
virtual Int64 seek(Int64 position)
Change the current reading position.
+
sf::MemoryInputStream::open
void open(const void *data, std::size_t sizeInBytes)
Open the stream from its data.
+
sf::MemoryInputStream::read
virtual Int64 read(void *data, Int64 size)
Read data from the stream.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Mouse_8hpp_source.html b/Space-Invaders/sfml/doc/html/Mouse_8hpp_source.html new file mode 100644 index 000000000..f1f29d1ca --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Mouse_8hpp_source.html @@ -0,0 +1,192 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Mouse.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_MOUSE_HPP
+
26#define SFML_MOUSE_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32#include <SFML/System/Vector2.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
37class WindowBase;
+
38
+
43class SFML_WINDOW_API Mouse
+
44{
+
45public:
+
46
+
51 enum Button
+
52 {
+
53 Left,
+
54 Right,
+
55 Middle,
+
56 XButton1,
+
57 XButton2,
+
58
+
59 ButtonCount
+
60 };
+
61
+
66 enum Wheel
+
67 {
+
68 VerticalWheel,
+
69 HorizontalWheel
+
70 };
+
71
+
83 static bool isButtonPressed(Button button);
+
84
+
94 static Vector2i getPosition();
+
95
+
107 static Vector2i getPosition(const WindowBase& relativeTo);
+
108
+
118 static void setPosition(const Vector2i& position);
+
119
+
130 static void setPosition(const Vector2i& position, const WindowBase& relativeTo);
+
131};
+
132
+
133} // namespace sf
+
134
+
135
+
136#endif // SFML_MOUSE_HPP
+
137
+
138
+
sf::Mouse
Give access to the real-time state of the mouse.
Definition: Mouse.hpp:44
+
sf::Mouse::setPosition
static void setPosition(const Vector2i &position)
Set the current position of the mouse in desktop coordinates.
+
sf::Mouse::Button
Button
Mouse buttons.
Definition: Mouse.hpp:52
+
sf::Mouse::XButton2
@ XButton2
The second extra mouse button.
Definition: Mouse.hpp:57
+
sf::Mouse::Middle
@ Middle
The middle (wheel) mouse button.
Definition: Mouse.hpp:55
+
sf::Mouse::Left
@ Left
The left mouse button.
Definition: Mouse.hpp:53
+
sf::Mouse::XButton1
@ XButton1
The first extra mouse button.
Definition: Mouse.hpp:56
+
sf::Mouse::Right
@ Right
The right mouse button.
Definition: Mouse.hpp:54
+
sf::Mouse::Wheel
Wheel
Mouse wheels.
Definition: Mouse.hpp:67
+
sf::Mouse::VerticalWheel
@ VerticalWheel
The vertical mouse wheel.
Definition: Mouse.hpp:68
+
sf::Mouse::setPosition
static void setPosition(const Vector2i &position, const WindowBase &relativeTo)
Set the current position of the mouse in window coordinates.
+
sf::Mouse::isButtonPressed
static bool isButtonPressed(Button button)
Check if a mouse button is pressed.
+
sf::Mouse::getPosition
static Vector2i getPosition()
Get the current position of the mouse in desktop coordinates.
+
sf::Mouse::getPosition
static Vector2i getPosition(const WindowBase &relativeTo)
Get the current position of the mouse in window coordinates.
+
sf::Vector2
Utility template class for manipulating 2-dimensional vectors.
Definition: Vector2.hpp:38
+
sf::WindowBase
Window that serves as a base for other windows.
Definition: WindowBase.hpp:57
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Music_8hpp_source.html b/Space-Invaders/sfml/doc/html/Music_8hpp_source.html new file mode 100644 index 000000000..f44b836a3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Music_8hpp_source.html @@ -0,0 +1,237 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Music.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_MUSIC_HPP
+
26#define SFML_MUSIC_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <SFML/Audio/SoundStream.hpp>
+
33#include <SFML/Audio/InputSoundFile.hpp>
+
34#include <SFML/System/Mutex.hpp>
+
35#include <SFML/System/Time.hpp>
+
36#include <string>
+
37#include <vector>
+
38
+
39
+
40namespace sf
+
41{
+
42class InputStream;
+
43
+
48class SFML_AUDIO_API Music : public SoundStream
+
49{
+
50public:
+
51
+
56 template <typename T>
+
57 struct Span
+
58 {
+
63 Span()
+
64 {
+
65
+
66 }
+
67
+
75 Span(T off, T len):
+
76 offset(off),
+
77 length(len)
+
78 {
+
79
+
80 }
+
81
+
82 T offset;
+
83 T length;
+
84 };
+
85
+
86 // Define the relevant Span types
+
87 typedef Span<Time> TimeSpan;
+
88
+
93 Music();
+
94
+
99 ~Music();
+
100
+
120 bool openFromFile(const std::string& filename);
+
121
+
143 bool openFromMemory(const void* data, std::size_t sizeInBytes);
+
144
+
164 bool openFromStream(InputStream& stream);
+
165
+
172 Time getDuration() const;
+
173
+
189 TimeSpan getLoopPoints() const;
+
190
+
211 void setLoopPoints(TimeSpan timePoints);
+
212
+
213protected:
+
214
+
226 virtual bool onGetData(Chunk& data);
+
227
+
234 virtual void onSeek(Time timeOffset);
+
235
+
246 virtual Int64 onLoop();
+
247
+
248private:
+
249
+
254 void initialize();
+
255
+
264 Uint64 timeToSamples(Time position) const;
+
265
+
274 Time samplesToTime(Uint64 samples) const;
+
275
+
277 // Member data
+
279 InputSoundFile m_file;
+
280 std::vector<Int16> m_samples;
+
281 Mutex m_mutex;
+
282 Span<Uint64> m_loopSpan;
+
283};
+
284
+
285} // namespace sf
+
286
+
287
+
288#endif // SFML_MUSIC_HPP
+
289
+
290
+
sf::InputSoundFile
Provide read access to sound files.
Definition: InputSoundFile.hpp:48
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::Music
Streamed music played from an audio file.
Definition: Music.hpp:49
+
sf::Music::Music
Music()
Default constructor.
+
sf::Music::onSeek
virtual void onSeek(Time timeOffset)
Change the current playing position in the stream source.
+
sf::Music::getDuration
Time getDuration() const
Get the total duration of the music.
+
sf::Music::openFromFile
bool openFromFile(const std::string &filename)
Open a music from an audio file.
+
sf::Music::~Music
~Music()
Destructor.
+
sf::Music::openFromStream
bool openFromStream(InputStream &stream)
Open a music from an audio file in a custom stream.
+
sf::Music::onLoop
virtual Int64 onLoop()
Change the current playing position in the stream source to the loop offset.
+
sf::Music::getLoopPoints
TimeSpan getLoopPoints() const
Get the positions of the of the sound's looping sequence.
+
sf::Music::onGetData
virtual bool onGetData(Chunk &data)
Request a new chunk of audio samples from the stream source.
+
sf::Music::setLoopPoints
void setLoopPoints(TimeSpan timePoints)
Sets the beginning and duration of the sound's looping sequence using sf::Time.
+
sf::Music::openFromMemory
bool openFromMemory(const void *data, std::size_t sizeInBytes)
Open a music from an audio file in memory.
+
sf::Mutex
Blocks concurrent access to shared resources from multiple threads.
Definition: Mutex.hpp:48
+
sf::SoundStream
Abstract base class for streamed audio sources.
Definition: SoundStream.hpp:46
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
sf::Music::Span
Structure defining a time range using the template type.
Definition: Music.hpp:58
+
sf::Music::Span::offset
T offset
The beginning offset of the time range.
Definition: Music.hpp:82
+
sf::Music::Span::length
T length
The length of the time range.
Definition: Music.hpp:83
+
sf::Music::Span::Span
Span()
Default constructor.
Definition: Music.hpp:63
+
sf::Music::Span::Span
Span(T off, T len)
Initialization constructor.
Definition: Music.hpp:75
+
sf::SoundStream::Chunk
Structure defining a chunk of audio data to stream.
Definition: SoundStream.hpp:54
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Mutex_8hpp_source.html b/Space-Invaders/sfml/doc/html/Mutex_8hpp_source.html new file mode 100644 index 000000000..045c025c8 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Mutex_8hpp_source.html @@ -0,0 +1,171 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Mutex.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_MUTEX_HPP
+
26#define SFML_MUTEX_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Export.hpp>
+
32#include <SFML/System/NonCopyable.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
37namespace priv
+
38{
+
39 class MutexImpl;
+
40}
+
41
+
47class SFML_SYSTEM_API Mutex : NonCopyable
+
48{
+
49public:
+
50
+
55 Mutex();
+
56
+
61 ~Mutex();
+
62
+
73 void lock();
+
74
+
81 void unlock();
+
82
+
83private:
+
84
+
86 // Member data
+
88 priv::MutexImpl* m_mutexImpl;
+
89};
+
90
+
91} // namespace sf
+
92
+
93
+
94#endif // SFML_MUTEX_HPP
+
95
+
96
+
sf::Mutex
Blocks concurrent access to shared resources from multiple threads.
Definition: Mutex.hpp:48
+
sf::Mutex::lock
void lock()
Lock the mutex.
+
sf::Mutex::Mutex
Mutex()
Default constructor.
+
sf::Mutex::~Mutex
~Mutex()
Destructor.
+
sf::Mutex::unlock
void unlock()
Unlock the mutex.
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/NativeActivity_8hpp_source.html b/Space-Invaders/sfml/doc/html/NativeActivity_8hpp_source.html new file mode 100644 index 000000000..ef4c465e5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/NativeActivity_8hpp_source.html @@ -0,0 +1,150 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
NativeActivity.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_NATIVEACTIVITY_HPP
+
26#define SFML_NATIVEACTIVITY_HPP
+
27
+
28
+
30// Headers
+
32#include <SFML/System/Export.hpp>
+
33
+
34
+
35#if !defined(SFML_SYSTEM_ANDROID)
+
36#error NativeActivity.hpp: This header is Android only.
+
37#endif
+
38
+
39
+
40struct ANativeActivity;
+
41
+
42namespace sf
+
43{
+
57SFML_SYSTEM_API ANativeActivity* getNativeActivity();
+
58
+
59} // namespace sf
+
60
+
61
+
62#endif // SFML_NATIVEACTIVITY_HPP
+
sf::getNativeActivity
ANativeActivity * getNativeActivity()
Return a pointer to the Android native activity.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Network_2Export_8hpp_source.html b/Space-Invaders/sfml/doc/html/Network_2Export_8hpp_source.html new file mode 100644 index 000000000..a017775b4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Network_2Export_8hpp_source.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Network/Export.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_NETWORK_EXPORT_HPP
+
26#define SFML_NETWORK_EXPORT_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32
+
33
+
35// Define portable import / export macros
+
37#if defined(SFML_NETWORK_EXPORTS)
+
38
+
39 #define SFML_NETWORK_API SFML_API_EXPORT
+
40
+
41#else
+
42
+
43 #define SFML_NETWORK_API SFML_API_IMPORT
+
44
+
45#endif
+
46
+
47
+
48#endif // SFML_NETWORK_EXPORT_HPP
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Network_8hpp_source.html b/Space-Invaders/sfml/doc/html/Network_8hpp_source.html new file mode 100644 index 000000000..5d85b8c3e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Network_8hpp_source.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Network.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_NETWORK_HPP
+
26#define SFML_NETWORK_HPP
+
27
+
29// Headers
+
31
+
32#include <SFML/System.hpp>
+
33#include <SFML/Network/Ftp.hpp>
+
34#include <SFML/Network/Http.hpp>
+
35#include <SFML/Network/IpAddress.hpp>
+
36#include <SFML/Network/Packet.hpp>
+
37#include <SFML/Network/Socket.hpp>
+
38#include <SFML/Network/SocketHandle.hpp>
+
39#include <SFML/Network/SocketSelector.hpp>
+
40#include <SFML/Network/TcpListener.hpp>
+
41#include <SFML/Network/TcpSocket.hpp>
+
42#include <SFML/Network/UdpSocket.hpp>
+
43
+
44
+
45#endif // SFML_NETWORK_HPP
+
46
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/NonCopyable_8hpp_source.html b/Space-Invaders/sfml/doc/html/NonCopyable_8hpp_source.html new file mode 100644 index 000000000..f21fd1a4e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/NonCopyable_8hpp_source.html @@ -0,0 +1,159 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
NonCopyable.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_NONCOPYABLE_HPP
+
26#define SFML_NONCOPYABLE_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Export.hpp>
+
32
+
33
+
34namespace sf
+
35{
+
41class SFML_SYSTEM_API NonCopyable
+
42{
+
43protected:
+
44
+
53 NonCopyable() {}
+
54
+
63 ~NonCopyable() {}
+
64
+
65private:
+
66
+
77 NonCopyable(const NonCopyable&);
+
78
+
89 NonCopyable& operator =(const NonCopyable&);
+
90};
+
91
+
92} // namespace sf
+
93
+
94
+
95#endif // SFML_NONCOPYABLE_HPP
+
96
+
97
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::NonCopyable::NonCopyable
NonCopyable()
Default constructor.
Definition: NonCopyable.hpp:53
+
sf::NonCopyable::~NonCopyable
~NonCopyable()
Default destructor.
Definition: NonCopyable.hpp:63
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/OpenGL_8hpp_source.html b/Space-Invaders/sfml/doc/html/OpenGL_8hpp_source.html new file mode 100644 index 000000000..60508d60a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/OpenGL_8hpp_source.html @@ -0,0 +1,173 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
OpenGL.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_OPENGL_HPP
+
26#define SFML_OPENGL_HPP
+
27
+
28
+
32#include <SFML/Config.hpp>
+
33
+
34
+
39#if defined(SFML_SYSTEM_WINDOWS)
+
40
+
41 // The Visual C++ version of gl.h uses WINGDIAPI and APIENTRY but doesn't define them
+
42 #ifdef _MSC_VER
+
43 #include <windows.h>
+
44 #endif
+
45
+
46 #include <GL/gl.h>
+
47
+
48#elif defined(SFML_SYSTEM_LINUX) || defined(SFML_SYSTEM_FREEBSD) || defined(SFML_SYSTEM_OPENBSD) || defined(SFML_SYSTEM_NETBSD)
+
49
+
50 #if defined(SFML_OPENGL_ES)
+
51 #include <GLES/gl.h>
+
52 #include <GLES/glext.h>
+
53 #else
+
54 #include <GL/gl.h>
+
55 #endif
+
56
+
57#elif defined(SFML_SYSTEM_MACOS)
+
58
+
59 #include <OpenGL/gl.h>
+
60
+
61#elif defined (SFML_SYSTEM_IOS)
+
62
+
63 #include <OpenGLES/ES1/gl.h>
+
64 #include <OpenGLES/ES1/glext.h>
+
65
+
66#elif defined (SFML_SYSTEM_ANDROID)
+
67
+
68 #include <GLES/gl.h>
+
69 #include <GLES/glext.h>
+
70
+
71 // We're not using OpenGL ES 2+ yet, but we can use the sRGB extension
+
72 #include <GLES2/gl2platform.h>
+
73 #include <GLES2/gl2ext.h>
+
74
+
75#endif
+
76
+
77
+
78#endif // SFML_OPENGL_HPP
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/OutputSoundFile_8hpp_source.html b/Space-Invaders/sfml/doc/html/OutputSoundFile_8hpp_source.html new file mode 100644 index 000000000..2eaf7d47b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/OutputSoundFile_8hpp_source.html @@ -0,0 +1,173 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
OutputSoundFile.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_OUTPUTSOUNDFILE_HPP
+
26#define SFML_OUTPUTSOUNDFILE_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <SFML/System/NonCopyable.hpp>
+
33#include <string>
+
34
+
35
+
36namespace sf
+
37{
+
38class SoundFileWriter;
+
39
+
44class SFML_AUDIO_API OutputSoundFile : NonCopyable
+
45{
+
46public:
+
47
+
52 OutputSoundFile();
+
53
+
60 ~OutputSoundFile();
+
61
+
74 bool openFromFile(const std::string& filename, unsigned int sampleRate, unsigned int channelCount);
+
75
+
83 void write(const Int16* samples, Uint64 count);
+
84
+
89 void close();
+
90
+
91private:
+
92
+
94 // Member data
+
96 SoundFileWriter* m_writer;
+
97};
+
98
+
99} // namespace sf
+
100
+
101
+
102#endif // SFML_OUTPUTSOUNDFILE_HPP
+
103
+
104
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::OutputSoundFile
Provide write access to sound files.
Definition: OutputSoundFile.hpp:45
+
sf::OutputSoundFile::~OutputSoundFile
~OutputSoundFile()
Destructor.
+
sf::OutputSoundFile::OutputSoundFile
OutputSoundFile()
Default constructor.
+
sf::OutputSoundFile::close
void close()
Close the current file.
+
sf::OutputSoundFile::write
void write(const Int16 *samples, Uint64 count)
Write audio samples to the file.
+
sf::OutputSoundFile::openFromFile
bool openFromFile(const std::string &filename, unsigned int sampleRate, unsigned int channelCount)
Open the sound file from the disk for writing.
+
sf::SoundFileWriter
Abstract base class for sound file encoding.
Definition: SoundFileWriter.hpp:42
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Packet_8hpp_source.html b/Space-Invaders/sfml/doc/html/Packet_8hpp_source.html new file mode 100644 index 000000000..28b17832c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Packet_8hpp_source.html @@ -0,0 +1,275 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Packet.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_PACKET_HPP
+
26#define SFML_PACKET_HPP
+
27
+
29// Headers
+
31#include <SFML/Network/Export.hpp>
+
32#include <string>
+
33#include <vector>
+
34
+
35
+
36namespace sf
+
37{
+
38class String;
+
39class TcpSocket;
+
40class UdpSocket;
+
41
+
47class SFML_NETWORK_API Packet
+
48{
+
49 // A bool-like type that cannot be converted to integer or pointer types
+
50 typedef bool (Packet::*BoolType)(std::size_t);
+
51
+
52public:
+
53
+
60 Packet();
+
61
+
66 virtual ~Packet();
+
67
+
78 void append(const void* data, std::size_t sizeInBytes);
+
79
+
90 std::size_t getReadPosition() const;
+
91
+
100 void clear();
+
101
+
115 const void* getData() const;
+
116
+
128 std::size_t getDataSize() const;
+
129
+
142 bool endOfPacket() const;
+
143
+
144public:
+
145
+
184 operator BoolType() const;
+
185
+
190 Packet& operator >>(bool& data);
+
191
+
195 Packet& operator >>(Int8& data);
+
196
+
200 Packet& operator >>(Uint8& data);
+
201
+
205 Packet& operator >>(Int16& data);
+
206
+
210 Packet& operator >>(Uint16& data);
+
211
+
215 Packet& operator >>(Int32& data);
+
216
+
220 Packet& operator >>(Uint32& data);
+
221
+
225 Packet& operator >>(Int64& data);
+
226
+
230 Packet& operator >>(Uint64& data);
+
231
+
235 Packet& operator >>(float& data);
+
236
+
240 Packet& operator >>(double& data);
+
241
+
245 Packet& operator >>(char* data);
+
246
+
250 Packet& operator >>(std::string& data);
+
251
+
255 Packet& operator >>(wchar_t* data);
+
256
+
260 Packet& operator >>(std::wstring& data);
+
261
+
265 Packet& operator >>(String& data);
+
266
+
271 Packet& operator <<(bool data);
+
272
+
276 Packet& operator <<(Int8 data);
+
277
+
281 Packet& operator <<(Uint8 data);
+
282
+
286 Packet& operator <<(Int16 data);
+
287
+
291 Packet& operator <<(Uint16 data);
+
292
+
296 Packet& operator <<(Int32 data);
+
297
+
301 Packet& operator <<(Uint32 data);
+
302
+
306 Packet& operator <<(Int64 data);
+
307
+
311 Packet& operator <<(Uint64 data);
+
312
+
316 Packet& operator <<(float data);
+
317
+
321 Packet& operator <<(double data);
+
322
+
326 Packet& operator <<(const char* data);
+
327
+
331 Packet& operator <<(const std::string& data);
+
332
+
336 Packet& operator <<(const wchar_t* data);
+
337
+
341 Packet& operator <<(const std::wstring& data);
+
342
+
346 Packet& operator <<(const String& data);
+
347
+
348protected:
+
349
+
350 friend class TcpSocket;
+
351 friend class UdpSocket;
+
352
+
371 virtual const void* onSend(std::size_t& size);
+
372
+
390 virtual void onReceive(const void* data, std::size_t size);
+
391
+
392private:
+
393
+
398 bool operator ==(const Packet& right) const;
+
399 bool operator !=(const Packet& right) const;
+
400
+
411 bool checkSize(std::size_t size);
+
412
+
414 // Member data
+
416 std::vector<char> m_data;
+
417 std::size_t m_readPos;
+
418 std::size_t m_sendPos;
+
419 bool m_isValid;
+
420};
+
421
+
422} // namespace sf
+
423
+
424
+
425#endif // SFML_PACKET_HPP
+
426
+
427
+
sf::Packet
Utility class to build blocks of data to transfer over the network.
Definition: Packet.hpp:48
+
sf::Packet::getDataSize
std::size_t getDataSize() const
Get the size of the data contained in the packet.
+
sf::Packet::clear
void clear()
Clear the packet.
+
sf::Packet::getReadPosition
std::size_t getReadPosition() const
Get the current reading position in the packet.
+
sf::Packet::endOfPacket
bool endOfPacket() const
Tell if the reading position has reached the end of the packet.
+
sf::Packet::Packet
Packet()
Default constructor.
+
sf::Packet::append
void append(const void *data, std::size_t sizeInBytes)
Append data to the end of the packet.
+
sf::Packet::getData
const void * getData() const
Get a pointer to the data contained in the packet.
+
sf::Packet::onReceive
virtual void onReceive(const void *data, std::size_t size)
Called after the packet is received over the network.
+
sf::Packet::~Packet
virtual ~Packet()
Virtual destructor.
+
sf::Packet::onSend
virtual const void * onSend(std::size_t &size)
Called before the packet is sent over the network.
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+
sf::TcpSocket
Specialized socket using the TCP protocol.
Definition: TcpSocket.hpp:47
+
sf::UdpSocket
Specialized socket using the UDP protocol.
Definition: UdpSocket.hpp:46
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/PrimitiveType_8hpp_source.html b/Space-Invaders/sfml/doc/html/PrimitiveType_8hpp_source.html new file mode 100644 index 000000000..529d9b440 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/PrimitiveType_8hpp_source.html @@ -0,0 +1,162 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
PrimitiveType.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_PRIMITIVETYPE_HPP
+
26#define SFML_PRIMITIVETYPE_HPP
+
27
+
28namespace sf
+
29{
+
39enum PrimitiveType
+
40{
+
41 Points,
+
42 Lines,
+
43 LineStrip,
+
44 Triangles,
+
45 TriangleStrip,
+
46 TriangleFan,
+
47 Quads,
+
48
+
49 // Deprecated names
+
50 LinesStrip = LineStrip,
+
51 TrianglesStrip = TriangleStrip,
+
52 TrianglesFan = TriangleFan
+
53};
+
54
+
55} // namespace sf
+
56
+
57
+
58#endif // SFML_PRIMITIVETYPE_HPP
+
sf::PrimitiveType
PrimitiveType
Types of primitives that a sf::VertexArray can render.
Definition: PrimitiveType.hpp:40
+
sf::TriangleStrip
@ TriangleStrip
List of connected triangles, a point uses the two previous points to form a triangle.
Definition: PrimitiveType.hpp:45
+
sf::LineStrip
@ LineStrip
List of connected lines, a point uses the previous point to form a line.
Definition: PrimitiveType.hpp:43
+
sf::Lines
@ Lines
List of individual lines.
Definition: PrimitiveType.hpp:42
+
sf::TriangleFan
@ TriangleFan
List of connected triangles, a point uses the common center and the previous point to form a triangle...
Definition: PrimitiveType.hpp:46
+
sf::Quads
@ Quads
List of individual quads (deprecated, don't work with OpenGL ES)
Definition: PrimitiveType.hpp:47
+
sf::TrianglesFan
@ TrianglesFan
Definition: PrimitiveType.hpp:52
+
sf::LinesStrip
@ LinesStrip
Definition: PrimitiveType.hpp:50
+
sf::TrianglesStrip
@ TrianglesStrip
Definition: PrimitiveType.hpp:51
+
sf::Triangles
@ Triangles
List of individual triangles.
Definition: PrimitiveType.hpp:44
+
sf::Points
@ Points
List of individual points.
Definition: PrimitiveType.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Rect_8hpp_source.html b/Space-Invaders/sfml/doc/html/Rect_8hpp_source.html new file mode 100644 index 000000000..9821226e0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Rect_8hpp_source.html @@ -0,0 +1,203 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Rect.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_RECT_HPP
+
26#define SFML_RECT_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Vector2.hpp>
+
32#include <algorithm>
+
33
+
34
+
35namespace sf
+
36{
+
41template <typename T>
+
42class Rect
+
43{
+
44public:
+
45
+
53 Rect();
+
54
+
67 Rect(T rectLeft, T rectTop, T rectWidth, T rectHeight);
+
68
+
79 Rect(const Vector2<T>& position, const Vector2<T>& size);
+
80
+
92 template <typename U>
+
93 explicit Rect(const Rect<U>& rectangle);
+
94
+
109 bool contains(T x, T y) const;
+
110
+
124 bool contains(const Vector2<T>& point) const;
+
125
+
136 bool intersects(const Rect<T>& rectangle) const;
+
137
+
152 bool intersects(const Rect<T>& rectangle, Rect<T>& intersection) const;
+
153
+
162 sf::Vector2<T> getPosition() const;
+
163
+
172 sf::Vector2<T> getSize() const;
+
173
+
175 // Member data
+
177 T left;
+
178 T top;
+
179 T width;
+
180 T height;
+
181};
+
182
+
195template <typename T>
+
196bool operator ==(const Rect<T>& left, const Rect<T>& right);
+
197
+
210template <typename T>
+
211bool operator !=(const Rect<T>& left, const Rect<T>& right);
+
212
+
213#include <SFML/Graphics/Rect.inl>
+
214
+
215// Create typedefs for the most common types
+
216typedef Rect<int> IntRect;
+
217typedef Rect<float> FloatRect;
+
218
+
219} // namespace sf
+
220
+
221
+
222#endif // SFML_RECT_HPP
+
223
+
224
+
sf::Rect
Utility class for manipulating 2D axis aligned rectangles.
Definition: Rect.hpp:43
+
sf::Rect::Rect
Rect()
Default constructor.
+
sf::Rect::Rect
Rect(T rectLeft, T rectTop, T rectWidth, T rectHeight)
Construct the rectangle from its coordinates.
+
sf::Rect::Rect
Rect(const Vector2< T > &position, const Vector2< T > &size)
Construct the rectangle from position and size.
+
sf::Rect::contains
bool contains(const Vector2< T > &point) const
Check if a point is inside the rectangle's area.
+
sf::Rect::width
T width
Width of the rectangle.
Definition: Rect.hpp:179
+
sf::Rect::height
T height
Height of the rectangle.
Definition: Rect.hpp:180
+
sf::Rect::Rect
Rect(const Rect< U > &rectangle)
Construct the rectangle from another type of rectangle.
+
sf::Rect::getPosition
sf::Vector2< T > getPosition() const
Get the position of the rectangle's top-left corner.
+
sf::Rect::contains
bool contains(T x, T y) const
Check if a point is inside the rectangle's area.
+
sf::Rect::left
T left
Left coordinate of the rectangle.
Definition: Rect.hpp:177
+
sf::Rect::getSize
sf::Vector2< T > getSize() const
Get the size of the rectangle.
+
sf::Rect::top
T top
Top coordinate of the rectangle.
Definition: Rect.hpp:178
+
sf::Rect::intersects
bool intersects(const Rect< T > &rectangle) const
Check the intersection between two rectangles.
+
sf::Rect::intersects
bool intersects(const Rect< T > &rectangle, Rect< T > &intersection) const
Check the intersection between two rectangles.
+
sf::Vector2
Utility template class for manipulating 2-dimensional vectors.
Definition: Vector2.hpp:38
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/RectangleShape_8hpp_source.html b/Space-Invaders/sfml/doc/html/RectangleShape_8hpp_source.html new file mode 100644 index 000000000..3c973c9dc --- /dev/null +++ b/Space-Invaders/sfml/doc/html/RectangleShape_8hpp_source.html @@ -0,0 +1,170 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
RectangleShape.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_RECTANGLESHAPE_HPP
+
26#define SFML_RECTANGLESHAPE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Shape.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
41class SFML_GRAPHICS_API RectangleShape : public Shape
+
42{
+
43public:
+
44
+
51 explicit RectangleShape(const Vector2f& size = Vector2f(0, 0));
+
52
+
61 void setSize(const Vector2f& size);
+
62
+
71 const Vector2f& getSize() const;
+
72
+
80 virtual std::size_t getPointCount() const;
+
81
+
95 virtual Vector2f getPoint(std::size_t index) const;
+
96
+
97private:
+
98
+
100 // Member data
+
102 Vector2f m_size;
+
103};
+
104
+
105} // namespace sf
+
106
+
107
+
108#endif // SFML_RECTANGLESHAPE_HPP
+
109
+
110
+
sf::RectangleShape
Specialized shape representing a rectangle.
Definition: RectangleShape.hpp:42
+
sf::RectangleShape::getPoint
virtual Vector2f getPoint(std::size_t index) const
Get a point of the rectangle.
+
sf::RectangleShape::setSize
void setSize(const Vector2f &size)
Set the size of the rectangle.
+
sf::RectangleShape::RectangleShape
RectangleShape(const Vector2f &size=Vector2f(0, 0))
Default constructor.
+
sf::RectangleShape::getPointCount
virtual std::size_t getPointCount() const
Get the number of points defining the shape.
+
sf::RectangleShape::getSize
const Vector2f & getSize() const
Get the size of the rectangle.
+
sf::Shape
Base class for textured shapes with outline.
Definition: Shape.hpp:45
+ +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/RenderStates_8hpp_source.html b/Space-Invaders/sfml/doc/html/RenderStates_8hpp_source.html new file mode 100644 index 000000000..922893f13 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/RenderStates_8hpp_source.html @@ -0,0 +1,189 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
RenderStates.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_RENDERSTATES_HPP
+
26#define SFML_RENDERSTATES_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/BlendMode.hpp>
+
33#include <SFML/Graphics/Transform.hpp>
+
34
+
35
+
36namespace sf
+
37{
+
38class Shader;
+
39class Texture;
+
40
+
45class SFML_GRAPHICS_API RenderStates
+
46{
+
47public:
+
48
+
61 RenderStates();
+
62
+
69 RenderStates(const BlendMode& theBlendMode);
+
70
+
77 RenderStates(const Transform& theTransform);
+
78
+
85 RenderStates(const Texture* theTexture);
+
86
+
93 RenderStates(const Shader* theShader);
+
94
+
104 RenderStates(const BlendMode& theBlendMode, const Transform& theTransform,
+
105 const Texture* theTexture, const Shader* theShader);
+
106
+
108 // Static member data
+
110 static const RenderStates Default;
+
111
+
113 // Member data
+
115 BlendMode blendMode;
+
116 Transform transform;
+
117 const Texture* texture;
+
118 const Shader* shader;
+
119};
+
120
+
121} // namespace sf
+
122
+
123
+
124#endif // SFML_RENDERSTATES_HPP
+
125
+
126
+
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderStates::transform
Transform transform
Transform.
Definition: RenderStates.hpp:116
+
sf::RenderStates::RenderStates
RenderStates(const Shader *theShader)
Construct a default set of render states with a custom shader.
+
sf::RenderStates::RenderStates
RenderStates(const Transform &theTransform)
Construct a default set of render states with a custom transform.
+
sf::RenderStates::texture
const Texture * texture
Texture.
Definition: RenderStates.hpp:117
+
sf::RenderStates::RenderStates
RenderStates()
Default constructor.
+
sf::RenderStates::RenderStates
RenderStates(const Texture *theTexture)
Construct a default set of render states with a custom texture.
+
sf::RenderStates::RenderStates
RenderStates(const BlendMode &theBlendMode, const Transform &theTransform, const Texture *theTexture, const Shader *theShader)
Construct a set of render states with all its attributes.
+
sf::RenderStates::RenderStates
RenderStates(const BlendMode &theBlendMode)
Construct a default set of render states with a custom blend mode.
+
sf::RenderStates::Default
static const RenderStates Default
Special instance holding the default render states.
Definition: RenderStates.hpp:110
+
sf::RenderStates::shader
const Shader * shader
Shader.
Definition: RenderStates.hpp:118
+
sf::RenderStates::blendMode
BlendMode blendMode
Blending mode.
Definition: RenderStates.hpp:115
+
sf::Shader
Shader class (vertex, geometry and fragment)
Definition: Shader.hpp:53
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Transform
Define a 3x3 transform matrix.
Definition: Transform.hpp:43
+
sf::BlendMode
Blending modes for drawing.
Definition: BlendMode.hpp:42
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/RenderTarget_8hpp_source.html b/Space-Invaders/sfml/doc/html/RenderTarget_8hpp_source.html new file mode 100644 index 000000000..08bc25d8f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/RenderTarget_8hpp_source.html @@ -0,0 +1,280 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
RenderTarget.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_RENDERTARGET_HPP
+
26#define SFML_RENDERTARGET_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Color.hpp>
+
33#include <SFML/Graphics/Rect.hpp>
+
34#include <SFML/Graphics/View.hpp>
+
35#include <SFML/Graphics/Transform.hpp>
+
36#include <SFML/Graphics/BlendMode.hpp>
+
37#include <SFML/Graphics/RenderStates.hpp>
+
38#include <SFML/Graphics/PrimitiveType.hpp>
+
39#include <SFML/Graphics/Vertex.hpp>
+
40#include <SFML/System/NonCopyable.hpp>
+
41
+
42
+
43namespace sf
+
44{
+
45class Drawable;
+
46class VertexBuffer;
+
47
+
52class SFML_GRAPHICS_API RenderTarget : NonCopyable
+
53{
+
54public:
+
55
+
60 virtual ~RenderTarget();
+
61
+
71 void clear(const Color& color = Color(0, 0, 0, 255));
+
72
+
92 void setView(const View& view);
+
93
+
102 const View& getView() const;
+
103
+
115 const View& getDefaultView() const;
+
116
+
130 IntRect getViewport(const View& view) const;
+
131
+
150 Vector2f mapPixelToCoords(const Vector2i& point) const;
+
151
+
181 Vector2f mapPixelToCoords(const Vector2i& point, const View& view) const;
+
182
+
201 Vector2i mapCoordsToPixel(const Vector2f& point) const;
+
202
+
228 Vector2i mapCoordsToPixel(const Vector2f& point, const View& view) const;
+
229
+
237 void draw(const Drawable& drawable, const RenderStates& states = RenderStates::Default);
+
238
+
248 void draw(const Vertex* vertices, std::size_t vertexCount,
+
249 PrimitiveType type, const RenderStates& states = RenderStates::Default);
+
250
+
258 void draw(const VertexBuffer& vertexBuffer, const RenderStates& states = RenderStates::Default);
+
259
+
269 void draw(const VertexBuffer& vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates& states = RenderStates::Default);
+
270
+
277 virtual Vector2u getSize() const = 0;
+
278
+
285 virtual bool isSrgb() const;
+
286
+
307 virtual bool setActive(bool active = true);
+
308
+
341 void pushGLStates();
+
342
+
352 void popGLStates();
+
353
+
375 void resetGLStates();
+
376
+
377protected:
+
378
+
383 RenderTarget();
+
384
+
392 void initialize();
+
393
+
394private:
+
395
+
400 void applyCurrentView();
+
401
+
408 void applyBlendMode(const BlendMode& mode);
+
409
+
416 void applyTransform(const Transform& transform);
+
417
+
424 void applyTexture(const Texture* texture);
+
425
+
432 void applyShader(const Shader* shader);
+
433
+
441 void setupDraw(bool useVertexCache, const RenderStates& states);
+
442
+
451 void drawPrimitives(PrimitiveType type, std::size_t firstVertex, std::size_t vertexCount);
+
452
+
459 void cleanupDraw(const RenderStates& states);
+
460
+
465 struct StatesCache
+
466 {
+
467 enum {VertexCacheSize = 4};
+
468
+
469 bool enable;
+
470 bool glStatesSet;
+
471 bool viewChanged;
+
472 BlendMode lastBlendMode;
+
473 Uint64 lastTextureId;
+
474 bool texCoordsArrayEnabled;
+
475 bool useVertexCache;
+
476 Vertex vertexCache[VertexCacheSize];
+
477 };
+
478
+
480 // Member data
+
482 View m_defaultView;
+
483 View m_view;
+
484 StatesCache m_cache;
+
485 Uint64 m_id;
+
486};
+
487
+
488} // namespace sf
+
489
+
490
+
491#endif // SFML_RENDERTARGET_HPP
+
492
+
493
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+
sf::Drawable
Abstract base class for objects that can be drawn to a render target.
Definition: Drawable.hpp:45
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+ +
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::RenderTarget::mapPixelToCoords
Vector2f mapPixelToCoords(const Vector2i &point) const
Convert a point from target coordinates to world coordinates, using the current view.
+
sf::RenderTarget::setView
void setView(const View &view)
Change the current active view.
+
sf::RenderTarget::draw
void draw(const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default)
Draw primitives defined by a vertex buffer.
+
sf::RenderTarget::draw
void draw(const Drawable &drawable, const RenderStates &states=RenderStates::Default)
Draw a drawable object to the render target.
+
sf::RenderTarget::RenderTarget
RenderTarget()
Default constructor.
+
sf::RenderTarget::mapPixelToCoords
Vector2f mapPixelToCoords(const Vector2i &point, const View &view) const
Convert a point from target coordinates to world coordinates.
+
sf::RenderTarget::getSize
virtual Vector2u getSize() const =0
Return the size of the rendering region of the target.
+
sf::RenderTarget::draw
void draw(const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default)
Draw primitives defined by a vertex buffer.
+
sf::RenderTarget::clear
void clear(const Color &color=Color(0, 0, 0, 255))
Clear the entire target with a single color.
+
sf::RenderTarget::getDefaultView
const View & getDefaultView() const
Get the default view of the render target.
+
sf::RenderTarget::mapCoordsToPixel
Vector2i mapCoordsToPixel(const Vector2f &point, const View &view) const
Convert a point from world coordinates to target coordinates.
+
sf::RenderTarget::getViewport
IntRect getViewport(const View &view) const
Get the viewport of a view, applied to this render target.
+
sf::RenderTarget::pushGLStates
void pushGLStates()
Save the current OpenGL render states and matrices.
+
sf::RenderTarget::draw
void draw(const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default)
Draw primitives defined by an array of vertices.
+
sf::RenderTarget::~RenderTarget
virtual ~RenderTarget()
Destructor.
+
sf::RenderTarget::resetGLStates
void resetGLStates()
Reset the internal OpenGL states so that the target is ready for drawing.
+
sf::RenderTarget::popGLStates
void popGLStates()
Restore the previously saved OpenGL render states and matrices.
+
sf::RenderTarget::mapCoordsToPixel
Vector2i mapCoordsToPixel(const Vector2f &point) const
Convert a point from world coordinates to target coordinates, using the current view.
+
sf::RenderTarget::getView
const View & getView() const
Get the view currently in use in the render target.
+
sf::RenderTarget::setActive
virtual bool setActive(bool active=true)
Activate or deactivate the render target for rendering.
+
sf::RenderTarget::isSrgb
virtual bool isSrgb() const
Tell if the render target will use sRGB encoding when drawing on it.
+
sf::RenderTarget::initialize
void initialize()
Performs the common initialization step after creation.
+
sf::Shader
Shader class (vertex, geometry and fragment)
Definition: Shader.hpp:53
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Transform
Define a 3x3 transform matrix.
Definition: Transform.hpp:43
+ +
sf::VertexBuffer
Vertex buffer storage for one or more 2D primitives.
Definition: VertexBuffer.hpp:47
+
sf::Vertex
Define a point with color and texture coordinates.
Definition: Vertex.hpp:43
+
sf::View
2D camera that defines what region is shown on screen
Definition: View.hpp:44
+
sf::PrimitiveType
PrimitiveType
Types of primitives that a sf::VertexArray can render.
Definition: PrimitiveType.hpp:40
+
sf::BlendMode
Blending modes for drawing.
Definition: BlendMode.hpp:42
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/RenderTexture_8hpp_source.html b/Space-Invaders/sfml/doc/html/RenderTexture_8hpp_source.html new file mode 100644 index 000000000..03f275cf2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/RenderTexture_8hpp_source.html @@ -0,0 +1,211 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
RenderTexture.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_RENDERTEXTURE_HPP
+
26#define SFML_RENDERTEXTURE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Texture.hpp>
+
33#include <SFML/Graphics/RenderTarget.hpp>
+
34#include <SFML/Window/ContextSettings.hpp>
+
35
+
36
+
37namespace sf
+
38{
+
39namespace priv
+
40{
+
41 class RenderTextureImpl;
+
42}
+
43
+
48class SFML_GRAPHICS_API RenderTexture : public RenderTarget
+
49{
+
50public:
+
51
+
61 RenderTexture();
+
62
+
67 virtual ~RenderTexture();
+
68
+
89 SFML_DEPRECATED bool create(unsigned int width, unsigned int height, bool depthBuffer);
+
90
+
109 bool create(unsigned int width, unsigned int height, const ContextSettings& settings = ContextSettings());
+
110
+
117 static unsigned int getMaximumAntialiasingLevel();
+
118
+
130 void setSmooth(bool smooth);
+
131
+
140 bool isSmooth() const;
+
141
+
153 void setRepeated(bool repeated);
+
154
+
163 bool isRepeated() const;
+
164
+
179 bool generateMipmap();
+
180
+
196 bool setActive(bool active = true);
+
197
+
207 void display();
+
208
+
218 virtual Vector2u getSize() const;
+
219
+
220
+
230 virtual bool isSrgb() const;
+
231
+
246 const Texture& getTexture() const;
+
247
+
248private:
+
249
+
251 // Member data
+
253 priv::RenderTextureImpl* m_impl;
+
254 Texture m_texture;
+
255};
+
256
+
257} // namespace sf
+
258
+
259
+
260#endif // SFML_RENDERTEXTURE_HPP
+
261
+
262
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::RenderTexture
Target for off-screen 2D rendering into a texture.
Definition: RenderTexture.hpp:49
+
sf::RenderTexture::create
bool create(unsigned int width, unsigned int height, bool depthBuffer)
Create the render-texture.
+
sf::RenderTexture::RenderTexture
RenderTexture()
Default constructor.
+
sf::RenderTexture::create
bool create(unsigned int width, unsigned int height, const ContextSettings &settings=ContextSettings())
Create the render-texture.
+
sf::RenderTexture::isSmooth
bool isSmooth() const
Tell whether the smooth filtering is enabled or not.
+
sf::RenderTexture::setActive
bool setActive(bool active=true)
Activate or deactivate the render-texture for rendering.
+
sf::RenderTexture::getTexture
const Texture & getTexture() const
Get a read-only reference to the target texture.
+
sf::RenderTexture::getSize
virtual Vector2u getSize() const
Return the size of the rendering region of the texture.
+
sf::RenderTexture::isRepeated
bool isRepeated() const
Tell whether the texture is repeated or not.
+
sf::RenderTexture::generateMipmap
bool generateMipmap()
Generate a mipmap using the current texture data.
+
sf::RenderTexture::~RenderTexture
virtual ~RenderTexture()
Destructor.
+
sf::RenderTexture::isSrgb
virtual bool isSrgb() const
Tell if the render-texture will use sRGB encoding when drawing on it.
+
sf::RenderTexture::getMaximumAntialiasingLevel
static unsigned int getMaximumAntialiasingLevel()
Get the maximum anti-aliasing level supported by the system.
+
sf::RenderTexture::setSmooth
void setSmooth(bool smooth)
Enable or disable texture smoothing.
+
sf::RenderTexture::setRepeated
void setRepeated(bool repeated)
Enable or disable texture repeating.
+
sf::RenderTexture::display
void display()
Update the contents of the target texture.
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+ +
sf::ContextSettings
Structure defining the settings of the OpenGL context attached to a window.
Definition: ContextSettings.hpp:38
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/RenderWindow_8hpp_source.html b/Space-Invaders/sfml/doc/html/RenderWindow_8hpp_source.html new file mode 100644 index 000000000..ce88d4720 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/RenderWindow_8hpp_source.html @@ -0,0 +1,197 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
RenderWindow.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_RENDERWINDOW_HPP
+
26#define SFML_RENDERWINDOW_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/RenderTarget.hpp>
+
33#include <SFML/Graphics/Image.hpp>
+
34#include <SFML/Window/Window.hpp>
+
35#include <string>
+
36
+
37
+
38namespace sf
+
39{
+
44class SFML_GRAPHICS_API RenderWindow : public Window, public RenderTarget
+
45{
+
46public:
+
47
+
55 RenderWindow();
+
56
+
76 RenderWindow(VideoMode mode, const String& title, Uint32 style = Style::Default, const ContextSettings& settings = ContextSettings());
+
77
+
94 explicit RenderWindow(WindowHandle handle, const ContextSettings& settings = ContextSettings());
+
95
+
102 virtual ~RenderWindow();
+
103
+
113 virtual Vector2u getSize() const;
+
114
+
115
+
124 virtual bool isSrgb() const;
+
125
+
142 bool setActive(bool active = true);
+
143
+
169 SFML_DEPRECATED Image capture() const;
+
170
+
171protected:
+
172
+
181 virtual void onCreate();
+
182
+
190 virtual void onResize();
+
191
+
192private:
+
193
+
195 // Member data
+
197 unsigned int m_defaultFrameBuffer;
+
198};
+
199
+
200} // namespace sf
+
201
+
202
+
203#endif // SFML_RENDERWINDOW_HPP
+
204
+
205
+
sf::Image
Class for loading, manipulating and saving images.
Definition: Image.hpp:47
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::RenderWindow
Window that can serve as a target for 2D drawing.
Definition: RenderWindow.hpp:45
+
sf::RenderWindow::RenderWindow
RenderWindow(WindowHandle handle, const ContextSettings &settings=ContextSettings())
Construct the window from an existing control.
+
sf::RenderWindow::~RenderWindow
virtual ~RenderWindow()
Destructor.
+
sf::RenderWindow::capture
Image capture() const
Copy the current contents of the window to an image.
+
sf::RenderWindow::onCreate
virtual void onCreate()
Function called after the window has been created.
+
sf::RenderWindow::onResize
virtual void onResize()
Function called after the window has been resized.
+
sf::RenderWindow::RenderWindow
RenderWindow()
Default constructor.
+
sf::RenderWindow::isSrgb
virtual bool isSrgb() const
Tell if the window will use sRGB encoding when drawing on it.
+
sf::RenderWindow::getSize
virtual Vector2u getSize() const
Get the size of the rendering region of the window.
+
sf::RenderWindow::RenderWindow
RenderWindow(VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())
Construct a new window.
+
sf::RenderWindow::setActive
bool setActive(bool active=true)
Activate or deactivate the window as the current target for OpenGL rendering.
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+ +
sf::VideoMode
VideoMode defines a video mode (width, height, bpp)
Definition: VideoMode.hpp:42
+
sf::Window
Window that serves as a target for OpenGL rendering.
Definition: Window/Window.hpp:50
+
sf::WindowHandle
platform specific WindowHandle
Define a low-level window handle type, specific to each platform.
Definition: WindowHandle.hpp:68
+
sf::ContextSettings
Structure defining the settings of the OpenGL context attached to a window.
Definition: ContextSettings.hpp:38
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Sensor_8hpp_source.html b/Space-Invaders/sfml/doc/html/Sensor_8hpp_source.html new file mode 100644 index 000000000..053c63dbc --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Sensor_8hpp_source.html @@ -0,0 +1,178 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Sensor.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SENSOR_HPP
+
26#define SFML_SENSOR_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32#include <SFML/System/Vector3.hpp>
+
33#include <SFML/System/Time.hpp>
+
34
+
35
+
36namespace sf
+
37{
+
42class SFML_WINDOW_API Sensor
+
43{
+
44public:
+
45
+
50 enum Type
+
51 {
+
52 Accelerometer,
+
53 Gyroscope,
+
54 Magnetometer,
+
55 Gravity,
+
56 UserAcceleration,
+
57 Orientation,
+
58
+
59 Count
+
60 };
+
61
+
70 static bool isAvailable(Type sensor);
+
71
+
85 static void setEnabled(Type sensor, bool enabled);
+
86
+
95 static Vector3f getValue(Type sensor);
+
96};
+
97
+
98} // namespace sf
+
99
+
100
+
101#endif // SFML_SENSOR_HPP
+
102
+
103
+
sf::Sensor
Give access to the real-time state of the sensors.
Definition: Sensor.hpp:43
+
sf::Sensor::Type
Type
Sensor type.
Definition: Sensor.hpp:51
+
sf::Sensor::Accelerometer
@ Accelerometer
Measures the raw acceleration (m/s^2)
Definition: Sensor.hpp:52
+
sf::Sensor::Gyroscope
@ Gyroscope
Measures the raw rotation rates (degrees/s)
Definition: Sensor.hpp:53
+
sf::Sensor::Orientation
@ Orientation
Measures the absolute 3D orientation (degrees)
Definition: Sensor.hpp:57
+
sf::Sensor::UserAcceleration
@ UserAcceleration
Measures the direction and intensity of device acceleration, independent of the gravity (m/s^2)
Definition: Sensor.hpp:56
+
sf::Sensor::Magnetometer
@ Magnetometer
Measures the ambient magnetic field (micro-teslas)
Definition: Sensor.hpp:54
+
sf::Sensor::Gravity
@ Gravity
Measures the direction and intensity of gravity, independent of device acceleration (m/s^2)
Definition: Sensor.hpp:55
+
sf::Sensor::isAvailable
static bool isAvailable(Type sensor)
Check if a sensor is available on the underlying platform.
+
sf::Sensor::getValue
static Vector3f getValue(Type sensor)
Get the current sensor value.
+
sf::Sensor::setEnabled
static void setEnabled(Type sensor, bool enabled)
Enable or disable a sensor.
+
sf::Vector3
Utility template class for manipulating 3-dimensional vectors.
Definition: Vector3.hpp:38
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Shader_8hpp_source.html b/Space-Invaders/sfml/doc/html/Shader_8hpp_source.html new file mode 100644 index 000000000..0c9bb73f5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Shader_8hpp_source.html @@ -0,0 +1,351 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Shader.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SHADER_HPP
+
26#define SFML_SHADER_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Glsl.hpp>
+
33#include <SFML/Window/GlResource.hpp>
+
34#include <SFML/System/NonCopyable.hpp>
+
35#include <SFML/System/Vector2.hpp>
+
36#include <SFML/System/Vector3.hpp>
+
37#include <map>
+
38#include <string>
+
39
+
40
+
41namespace sf
+
42{
+
43class Color;
+
44class InputStream;
+
45class Texture;
+
46class Transform;
+
47
+
52class SFML_GRAPHICS_API Shader : GlResource, NonCopyable
+
53{
+
54public:
+
55
+
60 enum Type
+
61 {
+
62 Vertex,
+
63 Geometry,
+
64 Fragment
+
65 };
+
66
+
74 struct CurrentTextureType {};
+
75
+
82 static CurrentTextureType CurrentTexture;
+
83
+
84public:
+
85
+
92 Shader();
+
93
+
98 ~Shader();
+
99
+
119 bool loadFromFile(const std::string& filename, Type type);
+
120
+
140 bool loadFromFile(const std::string& vertexShaderFilename, const std::string& fragmentShaderFilename);
+
141
+
162 bool loadFromFile(const std::string& vertexShaderFilename, const std::string& geometryShaderFilename, const std::string& fragmentShaderFilename);
+
163
+
182 bool loadFromMemory(const std::string& shader, Type type);
+
183
+
203 bool loadFromMemory(const std::string& vertexShader, const std::string& fragmentShader);
+
204
+
225 bool loadFromMemory(const std::string& vertexShader, const std::string& geometryShader, const std::string& fragmentShader);
+
226
+
245 bool loadFromStream(InputStream& stream, Type type);
+
246
+
266 bool loadFromStream(InputStream& vertexShaderStream, InputStream& fragmentShaderStream);
+
267
+
288 bool loadFromStream(InputStream& vertexShaderStream, InputStream& geometryShaderStream, InputStream& fragmentShaderStream);
+
289
+
297 void setUniform(const std::string& name, float x);
+
298
+
306 void setUniform(const std::string& name, const Glsl::Vec2& vector);
+
307
+
315 void setUniform(const std::string& name, const Glsl::Vec3& vector);
+
316
+
333 void setUniform(const std::string& name, const Glsl::Vec4& vector);
+
334
+
342 void setUniform(const std::string& name, int x);
+
343
+
351 void setUniform(const std::string& name, const Glsl::Ivec2& vector);
+
352
+
360 void setUniform(const std::string& name, const Glsl::Ivec3& vector);
+
361
+
377 void setUniform(const std::string& name, const Glsl::Ivec4& vector);
+
378
+
386 void setUniform(const std::string& name, bool x);
+
387
+
395 void setUniform(const std::string& name, const Glsl::Bvec2& vector);
+
396
+
404 void setUniform(const std::string& name, const Glsl::Bvec3& vector);
+
405
+
413 void setUniform(const std::string& name, const Glsl::Bvec4& vector);
+
414
+
422 void setUniform(const std::string& name, const Glsl::Mat3& matrix);
+
423
+
431 void setUniform(const std::string& name, const Glsl::Mat4& matrix);
+
432
+
463 void setUniform(const std::string& name, const Texture& texture);
+
464
+
486 void setUniform(const std::string& name, CurrentTextureType);
+
487
+
496 void setUniformArray(const std::string& name, const float* scalarArray, std::size_t length);
+
497
+
506 void setUniformArray(const std::string& name, const Glsl::Vec2* vectorArray, std::size_t length);
+
507
+
516 void setUniformArray(const std::string& name, const Glsl::Vec3* vectorArray, std::size_t length);
+
517
+
526 void setUniformArray(const std::string& name, const Glsl::Vec4* vectorArray, std::size_t length);
+
527
+
536 void setUniformArray(const std::string& name, const Glsl::Mat3* matrixArray, std::size_t length);
+
537
+
546 void setUniformArray(const std::string& name, const Glsl::Mat4* matrixArray, std::size_t length);
+
547
+
554 SFML_DEPRECATED void setParameter(const std::string& name, float x);
+
555
+
562 SFML_DEPRECATED void setParameter(const std::string& name, float x, float y);
+
563
+
570 SFML_DEPRECATED void setParameter(const std::string& name, float x, float y, float z);
+
571
+
578 SFML_DEPRECATED void setParameter(const std::string& name, float x, float y, float z, float w);
+
579
+
586 SFML_DEPRECATED void setParameter(const std::string& name, const Vector2f& vector);
+
587
+
594 SFML_DEPRECATED void setParameter(const std::string& name, const Vector3f& vector);
+
595
+
602 SFML_DEPRECATED void setParameter(const std::string& name, const Color& color);
+
603
+
610 SFML_DEPRECATED void setParameter(const std::string& name, const Transform& transform);
+
611
+
618 SFML_DEPRECATED void setParameter(const std::string& name, const Texture& texture);
+
619
+
626 SFML_DEPRECATED void setParameter(const std::string& name, CurrentTextureType);
+
627
+
638 unsigned int getNativeHandle() const;
+
639
+
661 static void bind(const Shader* shader);
+
662
+
673 static bool isAvailable();
+
674
+
692 static bool isGeometryAvailable();
+
693
+
694private:
+
695
+
709 bool compile(const char* vertexShaderCode, const char* geometryShaderCode, const char* fragmentShaderCode);
+
710
+
718 void bindTextures() const;
+
719
+
728 int getUniformLocation(const std::string& name);
+
729
+
737 struct UniformBinder;
+
738
+
740 // Types
+
742 typedef std::map<int, const Texture*> TextureTable;
+
743 typedef std::map<std::string, int> UniformTable;
+
744
+
746 // Member data
+
748 unsigned int m_shaderProgram;
+
749 int m_currentTexture;
+
750 TextureTable m_textures;
+
751 UniformTable m_uniforms;
+
752};
+
753
+
754} // namespace sf
+
755
+
756
+
757#endif // SFML_SHADER_HPP
+
758
+
759
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+
sf::GlResource
Base class for classes that require an OpenGL context.
Definition: GlResource.hpp:47
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::Shader
Shader class (vertex, geometry and fragment)
Definition: Shader.hpp:53
+
sf::Shader::loadFromFile
bool loadFromFile(const std::string &filename, Type type)
Load the vertex, geometry or fragment shader from a file.
+
sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const Glsl::Mat4 *matrixArray, std::size_t length)
Specify values for mat4[] array uniform.
+
sf::Shader::bind
static void bind(const Shader *shader)
Bind a shader for rendering.
+
sf::Shader::Shader
Shader()
Default constructor.
+
sf::Shader::loadFromFile
bool loadFromFile(const std::string &vertexShaderFilename, const std::string &geometryShaderFilename, const std::string &fragmentShaderFilename)
Load the vertex, geometry and fragment shaders from files.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Ivec2 &vector)
Specify value for ivec2 uniform.
+
sf::Shader::loadFromStream
bool loadFromStream(InputStream &stream, Type type)
Load the vertex, geometry or fragment shader from a custom stream.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Ivec4 &vector)
Specify value for ivec4 uniform.
+
sf::Shader::setParameter
void setParameter(const std::string &name, const Vector2f &vector)
Change a 2-components vector parameter of the shader.
+
sf::Shader::loadFromStream
bool loadFromStream(InputStream &vertexShaderStream, InputStream &fragmentShaderStream)
Load both the vertex and fragment shaders from custom streams.
+
sf::Shader::isGeometryAvailable
static bool isGeometryAvailable()
Tell whether or not the system supports geometry shaders.
+
sf::Shader::setParameter
void setParameter(const std::string &name, float x)
Change a float parameter of the shader.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Vec2 &vector)
Specify value for vec2 uniform.
+
sf::Shader::~Shader
~Shader()
Destructor.
+
sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const Glsl::Mat3 *matrixArray, std::size_t length)
Specify values for mat3[] array uniform.
+
sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const float *scalarArray, std::size_t length)
Specify values for float[] array uniform.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Texture &texture)
Specify a texture as sampler2D uniform.
+
sf::Shader::setParameter
void setParameter(const std::string &name, float x, float y, float z)
Change a 3-components vector parameter of the shader.
+
sf::Shader::setParameter
void setParameter(const std::string &name, const Texture &texture)
Change a texture parameter of the shader.
+
sf::Shader::setParameter
void setParameter(const std::string &name, const Transform &transform)
Change a matrix parameter of the shader.
+
sf::Shader::setParameter
void setParameter(const std::string &name, const Vector3f &vector)
Change a 3-components vector parameter of the shader.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Ivec3 &vector)
Specify value for ivec3 uniform.
+
sf::Shader::loadFromStream
bool loadFromStream(InputStream &vertexShaderStream, InputStream &geometryShaderStream, InputStream &fragmentShaderStream)
Load the vertex, geometry and fragment shaders from custom streams.
+
sf::Shader::setParameter
void setParameter(const std::string &name, const Color &color)
Change a color parameter of the shader.
+
sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const Glsl::Vec4 *vectorArray, std::size_t length)
Specify values for vec4[] array uniform.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Vec3 &vector)
Specify value for vec3 uniform.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Bvec3 &vector)
Specify value for bvec3 uniform.
+
sf::Shader::setUniform
void setUniform(const std::string &name, CurrentTextureType)
Specify current texture as sampler2D uniform.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Bvec2 &vector)
Specify value for bvec2 uniform.
+
sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const Glsl::Vec2 *vectorArray, std::size_t length)
Specify values for vec2[] array uniform.
+
sf::Shader::loadFromMemory
bool loadFromMemory(const std::string &vertexShader, const std::string &geometryShader, const std::string &fragmentShader)
Load the vertex, geometry and fragment shaders from source codes in memory.
+
sf::Shader::setParameter
void setParameter(const std::string &name, float x, float y)
Change a 2-components vector parameter of the shader.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Vec4 &vector)
Specify value for vec4 uniform.
+
sf::Shader::setUniform
void setUniform(const std::string &name, float x)
Specify value for float uniform.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Mat3 &matrix)
Specify value for mat3 matrix.
+
sf::Shader::getNativeHandle
unsigned int getNativeHandle() const
Get the underlying OpenGL handle of the shader.
+
sf::Shader::CurrentTexture
static CurrentTextureType CurrentTexture
Represents the texture of the object being drawn.
Definition: Shader.hpp:82
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Bvec4 &vector)
Specify value for bvec4 uniform.
+
sf::Shader::loadFromMemory
bool loadFromMemory(const std::string &shader, Type type)
Load the vertex, geometry or fragment shader from a source code in memory.
+
sf::Shader::loadFromFile
bool loadFromFile(const std::string &vertexShaderFilename, const std::string &fragmentShaderFilename)
Load both the vertex and fragment shaders from files.
+
sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Mat4 &matrix)
Specify value for mat4 matrix.
+
sf::Shader::isAvailable
static bool isAvailable()
Tell whether or not the system supports shaders.
+
sf::Shader::loadFromMemory
bool loadFromMemory(const std::string &vertexShader, const std::string &fragmentShader)
Load both the vertex and fragment shaders from source codes in memory.
+
sf::Shader::setUniform
void setUniform(const std::string &name, int x)
Specify value for int uniform.
+
sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const Glsl::Vec3 *vectorArray, std::size_t length)
Specify values for vec3[] array uniform.
+
sf::Shader::setParameter
void setParameter(const std::string &name, float x, float y, float z, float w)
Change a 4-components vector parameter of the shader.
+
sf::Shader::setParameter
void setParameter(const std::string &name, CurrentTextureType)
Change a texture parameter of the shader.
+
sf::Shader::setUniform
void setUniform(const std::string &name, bool x)
Specify value for bool uniform.
+
sf::Shader::Type
Type
Types of shaders.
Definition: Shader.hpp:61
+
sf::Shader::Geometry
@ Geometry
Geometry shader.
Definition: Shader.hpp:63
+
sf::Shader::Vertex
@ Vertex
Vertex shader
Definition: Shader.hpp:62
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Transform
Define a 3x3 transform matrix.
Definition: Transform.hpp:43
+ +
sf::Vector3
Utility template class for manipulating 3-dimensional vectors.
Definition: Vector3.hpp:38
+
sf::Glsl::Mat4
implementation defined Mat4
4x4 float matrix (mat4 in GLSL)
Definition: Glsl.hpp:181
+
sf::Glsl::Ivec4
implementation defined Ivec4
4D int vector (ivec4 in GLSL)
Definition: Glsl.hpp:124
+
sf::Glsl::Vec4
implementation defined Vec4
4D float vector (vec4 in GLSL)
Definition: Glsl.hpp:110
+
sf::Glsl::Bvec4
implementation defined Bvec4
4D bool vector (bvec4 in GLSL)
Definition: Glsl.hpp:130
+
sf::Glsl::Mat3
implementation defined Mat3
3x3 float matrix (mat3 in GLSL)
Definition: Glsl.hpp:155
+
sf::Shader::CurrentTextureType
Special type that can be passed to setUniform(), and that represents the texture of the object being ...
Definition: Shader.hpp:74
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Shape_8hpp_source.html b/Space-Invaders/sfml/doc/html/Shape_8hpp_source.html new file mode 100644 index 000000000..e74e9ba10 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Shape_8hpp_source.html @@ -0,0 +1,238 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Shape.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SHAPE_HPP
+
26#define SFML_SHAPE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Drawable.hpp>
+
33#include <SFML/Graphics/Transformable.hpp>
+
34#include <SFML/Graphics/VertexArray.hpp>
+
35#include <SFML/System/Vector2.hpp>
+
36
+
37
+
38namespace sf
+
39{
+
44class SFML_GRAPHICS_API Shape : public Drawable, public Transformable
+
45{
+
46public:
+
47
+
52 virtual ~Shape();
+
53
+
74 void setTexture(const Texture* texture, bool resetRect = false);
+
75
+
88 void setTextureRect(const IntRect& rect);
+
89
+
105 void setFillColor(const Color& color);
+
106
+
117 void setOutlineColor(const Color& color);
+
118
+
132 void setOutlineThickness(float thickness);
+
133
+
146 const Texture* getTexture() const;
+
147
+
156 const IntRect& getTextureRect() const;
+
157
+
166 const Color& getFillColor() const;
+
167
+
176 const Color& getOutlineColor() const;
+
177
+
186 float getOutlineThickness() const;
+
187
+
196 virtual std::size_t getPointCount() const = 0;
+
197
+
213 virtual Vector2f getPoint(std::size_t index) const = 0;
+
214
+
227 FloatRect getLocalBounds() const;
+
228
+
248 FloatRect getGlobalBounds() const;
+
249
+
250protected:
+
251
+
256 Shape();
+
257
+
266 void update();
+
267
+
268private:
+
269
+
277 virtual void draw(RenderTarget& target, RenderStates states) const;
+
278
+
283 void updateFillColors();
+
284
+
289 void updateTexCoords();
+
290
+
295 void updateOutline();
+
296
+
301 void updateOutlineColors();
+
302
+
303private:
+
304
+
306 // Member data
+
308 const Texture* m_texture;
+
309 IntRect m_textureRect;
+
310 Color m_fillColor;
+
311 Color m_outlineColor;
+
312 float m_outlineThickness;
+
313 VertexArray m_vertices;
+
314 VertexArray m_outlineVertices;
+
315 FloatRect m_insideBounds;
+
316 FloatRect m_bounds;
+
317};
+
318
+
319} // namespace sf
+
320
+
321
+
322#endif // SFML_SHAPE_HPP
+
323
+
324
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+
sf::Drawable
Abstract base class for objects that can be drawn to a render target.
Definition: Drawable.hpp:45
+ +
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::Shape
Base class for textured shapes with outline.
Definition: Shape.hpp:45
+
sf::Shape::getOutlineThickness
float getOutlineThickness() const
Get the outline thickness of the shape.
+
sf::Shape::setTextureRect
void setTextureRect(const IntRect &rect)
Set the sub-rectangle of the texture that the shape will display.
+
sf::Shape::~Shape
virtual ~Shape()
Virtual destructor.
+
sf::Shape::setFillColor
void setFillColor(const Color &color)
Set the fill color of the shape.
+
sf::Shape::getPoint
virtual Vector2f getPoint(std::size_t index) const =0
Get a point of the shape.
+
sf::Shape::Shape
Shape()
Default constructor.
+
sf::Shape::getOutlineColor
const Color & getOutlineColor() const
Get the outline color of the shape.
+
sf::Shape::setOutlineColor
void setOutlineColor(const Color &color)
Set the outline color of the shape.
+
sf::Shape::setOutlineThickness
void setOutlineThickness(float thickness)
Set the thickness of the shape's outline.
+
sf::Shape::getFillColor
const Color & getFillColor() const
Get the fill color of the shape.
+
sf::Shape::getGlobalBounds
FloatRect getGlobalBounds() const
Get the global (non-minimal) bounding rectangle of the entity.
+
sf::Shape::getTextureRect
const IntRect & getTextureRect() const
Get the sub-rectangle of the texture displayed by the shape.
+
sf::Shape::update
void update()
Recompute the internal geometry of the shape.
+
sf::Shape::getLocalBounds
FloatRect getLocalBounds() const
Get the local bounding rectangle of the entity.
+
sf::Shape::getTexture
const Texture * getTexture() const
Get the source texture of the shape.
+
sf::Shape::setTexture
void setTexture(const Texture *texture, bool resetRect=false)
Change the source texture of the shape.
+
sf::Shape::getPointCount
virtual std::size_t getPointCount() const =0
Get the total number of points of the shape.
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Transformable
Decomposed transform defined by a position, a rotation and a scale.
Definition: Transformable.hpp:42
+ +
sf::VertexArray
Define a set of one or more 2D primitives.
Definition: VertexArray.hpp:46
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Sleep_8hpp_source.html b/Space-Invaders/sfml/doc/html/Sleep_8hpp_source.html new file mode 100644 index 000000000..f6b4a0c0f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Sleep_8hpp_source.html @@ -0,0 +1,144 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Sleep.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SLEEP_HPP
+
26#define SFML_SLEEP_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Export.hpp>
+
32#include <SFML/System/Time.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
47void SFML_SYSTEM_API sleep(Time duration);
+
48
+
49} // namespace sf
+
50
+
51
+
52#endif // SFML_SLEEP_HPP
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
sf::sleep
void sleep(Time duration)
Make the current thread sleep for a given duration.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/SocketHandle_8hpp_source.html b/Space-Invaders/sfml/doc/html/SocketHandle_8hpp_source.html new file mode 100644 index 000000000..4b9f00648 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/SocketHandle_8hpp_source.html @@ -0,0 +1,155 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SocketHandle.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOCKETHANDLE_HPP
+
26#define SFML_SOCKETHANDLE_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32
+
33#if defined(SFML_SYSTEM_WINDOWS)
+
34 #include <basetsd.h>
+
35#endif
+
36
+
37
+
38namespace sf
+
39{
+
41// Define the low-level socket handle type, specific to
+
42// each platform
+
44#if defined(SFML_SYSTEM_WINDOWS)
+
45
+
46 typedef UINT_PTR SocketHandle;
+
47
+
48#else
+
49
+
50 typedef int SocketHandle;
+
51
+
52#endif
+
53
+
54} // namespace sf
+
55
+
56
+
57#endif // SFML_SOCKETHANDLE_HPP
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/SocketSelector_8hpp_source.html b/Space-Invaders/sfml/doc/html/SocketSelector_8hpp_source.html new file mode 100644 index 000000000..2a21cb4fb --- /dev/null +++ b/Space-Invaders/sfml/doc/html/SocketSelector_8hpp_source.html @@ -0,0 +1,185 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SocketSelector.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOCKETSELECTOR_HPP
+
26#define SFML_SOCKETSELECTOR_HPP
+
27
+
29// Headers
+
31#include <SFML/Network/Export.hpp>
+
32#include <SFML/System/Time.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
37class Socket;
+
38
+
43class SFML_NETWORK_API SocketSelector
+
44{
+
45public:
+
46
+
51 SocketSelector();
+
52
+
59 SocketSelector(const SocketSelector& copy);
+
60
+
65 ~SocketSelector();
+
66
+
80 void add(Socket& socket);
+
81
+
93 void remove(Socket& socket);
+
94
+
105 void clear();
+
106
+
123 bool wait(Time timeout = Time::Zero);
+
124
+
142 bool isReady(Socket& socket) const;
+
143
+
152 SocketSelector& operator =(const SocketSelector& right);
+
153
+
154private:
+
155
+
156 struct SocketSelectorImpl;
+
157
+
159 // Member data
+
161 SocketSelectorImpl* m_impl;
+
162};
+
163
+
164} // namespace sf
+
165
+
166
+
167#endif // SFML_SOCKETSELECTOR_HPP
+
168
+
169
+
sf::SocketSelector
Multiplexer that allows to read from multiple sockets.
Definition: SocketSelector.hpp:44
+
sf::SocketSelector::SocketSelector
SocketSelector(const SocketSelector &copy)
Copy constructor.
+
sf::SocketSelector::SocketSelector
SocketSelector()
Default constructor.
+
sf::SocketSelector::clear
void clear()
Remove all the sockets stored in the selector.
+
sf::SocketSelector::~SocketSelector
~SocketSelector()
Destructor.
+
sf::SocketSelector::isReady
bool isReady(Socket &socket) const
Test a socket to know if it is ready to receive data.
+
sf::SocketSelector::remove
void remove(Socket &socket)
Remove a socket from the selector.
+
sf::SocketSelector::wait
bool wait(Time timeout=Time::Zero)
Wait until one or more sockets are ready to receive.
+
sf::SocketSelector::add
void add(Socket &socket)
Add a new socket to the selector.
+
sf::Socket
Base class for all the socket types.
Definition: Socket.hpp:46
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Socket_8hpp_source.html b/Space-Invaders/sfml/doc/html/Socket_8hpp_source.html new file mode 100644 index 000000000..4d7a8f635 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Socket_8hpp_source.html @@ -0,0 +1,218 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Socket.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOCKET_HPP
+
26#define SFML_SOCKET_HPP
+
27
+
29// Headers
+
31#include <SFML/Network/Export.hpp>
+
32#include <SFML/Network/SocketHandle.hpp>
+
33#include <SFML/System/NonCopyable.hpp>
+
34#include <vector>
+
35
+
36
+
37namespace sf
+
38{
+
39class SocketSelector;
+
40
+
45class SFML_NETWORK_API Socket : NonCopyable
+
46{
+
47public:
+
48
+
53 enum Status
+
54 {
+
55 Done,
+
56 NotReady,
+
57 Partial,
+
58 Disconnected,
+
59 Error
+
60 };
+
61
+
66 enum
+
67 {
+
68 AnyPort = 0
+
69 };
+
70
+
71public:
+
72
+
77 virtual ~Socket();
+
78
+
96 void setBlocking(bool blocking);
+
97
+
106 bool isBlocking() const;
+
107
+
108protected:
+
109
+
114 enum Type
+
115 {
+
116 Tcp,
+
117 Udp
+
118 };
+
119
+
128 Socket(Type type);
+
129
+
140 SocketHandle getHandle() const;
+
141
+
148 void create();
+
149
+
159 void create(SocketHandle handle);
+
160
+
167 void close();
+
168
+
169private:
+
170
+
171 friend class SocketSelector;
+
172
+
174 // Member data
+
176 Type m_type;
+
177 SocketHandle m_socket;
+
178 bool m_isBlocking;
+
179};
+
180
+
181} // namespace sf
+
182
+
183
+
184#endif // SFML_SOCKET_HPP
+
185
+
186
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::SocketSelector
Multiplexer that allows to read from multiple sockets.
Definition: SocketSelector.hpp:44
+
sf::Socket
Base class for all the socket types.
Definition: Socket.hpp:46
+
sf::Socket::setBlocking
void setBlocking(bool blocking)
Set the blocking state of the socket.
+
sf::Socket::Status
Status
Status codes that may be returned by socket functions.
Definition: Socket.hpp:54
+
sf::Socket::Partial
@ Partial
The socket sent a part of the data.
Definition: Socket.hpp:57
+
sf::Socket::Done
@ Done
The socket has sent / received the data.
Definition: Socket.hpp:55
+
sf::Socket::NotReady
@ NotReady
The socket is not ready to send / receive data yet.
Definition: Socket.hpp:56
+
sf::Socket::Disconnected
@ Disconnected
The TCP socket has been disconnected.
Definition: Socket.hpp:58
+
sf::Socket::Type
Type
Types of protocols that the socket can use.
Definition: Socket.hpp:115
+
sf::Socket::Tcp
@ Tcp
TCP protocol.
Definition: Socket.hpp:116
+
sf::Socket::getHandle
SocketHandle getHandle() const
Return the internal handle of the socket.
+
sf::Socket::close
void close()
Close the socket gracefully.
+
sf::Socket::~Socket
virtual ~Socket()
Destructor.
+
sf::Socket::Socket
Socket(Type type)
Default constructor.
+
sf::Socket::create
void create()
Create the internal representation of the socket.
+
sf::Socket::isBlocking
bool isBlocking() const
Tell whether the socket is in blocking or non-blocking mode.
+
sf::Socket::create
void create(SocketHandle handle)
Create the internal representation of the socket from a socket handle.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/SoundBufferRecorder_8hpp_source.html b/Space-Invaders/sfml/doc/html/SoundBufferRecorder_8hpp_source.html new file mode 100644 index 000000000..3ea8c68e0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/SoundBufferRecorder_8hpp_source.html @@ -0,0 +1,174 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SoundBufferRecorder.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOUNDBUFFERRECORDER_HPP
+
26#define SFML_SOUNDBUFFERRECORDER_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <SFML/Audio/SoundBuffer.hpp>
+
33#include <SFML/Audio/SoundRecorder.hpp>
+
34#include <vector>
+
35
+
36
+
37namespace sf
+
38{
+
44class SFML_AUDIO_API SoundBufferRecorder : public SoundRecorder
+
45{
+
46public:
+
47
+
52 ~SoundBufferRecorder();
+
53
+
65 const SoundBuffer& getBuffer() const;
+
66
+
67protected:
+
68
+
75 virtual bool onStart();
+
76
+
86 virtual bool onProcessSamples(const Int16* samples, std::size_t sampleCount);
+
87
+
92 virtual void onStop();
+
93
+
94private:
+
95
+
97 // Member data
+
99 std::vector<Int16> m_samples;
+
100 SoundBuffer m_buffer;
+
101};
+
102
+
103} // namespace sf
+
104
+
105#endif // SFML_SOUNDBUFFERRECORDER_HPP
+
106
+
107
+
sf::SoundBufferRecorder
Specialized SoundRecorder which stores the captured audio data into a sound buffer.
Definition: SoundBufferRecorder.hpp:45
+
sf::SoundBufferRecorder::getBuffer
const SoundBuffer & getBuffer() const
Get the sound buffer containing the captured audio data.
+
sf::SoundBufferRecorder::~SoundBufferRecorder
~SoundBufferRecorder()
destructor
+
sf::SoundBufferRecorder::onStart
virtual bool onStart()
Start capturing audio data.
+
sf::SoundBufferRecorder::onProcessSamples
virtual bool onProcessSamples(const Int16 *samples, std::size_t sampleCount)
Process a new chunk of recorded samples.
+
sf::SoundBufferRecorder::onStop
virtual void onStop()
Stop capturing audio data.
+
sf::SoundBuffer
Storage for audio samples defining a sound.
Definition: SoundBuffer.hpp:50
+
sf::SoundRecorder
Abstract base class for capturing sound data.
Definition: SoundRecorder.hpp:46
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/SoundBuffer_8hpp_source.html b/Space-Invaders/sfml/doc/html/SoundBuffer_8hpp_source.html new file mode 100644 index 000000000..f7ae5d6f3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/SoundBuffer_8hpp_source.html @@ -0,0 +1,223 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SoundBuffer.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOUNDBUFFER_HPP
+
26#define SFML_SOUNDBUFFER_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <SFML/Audio/AlResource.hpp>
+
33#include <SFML/System/Time.hpp>
+
34#include <string>
+
35#include <vector>
+
36#include <set>
+
37
+
38
+
39namespace sf
+
40{
+
41class Sound;
+
42class InputSoundFile;
+
43class InputStream;
+
44
+
49class SFML_AUDIO_API SoundBuffer : AlResource
+
50{
+
51public:
+
52
+
57 SoundBuffer();
+
58
+
65 SoundBuffer(const SoundBuffer& copy);
+
66
+
71 ~SoundBuffer();
+
72
+
86 bool loadFromFile(const std::string& filename);
+
87
+
102 bool loadFromMemory(const void* data, std::size_t sizeInBytes);
+
103
+
117 bool loadFromStream(InputStream& stream);
+
118
+
135 bool loadFromSamples(const Int16* samples, Uint64 sampleCount, unsigned int channelCount, unsigned int sampleRate);
+
136
+
150 bool saveToFile(const std::string& filename) const;
+
151
+
164 const Int16* getSamples() const;
+
165
+
177 Uint64 getSampleCount() const;
+
178
+
191 unsigned int getSampleRate() const;
+
192
+
204 unsigned int getChannelCount() const;
+
205
+
214 Time getDuration() const;
+
215
+
224 SoundBuffer& operator =(const SoundBuffer& right);
+
225
+
226private:
+
227
+
228 friend class Sound;
+
229
+
238 bool initialize(InputSoundFile& file);
+
239
+
249 bool update(unsigned int channelCount, unsigned int sampleRate);
+
250
+
257 void attachSound(Sound* sound) const;
+
258
+
265 void detachSound(Sound* sound) const;
+
266
+
268 // Types
+
270 typedef std::set<Sound*> SoundList;
+
271
+
273 // Member data
+
275 unsigned int m_buffer;
+
276 std::vector<Int16> m_samples;
+
277 Time m_duration;
+
278 mutable SoundList m_sounds;
+
279};
+
280
+
281} // namespace sf
+
282
+
283
+
284#endif // SFML_SOUNDBUFFER_HPP
+
285
+
286
+
sf::AlResource
Base class for classes that require an OpenAL context.
Definition: AlResource.hpp:41
+
sf::InputSoundFile
Provide read access to sound files.
Definition: InputSoundFile.hpp:48
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::SoundBuffer
Storage for audio samples defining a sound.
Definition: SoundBuffer.hpp:50
+
sf::SoundBuffer::SoundBuffer
SoundBuffer()
Default constructor.
+
sf::SoundBuffer::getChannelCount
unsigned int getChannelCount() const
Get the number of channels used by the sound.
+
sf::SoundBuffer::getDuration
Time getDuration() const
Get the total duration of the sound.
+
sf::SoundBuffer::loadFromFile
bool loadFromFile(const std::string &filename)
Load the sound buffer from a file.
+
sf::SoundBuffer::getSampleRate
unsigned int getSampleRate() const
Get the sample rate of the sound.
+
sf::SoundBuffer::getSamples
const Int16 * getSamples() const
Get the array of audio samples stored in the buffer.
+
sf::SoundBuffer::loadFromSamples
bool loadFromSamples(const Int16 *samples, Uint64 sampleCount, unsigned int channelCount, unsigned int sampleRate)
Load the sound buffer from an array of audio samples.
+
sf::SoundBuffer::saveToFile
bool saveToFile(const std::string &filename) const
Save the sound buffer to an audio file.
+
sf::SoundBuffer::SoundBuffer
SoundBuffer(const SoundBuffer &copy)
Copy constructor.
+
sf::SoundBuffer::loadFromStream
bool loadFromStream(InputStream &stream)
Load the sound buffer from a custom stream.
+
sf::SoundBuffer::~SoundBuffer
~SoundBuffer()
Destructor.
+
sf::SoundBuffer::getSampleCount
Uint64 getSampleCount() const
Get the number of samples stored in the buffer.
+
sf::SoundBuffer::loadFromMemory
bool loadFromMemory(const void *data, std::size_t sizeInBytes)
Load the sound buffer from a file in memory.
+
sf::Sound
Regular sound that can be played in the audio environment.
Definition: Sound.hpp:46
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/SoundFileFactory_8hpp_source.html b/Space-Invaders/sfml/doc/html/SoundFileFactory_8hpp_source.html new file mode 100644 index 000000000..1c49094dd --- /dev/null +++ b/Space-Invaders/sfml/doc/html/SoundFileFactory_8hpp_source.html @@ -0,0 +1,206 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SoundFileFactory.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOUNDFILEFACTORY_HPP
+
26#define SFML_SOUNDFILEFACTORY_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <string>
+
33#include <vector>
+
34
+
35
+
36namespace sf
+
37{
+
38class InputStream;
+
39class SoundFileReader;
+
40class SoundFileWriter;
+
41
+
46class SFML_AUDIO_API SoundFileFactory
+
47{
+
48public:
+
49
+
56 template <typename T>
+
57 static void registerReader();
+
58
+
65 template <typename T>
+
66 static void unregisterReader();
+
67
+
74 template <typename T>
+
75 static void registerWriter();
+
76
+
83 template <typename T>
+
84 static void unregisterWriter();
+
85
+
98 static SoundFileReader* createReaderFromFilename(const std::string& filename);
+
99
+
113 static SoundFileReader* createReaderFromMemory(const void* data, std::size_t sizeInBytes);
+
114
+
127 static SoundFileReader* createReaderFromStream(InputStream& stream);
+
128
+
139 static SoundFileWriter* createWriterFromFilename(const std::string& filename);
+
140
+
141private:
+
142
+
144 // Types
+
146 struct ReaderFactory
+
147 {
+
148 bool (*check)(InputStream&);
+
149 SoundFileReader* (*create)();
+
150 };
+
151 typedef std::vector<ReaderFactory> ReaderFactoryArray;
+
152
+
153 struct WriterFactory
+
154 {
+
155 bool (*check)(const std::string&);
+
156 SoundFileWriter* (*create)();
+
157 };
+
158 typedef std::vector<WriterFactory> WriterFactoryArray;
+
159
+
161 // Static member data
+
163 static ReaderFactoryArray s_readers;
+
164 static WriterFactoryArray s_writers;
+
165};
+
166
+
167} // namespace sf
+
168
+
169#include <SFML/Audio/SoundFileFactory.inl>
+
170
+
171#endif // SFML_SOUNDFILEFACTORY_HPP
+
172
+
173
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::SoundFileFactory
Manages and instantiates sound file readers and writers.
Definition: SoundFileFactory.hpp:47
+
sf::SoundFileFactory::unregisterWriter
static void unregisterWriter()
Unregister a writer.
+
sf::SoundFileFactory::createReaderFromMemory
static SoundFileReader * createReaderFromMemory(const void *data, std::size_t sizeInBytes)
Instantiate the right codec for the given file in memory.
+
sf::SoundFileFactory::createWriterFromFilename
static SoundFileWriter * createWriterFromFilename(const std::string &filename)
Instantiate the right writer for the given file on disk.
+
sf::SoundFileFactory::registerWriter
static void registerWriter()
Register a new writer.
+
sf::SoundFileFactory::unregisterReader
static void unregisterReader()
Unregister a reader.
+
sf::SoundFileFactory::createReaderFromFilename
static SoundFileReader * createReaderFromFilename(const std::string &filename)
Instantiate the right reader for the given file on disk.
+
sf::SoundFileFactory::registerReader
static void registerReader()
Register a new reader.
+
sf::SoundFileFactory::createReaderFromStream
static SoundFileReader * createReaderFromStream(InputStream &stream)
Instantiate the right codec for the given file in stream.
+
sf::SoundFileReader
Abstract base class for sound file decoding.
Definition: SoundFileReader.hpp:44
+
sf::SoundFileWriter
Abstract base class for sound file encoding.
Definition: SoundFileWriter.hpp:42
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/SoundFileReader_8hpp_source.html b/Space-Invaders/sfml/doc/html/SoundFileReader_8hpp_source.html new file mode 100644 index 000000000..983d23e8d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/SoundFileReader_8hpp_source.html @@ -0,0 +1,174 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SoundFileReader.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOUNDFILEREADER_HPP
+
26#define SFML_SOUNDFILEREADER_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <string>
+
33
+
34
+
35namespace sf
+
36{
+
37class InputStream;
+
38
+
43class SFML_AUDIO_API SoundFileReader
+
44{
+
45public:
+
46
+
51 struct Info
+
52 {
+
53 Uint64 sampleCount;
+
54 unsigned int channelCount;
+
55 unsigned int sampleRate;
+
56 };
+
57
+
62 virtual ~SoundFileReader() {}
+
63
+
77 virtual bool open(InputStream& stream, Info& info) = 0;
+
78
+
92 virtual void seek(Uint64 sampleOffset) = 0;
+
93
+
103 virtual Uint64 read(Int16* samples, Uint64 maxCount) = 0;
+
104};
+
105
+
106} // namespace sf
+
107
+
108
+
109#endif // SFML_SOUNDFILEREADER_HPP
+
110
+
111
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::SoundFileReader
Abstract base class for sound file decoding.
Definition: SoundFileReader.hpp:44
+
sf::SoundFileReader::seek
virtual void seek(Uint64 sampleOffset)=0
Change the current read position to the given sample offset.
+
sf::SoundFileReader::~SoundFileReader
virtual ~SoundFileReader()
Virtual destructor.
Definition: SoundFileReader.hpp:62
+
sf::SoundFileReader::read
virtual Uint64 read(Int16 *samples, Uint64 maxCount)=0
Read audio samples from the open file.
+
sf::SoundFileReader::open
virtual bool open(InputStream &stream, Info &info)=0
Open a sound file for reading.
+
sf::SoundFileReader::Info
Structure holding the audio properties of a sound file.
Definition: SoundFileReader.hpp:52
+
sf::SoundFileReader::Info::sampleRate
unsigned int sampleRate
Samples rate of the sound, in samples per second.
Definition: SoundFileReader.hpp:55
+
sf::SoundFileReader::Info::sampleCount
Uint64 sampleCount
Total number of samples in the file.
Definition: SoundFileReader.hpp:53
+
sf::SoundFileReader::Info::channelCount
unsigned int channelCount
Number of channels of the sound.
Definition: SoundFileReader.hpp:54
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/SoundFileWriter_8hpp_source.html b/Space-Invaders/sfml/doc/html/SoundFileWriter_8hpp_source.html new file mode 100644 index 000000000..2c0207fc3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/SoundFileWriter_8hpp_source.html @@ -0,0 +1,157 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SoundFileWriter.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOUNDFILEWRITER_HPP
+
26#define SFML_SOUNDFILEWRITER_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <string>
+
33
+
34
+
35namespace sf
+
36{
+
41class SFML_AUDIO_API SoundFileWriter
+
42{
+
43public:
+
44
+
49 virtual ~SoundFileWriter() {}
+
50
+
61 virtual bool open(const std::string& filename, unsigned int sampleRate, unsigned int channelCount) = 0;
+
62
+
70 virtual void write(const Int16* samples, Uint64 count) = 0;
+
71};
+
72
+
73} // namespace sf
+
74
+
75
+
76#endif // SFML_SOUNDFILEWRITER_HPP
+
77
+
78
+
sf::SoundFileWriter
Abstract base class for sound file encoding.
Definition: SoundFileWriter.hpp:42
+
sf::SoundFileWriter::write
virtual void write(const Int16 *samples, Uint64 count)=0
Write audio samples to the open file.
+
sf::SoundFileWriter::open
virtual bool open(const std::string &filename, unsigned int sampleRate, unsigned int channelCount)=0
Open a sound file for writing.
+
sf::SoundFileWriter::~SoundFileWriter
virtual ~SoundFileWriter()
Virtual destructor.
Definition: SoundFileWriter.hpp:49
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/SoundRecorder_8hpp_source.html b/Space-Invaders/sfml/doc/html/SoundRecorder_8hpp_source.html new file mode 100644 index 000000000..2eee6638e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/SoundRecorder_8hpp_source.html @@ -0,0 +1,222 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SoundRecorder.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOUNDRECORDER_HPP
+
26#define SFML_SOUNDRECORDER_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <SFML/Audio/AlResource.hpp>
+
33#include <SFML/System/Thread.hpp>
+
34#include <SFML/System/Time.hpp>
+
35#include <vector>
+
36#include <string>
+
37
+
38
+
39namespace sf
+
40{
+
45class SFML_AUDIO_API SoundRecorder : AlResource
+
46{
+
47public:
+
48
+
53 virtual ~SoundRecorder();
+
54
+
77 bool start(unsigned int sampleRate = 44100);
+
78
+
85 void stop();
+
86
+
97 unsigned int getSampleRate() const;
+
98
+
108 static std::vector<std::string> getAvailableDevices();
+
109
+
120 static std::string getDefaultDevice();
+
121
+
137 bool setDevice(const std::string& name);
+
138
+
145 const std::string& getDevice() const;
+
146
+
160 void setChannelCount(unsigned int channelCount);
+
161
+
173 unsigned int getChannelCount() const;
+
174
+
186 static bool isAvailable();
+
187
+
188protected:
+
189
+
196 SoundRecorder();
+
197
+
214 void setProcessingInterval(Time interval);
+
215
+
227 virtual bool onStart();
+
228
+
243 virtual bool onProcessSamples(const Int16* samples, std::size_t sampleCount) = 0;
+
244
+
254 virtual void onStop();
+
255
+
256private:
+
257
+
265 void record();
+
266
+
275 void processCapturedSamples();
+
276
+
283 void cleanup();
+
284
+
286 // Member data
+
288 Thread m_thread;
+
289 std::vector<Int16> m_samples;
+
290 unsigned int m_sampleRate;
+
291 Time m_processingInterval;
+
292 bool m_isCapturing;
+
293 std::string m_deviceName;
+
294 unsigned int m_channelCount;
+
295};
+
296
+
297} // namespace sf
+
298
+
299
+
300#endif // SFML_SOUNDRECORDER_HPP
+
301
+
302
+
sf::AlResource
Base class for classes that require an OpenAL context.
Definition: AlResource.hpp:41
+
sf::SoundRecorder
Abstract base class for capturing sound data.
Definition: SoundRecorder.hpp:46
+
sf::SoundRecorder::getDevice
const std::string & getDevice() const
Get the name of the current audio capture device.
+
sf::SoundRecorder::onProcessSamples
virtual bool onProcessSamples(const Int16 *samples, std::size_t sampleCount)=0
Process a new chunk of recorded samples.
+
sf::SoundRecorder::getAvailableDevices
static std::vector< std::string > getAvailableDevices()
Get a list of the names of all available audio capture devices.
+
sf::SoundRecorder::SoundRecorder
SoundRecorder()
Default constructor.
+
sf::SoundRecorder::getChannelCount
unsigned int getChannelCount() const
Get the number of channels used by this recorder.
+
sf::SoundRecorder::start
bool start(unsigned int sampleRate=44100)
Start the capture.
+
sf::SoundRecorder::onStart
virtual bool onStart()
Start capturing audio data.
+
sf::SoundRecorder::setProcessingInterval
void setProcessingInterval(Time interval)
Set the processing interval.
+
sf::SoundRecorder::stop
void stop()
Stop the capture.
+
sf::SoundRecorder::setDevice
bool setDevice(const std::string &name)
Set the audio capture device.
+
sf::SoundRecorder::isAvailable
static bool isAvailable()
Check if the system supports audio capture.
+
sf::SoundRecorder::~SoundRecorder
virtual ~SoundRecorder()
destructor
+
sf::SoundRecorder::getDefaultDevice
static std::string getDefaultDevice()
Get the name of the default audio capture device.
+
sf::SoundRecorder::setChannelCount
void setChannelCount(unsigned int channelCount)
Set the channel count of the audio capture device.
+
sf::SoundRecorder::getSampleRate
unsigned int getSampleRate() const
Get the sample rate.
+
sf::SoundRecorder::onStop
virtual void onStop()
Stop capturing audio data.
+
sf::Thread
Utility class to manipulate threads.
Definition: Thread.hpp:49
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/SoundSource_8hpp_source.html b/Space-Invaders/sfml/doc/html/SoundSource_8hpp_source.html new file mode 100644 index 000000000..930847d93 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/SoundSource_8hpp_source.html @@ -0,0 +1,229 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SoundSource.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOUNDSOURCE_HPP
+
26#define SFML_SOUNDSOURCE_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <SFML/Audio/AlResource.hpp>
+
33#include <SFML/System/Vector3.hpp>
+
34
+
35
+
36namespace sf
+
37{
+
42class SFML_AUDIO_API SoundSource : AlResource
+
43{
+
44public:
+
45
+
50 enum Status
+
51 {
+
52 Stopped,
+
53 Paused,
+
54 Playing
+
55 };
+
56
+
63 SoundSource(const SoundSource& copy);
+
64
+
69 virtual ~SoundSource();
+
70
+
85 void setPitch(float pitch);
+
86
+
98 void setVolume(float volume);
+
99
+
114 void setPosition(float x, float y, float z);
+
115
+
128 void setPosition(const Vector3f& position);
+
129
+
144 void setRelativeToListener(bool relative);
+
145
+
161 void setMinDistance(float distance);
+
162
+
180 void setAttenuation(float attenuation);
+
181
+
190 float getPitch() const;
+
191
+
200 float getVolume() const;
+
201
+
210 Vector3f getPosition() const;
+
211
+
221 bool isRelativeToListener() const;
+
222
+
231 float getMinDistance() const;
+
232
+
241 float getAttenuation() const;
+
242
+
251 SoundSource& operator =(const SoundSource& right);
+
252
+
263 virtual void play() = 0;
+
264
+
274 virtual void pause() = 0;
+
275
+
286 virtual void stop() = 0;
+
287
+
294 virtual Status getStatus() const;
+
295
+
296protected:
+
297
+
304 SoundSource();
+
305
+
307 // Member data
+
309 unsigned int m_source;
+
310};
+
311
+
312} // namespace sf
+
313
+
314
+
315#endif // SFML_SOUNDSOURCE_HPP
+
316
+
317
+
sf::AlResource
Base class for classes that require an OpenAL context.
Definition: AlResource.hpp:41
+
sf::SoundSource
Base class defining a sound's properties.
Definition: SoundSource.hpp:43
+
sf::SoundSource::m_source
unsigned int m_source
OpenAL source identifier.
Definition: SoundSource.hpp:309
+
sf::SoundSource::getVolume
float getVolume() const
Get the volume of the sound.
+
sf::SoundSource::setPosition
void setPosition(float x, float y, float z)
Set the 3D position of the sound in the audio scene.
+
sf::SoundSource::stop
virtual void stop()=0
Stop playing the sound source.
+
sf::SoundSource::setPosition
void setPosition(const Vector3f &position)
Set the 3D position of the sound in the audio scene.
+
sf::SoundSource::pause
virtual void pause()=0
Pause the sound source.
+
sf::SoundSource::setVolume
void setVolume(float volume)
Set the volume of the sound.
+
sf::SoundSource::getPitch
float getPitch() const
Get the pitch of the sound.
+
sf::SoundSource::getMinDistance
float getMinDistance() const
Get the minimum distance of the sound.
+
sf::SoundSource::play
virtual void play()=0
Start or resume playing the sound source.
+
sf::SoundSource::setPitch
void setPitch(float pitch)
Set the pitch of the sound.
+
sf::SoundSource::setMinDistance
void setMinDistance(float distance)
Set the minimum distance of the sound.
+
sf::SoundSource::~SoundSource
virtual ~SoundSource()
Destructor.
+
sf::SoundSource::getAttenuation
float getAttenuation() const
Get the attenuation factor of the sound.
+
sf::SoundSource::getPosition
Vector3f getPosition() const
Get the 3D position of the sound in the audio scene.
+
sf::SoundSource::setAttenuation
void setAttenuation(float attenuation)
Set the attenuation factor of the sound.
+
sf::SoundSource::getStatus
virtual Status getStatus() const
Get the current status of the sound (stopped, paused, playing)
+
sf::SoundSource::Status
Status
Enumeration of the sound source states.
Definition: SoundSource.hpp:51
+
sf::SoundSource::Paused
@ Paused
Sound is paused.
Definition: SoundSource.hpp:53
+
sf::SoundSource::Stopped
@ Stopped
Sound is not playing.
Definition: SoundSource.hpp:52
+
sf::SoundSource::setRelativeToListener
void setRelativeToListener(bool relative)
Make the sound's position relative to the listener or absolute.
+
sf::SoundSource::isRelativeToListener
bool isRelativeToListener() const
Tell whether the sound's position is relative to the listener or is absolute.
+
sf::SoundSource::SoundSource
SoundSource(const SoundSource &copy)
Copy constructor.
+
sf::SoundSource::SoundSource
SoundSource()
Default constructor.
+
sf::Vector3
Utility template class for manipulating 3-dimensional vectors.
Definition: Vector3.hpp:38
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/SoundStream_8hpp_source.html b/Space-Invaders/sfml/doc/html/SoundStream_8hpp_source.html new file mode 100644 index 000000000..3cf479438 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/SoundStream_8hpp_source.html @@ -0,0 +1,254 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SoundStream.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOUNDSTREAM_HPP
+
26#define SFML_SOUNDSTREAM_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <SFML/Audio/SoundSource.hpp>
+
33#include <SFML/System/Thread.hpp>
+
34#include <SFML/System/Time.hpp>
+
35#include <SFML/System/Mutex.hpp>
+
36#include <cstdlib>
+
37
+
38
+
39namespace sf
+
40{
+
45class SFML_AUDIO_API SoundStream : public SoundSource
+
46{
+
47public:
+
48
+
53 struct Chunk
+
54 {
+
55 const Int16* samples;
+
56 std::size_t sampleCount;
+
57 };
+
58
+
63 virtual ~SoundStream();
+
64
+
77 void play();
+
78
+
88 void pause();
+
89
+
100 void stop();
+
101
+
110 unsigned int getChannelCount() const;
+
111
+
121 unsigned int getSampleRate() const;
+
122
+
129 Status getStatus() const;
+
130
+
144 void setPlayingOffset(Time timeOffset);
+
145
+
154 Time getPlayingOffset() const;
+
155
+
169 void setLoop(bool loop);
+
170
+
179 bool getLoop() const;
+
180
+
181protected:
+
182
+
183 enum
+
184 {
+
185 NoLoop = -1
+
186 };
+
187
+
194 SoundStream();
+
195
+
210 void initialize(unsigned int channelCount, unsigned int sampleRate);
+
211
+
229 virtual bool onGetData(Chunk& data) = 0;
+
230
+
240 virtual void onSeek(Time timeOffset) = 0;
+
241
+
252 virtual Int64 onLoop();
+
253
+
266 void setProcessingInterval(Time interval);
+
267
+
268private:
+
269
+
277 void streamData();
+
278
+
293 bool fillAndPushBuffer(unsigned int bufferNum, bool immediateLoop = false);
+
294
+
304 bool fillQueue();
+
305
+
312 void clearQueue();
+
313
+
314 enum
+
315 {
+
316 BufferCount = 3,
+
317 BufferRetries = 2
+
318 };
+
319
+
321 // Member data
+
323 Thread m_thread;
+
324 mutable Mutex m_threadMutex;
+
325 Status m_threadStartState;
+
326 bool m_isStreaming;
+
327 unsigned int m_buffers[BufferCount];
+
328 unsigned int m_channelCount;
+
329 unsigned int m_sampleRate;
+
330 Int32 m_format;
+
331 bool m_loop;
+
332 Uint64 m_samplesProcessed;
+
333 Int64 m_bufferSeeks[BufferCount];
+
334 Time m_processingInterval;
+
335};
+
336
+
337} // namespace sf
+
338
+
339
+
340#endif // SFML_SOUNDSTREAM_HPP
+
341
+
342
+
sf::Mutex
Blocks concurrent access to shared resources from multiple threads.
Definition: Mutex.hpp:48
+
sf::SoundSource
Base class defining a sound's properties.
Definition: SoundSource.hpp:43
+
sf::SoundSource::Status
Status
Enumeration of the sound source states.
Definition: SoundSource.hpp:51
+
sf::SoundStream
Abstract base class for streamed audio sources.
Definition: SoundStream.hpp:46
+
sf::SoundStream::stop
void stop()
Stop playing the audio stream.
+
sf::SoundStream::getChannelCount
unsigned int getChannelCount() const
Return the number of channels of the stream.
+
sf::SoundStream::~SoundStream
virtual ~SoundStream()
Destructor.
+
sf::SoundStream::setProcessingInterval
void setProcessingInterval(Time interval)
Set the processing interval.
+
sf::SoundStream::onLoop
virtual Int64 onLoop()
Change the current playing position in the stream source to the beginning of the loop.
+
sf::SoundStream::setLoop
void setLoop(bool loop)
Set whether or not the stream should loop after reaching the end.
+
sf::SoundStream::getLoop
bool getLoop() const
Tell whether or not the stream is in loop mode.
+
sf::SoundStream::getStatus
Status getStatus() const
Get the current status of the stream (stopped, paused, playing)
+
sf::SoundStream::SoundStream
SoundStream()
Default constructor.
+
sf::SoundStream::getSampleRate
unsigned int getSampleRate() const
Get the stream sample rate of the stream.
+
sf::SoundStream::onSeek
virtual void onSeek(Time timeOffset)=0
Change the current playing position in the stream source.
+
sf::SoundStream::pause
void pause()
Pause the audio stream.
+
sf::SoundStream::onGetData
virtual bool onGetData(Chunk &data)=0
Request a new chunk of audio samples from the stream source.
+
sf::SoundStream::initialize
void initialize(unsigned int channelCount, unsigned int sampleRate)
Define the audio stream parameters.
+
sf::SoundStream::getPlayingOffset
Time getPlayingOffset() const
Get the current playing position of the stream.
+
sf::SoundStream::setPlayingOffset
void setPlayingOffset(Time timeOffset)
Change the current playing position of the stream.
+
sf::SoundStream::play
void play()
Start or resume playing the audio stream.
+
sf::Thread
Utility class to manipulate threads.
Definition: Thread.hpp:49
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
sf::SoundStream::Chunk
Structure defining a chunk of audio data to stream.
Definition: SoundStream.hpp:54
+
sf::SoundStream::Chunk::samples
const Int16 * samples
Pointer to the audio samples.
Definition: SoundStream.hpp:55
+
sf::SoundStream::Chunk::sampleCount
std::size_t sampleCount
Number of samples pointed by Samples.
Definition: SoundStream.hpp:56
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Sound_8hpp_source.html b/Space-Invaders/sfml/doc/html/Sound_8hpp_source.html new file mode 100644 index 000000000..37ff77c7e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Sound_8hpp_source.html @@ -0,0 +1,208 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Sound.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SOUND_HPP
+
26#define SFML_SOUND_HPP
+
27
+
29// Headers
+
31#include <SFML/Audio/Export.hpp>
+
32#include <SFML/Audio/SoundSource.hpp>
+
33#include <SFML/System/Time.hpp>
+
34#include <cstdlib>
+
35
+
36
+
37namespace sf
+
38{
+
39class SoundBuffer;
+
40
+
45class SFML_AUDIO_API Sound : public SoundSource
+
46{
+
47public:
+
48
+
53 Sound();
+
54
+
61 explicit Sound(const SoundBuffer& buffer);
+
62
+
69 Sound(const Sound& copy);
+
70
+
75 ~Sound();
+
76
+
89 void play();
+
90
+
100 void pause();
+
101
+
112 void stop();
+
113
+
126 void setBuffer(const SoundBuffer& buffer);
+
127
+
141 void setLoop(bool loop);
+
142
+
156 void setPlayingOffset(Time timeOffset);
+
157
+
164 const SoundBuffer* getBuffer() const;
+
165
+
174 bool getLoop() const;
+
175
+
184 Time getPlayingOffset() const;
+
185
+
192 Status getStatus() const;
+
193
+
202 Sound& operator =(const Sound& right);
+
203
+
213 void resetBuffer();
+
214
+
215private:
+
216
+
218 // Member data
+
220 const SoundBuffer* m_buffer;
+
221};
+
222
+
223} // namespace sf
+
224
+
225
+
226#endif // SFML_SOUND_HPP
+
227
+
228
+
sf::SoundBuffer
Storage for audio samples defining a sound.
Definition: SoundBuffer.hpp:50
+
sf::SoundSource
Base class defining a sound's properties.
Definition: SoundSource.hpp:43
+
sf::SoundSource::Status
Status
Enumeration of the sound source states.
Definition: SoundSource.hpp:51
+
sf::Sound
Regular sound that can be played in the audio environment.
Definition: Sound.hpp:46
+
sf::Sound::getLoop
bool getLoop() const
Tell whether or not the sound is in loop mode.
+
sf::Sound::play
void play()
Start or resume playing the sound.
+
sf::Sound::Sound
Sound()
Default constructor.
+
sf::Sound::Sound
Sound(const SoundBuffer &buffer)
Construct the sound with a buffer.
+
sf::Sound::getStatus
Status getStatus() const
Get the current status of the sound (stopped, paused, playing)
+
sf::Sound::getPlayingOffset
Time getPlayingOffset() const
Get the current playing position of the sound.
+
sf::Sound::pause
void pause()
Pause the sound.
+
sf::Sound::getBuffer
const SoundBuffer * getBuffer() const
Get the audio buffer attached to the sound.
+
sf::Sound::setBuffer
void setBuffer(const SoundBuffer &buffer)
Set the source buffer containing the audio data to play.
+
sf::Sound::stop
void stop()
stop playing the sound
+
sf::Sound::setPlayingOffset
void setPlayingOffset(Time timeOffset)
Change the current playing position of the sound.
+
sf::Sound::resetBuffer
void resetBuffer()
Reset the internal buffer of the sound.
+
sf::Sound::~Sound
~Sound()
Destructor.
+
sf::Sound::Sound
Sound(const Sound &copy)
Copy constructor.
+
sf::Sound::setLoop
void setLoop(bool loop)
Set whether or not the sound should loop after reaching the end.
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Sprite_8hpp_source.html b/Space-Invaders/sfml/doc/html/Sprite_8hpp_source.html new file mode 100644 index 000000000..09738705f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Sprite_8hpp_source.html @@ -0,0 +1,207 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Sprite.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SPRITE_HPP
+
26#define SFML_SPRITE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Drawable.hpp>
+
33#include <SFML/Graphics/Transformable.hpp>
+
34#include <SFML/Graphics/Vertex.hpp>
+
35#include <SFML/Graphics/Rect.hpp>
+
36
+
37
+
38namespace sf
+
39{
+
40class Texture;
+
41
+
47class SFML_GRAPHICS_API Sprite : public Drawable, public Transformable
+
48{
+
49public:
+
50
+
57 Sprite();
+
58
+
67 explicit Sprite(const Texture& texture);
+
68
+
78 Sprite(const Texture& texture, const IntRect& rectangle);
+
79
+
99 void setTexture(const Texture& texture, bool resetRect = false);
+
100
+
113 void setTextureRect(const IntRect& rectangle);
+
114
+
128 void setColor(const Color& color);
+
129
+
142 const Texture* getTexture() const;
+
143
+
152 const IntRect& getTextureRect() const;
+
153
+
162 const Color& getColor() const;
+
163
+
176 FloatRect getLocalBounds() const;
+
177
+
190 FloatRect getGlobalBounds() const;
+
191
+
192private:
+
193
+
201 virtual void draw(RenderTarget& target, RenderStates states) const;
+
202
+
207 void updatePositions();
+
208
+
213 void updateTexCoords();
+
214
+
216 // Member data
+
218 Vertex m_vertices[4];
+
219 const Texture* m_texture;
+
220 IntRect m_textureRect;
+
221};
+
222
+
223} // namespace sf
+
224
+
225
+
226#endif // SFML_SPRITE_HPP
+
227
+
228
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+
sf::Drawable
Abstract base class for objects that can be drawn to a render target.
Definition: Drawable.hpp:45
+ +
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::Sprite
Drawable representation of a texture, with its own transformations, color, etc.
Definition: Sprite.hpp:48
+
sf::Sprite::Sprite
Sprite(const Texture &texture, const IntRect &rectangle)
Construct the sprite from a sub-rectangle of a source texture.
+
sf::Sprite::setColor
void setColor(const Color &color)
Set the global color of the sprite.
+
sf::Sprite::Sprite
Sprite(const Texture &texture)
Construct the sprite from a source texture.
+
sf::Sprite::setTexture
void setTexture(const Texture &texture, bool resetRect=false)
Change the source texture of the sprite.
+
sf::Sprite::setTextureRect
void setTextureRect(const IntRect &rectangle)
Set the sub-rectangle of the texture that the sprite will display.
+
sf::Sprite::getTexture
const Texture * getTexture() const
Get the source texture of the sprite.
+
sf::Sprite::Sprite
Sprite()
Default constructor.
+
sf::Sprite::getGlobalBounds
FloatRect getGlobalBounds() const
Get the global bounding rectangle of the entity.
+
sf::Sprite::getLocalBounds
FloatRect getLocalBounds() const
Get the local bounding rectangle of the entity.
+
sf::Sprite::getColor
const Color & getColor() const
Get the global color of the sprite.
+
sf::Sprite::getTextureRect
const IntRect & getTextureRect() const
Get the sub-rectangle of the texture displayed by the sprite.
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Transformable
Decomposed transform defined by a position, a rotation and a scale.
Definition: Transformable.hpp:42
+
sf::Vertex
Define a point with color and texture coordinates.
Definition: Vertex.hpp:43
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/String_8hpp_source.html b/Space-Invaders/sfml/doc/html/String_8hpp_source.html new file mode 100644 index 000000000..3867d71ff --- /dev/null +++ b/Space-Invaders/sfml/doc/html/String_8hpp_source.html @@ -0,0 +1,299 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
String.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_STRING_HPP
+
26#define SFML_STRING_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Export.hpp>
+
32#include <SFML/System/Utf.hpp>
+
33#include <iterator>
+
34#include <locale>
+
35#include <string>
+
36
+
37
+
38namespace sf
+
39{
+
45class SFML_SYSTEM_API String
+
46{
+
47public:
+
48
+
50 // Types
+
52 typedef std::basic_string<Uint32>::iterator Iterator;
+
53 typedef std::basic_string<Uint32>::const_iterator ConstIterator;
+
54
+
56 // Static member data
+
58 static const std::size_t InvalidPos;
+
59
+
66 String();
+
67
+
78 String(char ansiChar, const std::locale& locale = std::locale());
+
79
+
86 String(wchar_t wideChar);
+
87
+
94 String(Uint32 utf32Char);
+
95
+
106 String(const char* ansiString, const std::locale& locale = std::locale());
+
107
+
118 String(const std::string& ansiString, const std::locale& locale = std::locale());
+
119
+
126 String(const wchar_t* wideString);
+
127
+
134 String(const std::wstring& wideString);
+
135
+
142 String(const Uint32* utf32String);
+
143
+
150 String(const std::basic_string<Uint32>& utf32String);
+
151
+
158 String(const String& copy);
+
159
+
171 template <typename T>
+
172 static String fromUtf8(T begin, T end);
+
173
+
185 template <typename T>
+
186 static String fromUtf16(T begin, T end);
+
187
+
203 template <typename T>
+
204 static String fromUtf32(T begin, T end);
+
205
+
221 operator std::string() const;
+
222
+
236 operator std::wstring() const;
+
237
+
253 std::string toAnsiString(const std::locale& locale = std::locale()) const;
+
254
+
266 std::wstring toWideString() const;
+
267
+
276 std::basic_string<Uint8> toUtf8() const;
+
277
+
286 std::basic_string<Uint16> toUtf16() const;
+
287
+
299 std::basic_string<Uint32> toUtf32() const;
+
300
+
309 String& operator =(const String& right);
+
310
+
319 String& operator +=(const String& right);
+
320
+
332 Uint32 operator [](std::size_t index) const;
+
333
+
345 Uint32& operator [](std::size_t index);
+
346
+
355 void clear();
+
356
+
365 std::size_t getSize() const;
+
366
+
375 bool isEmpty() const;
+
376
+
387 void erase(std::size_t position, std::size_t count = 1);
+
388
+
399 void insert(std::size_t position, const String& str);
+
400
+
413 std::size_t find(const String& str, std::size_t start = 0) const;
+
414
+
427 void replace(std::size_t position, std::size_t length, const String& replaceWith);
+
428
+
439 void replace(const String& searchFor, const String& replaceWith);
+
440
+
456 String substring(std::size_t position, std::size_t length = InvalidPos) const;
+
457
+
469 const Uint32* getData() const;
+
470
+
479 Iterator begin();
+
480
+
489 ConstIterator begin() const;
+
490
+
503 Iterator end();
+
504
+
517 ConstIterator end() const;
+
518
+
519private:
+
520
+
521 friend SFML_SYSTEM_API bool operator ==(const String& left, const String& right);
+
522 friend SFML_SYSTEM_API bool operator <(const String& left, const String& right);
+
523
+
525 // Member data
+
527 std::basic_string<Uint32> m_string;
+
528};
+
529
+
540SFML_SYSTEM_API bool operator ==(const String& left, const String& right);
+
541
+
552SFML_SYSTEM_API bool operator !=(const String& left, const String& right);
+
553
+
564SFML_SYSTEM_API bool operator <(const String& left, const String& right);
+
565
+
576SFML_SYSTEM_API bool operator >(const String& left, const String& right);
+
577
+
588SFML_SYSTEM_API bool operator <=(const String& left, const String& right);
+
589
+
600SFML_SYSTEM_API bool operator >=(const String& left, const String& right);
+
601
+
612SFML_SYSTEM_API String operator +(const String& left, const String& right);
+
613
+
614#include <SFML/System/String.inl>
+
615
+
616} // namespace sf
+
617
+
618
+
619#endif // SFML_STRING_HPP
+
620
+
621
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+
sf::String::String
String(const std::string &ansiString, const std::locale &locale=std::locale())
Construct from an ANSI string and a locale.
+
sf::String::begin
ConstIterator begin() const
Return an iterator to the beginning of the string.
+
sf::String::toUtf8
std::basic_string< Uint8 > toUtf8() const
Convert the Unicode string to a UTF-8 string.
+
sf::String::isEmpty
bool isEmpty() const
Check whether the string is empty or not.
+
sf::String::clear
void clear()
Clear the string.
+
sf::String::getData
const Uint32 * getData() const
Get a pointer to the C-style array of characters.
+
sf::String::substring
String substring(std::size_t position, std::size_t length=InvalidPos) const
Return a part of the string.
+
sf::String::String
String(const wchar_t *wideString)
Construct from null-terminated C-style wide string.
+
sf::String::String
String(const char *ansiString, const std::locale &locale=std::locale())
Construct from a null-terminated C-style ANSI string and a locale.
+
sf::String::String
String(const std::wstring &wideString)
Construct from a wide string.
+
sf::String::String
String(const std::basic_string< Uint32 > &utf32String)
Construct from an UTF-32 string.
+
sf::String::fromUtf16
static String fromUtf16(T begin, T end)
Create a new sf::String from a UTF-16 encoded string.
+
sf::String::replace
void replace(const String &searchFor, const String &replaceWith)
Replace all occurrences of a substring with a replacement string.
+
sf::String::ConstIterator
std::basic_string< Uint32 >::const_iterator ConstIterator
Read-only iterator type.
Definition: String.hpp:53
+
sf::String::String
String(Uint32 utf32Char)
Construct from single UTF-32 character.
+
sf::String::begin
Iterator begin()
Return an iterator to the beginning of the string.
+
sf::String::String
String()
Default constructor.
+
sf::String::toWideString
std::wstring toWideString() const
Convert the Unicode string to a wide string.
+
sf::String::find
std::size_t find(const String &str, std::size_t start=0) const
Find a sequence of one or more characters in the string.
+
sf::String::fromUtf8
static String fromUtf8(T begin, T end)
Create a new sf::String from a UTF-8 encoded string.
+
sf::String::erase
void erase(std::size_t position, std::size_t count=1)
Erase one or more characters from the string.
+
sf::String::fromUtf32
static String fromUtf32(T begin, T end)
Create a new sf::String from a UTF-32 encoded string.
+
sf::String::toUtf16
std::basic_string< Uint16 > toUtf16() const
Convert the Unicode string to a UTF-16 string.
+
sf::String::InvalidPos
static const std::size_t InvalidPos
Represents an invalid position in the string.
Definition: String.hpp:58
+
sf::String::end
Iterator end()
Return an iterator to the end of the string.
+
sf::String::Iterator
std::basic_string< Uint32 >::iterator Iterator
Iterator type.
Definition: String.hpp:52
+
sf::String::String
String(char ansiChar, const std::locale &locale=std::locale())
Construct from a single ANSI character and a locale.
+
sf::String::insert
void insert(std::size_t position, const String &str)
Insert one or more characters into the string.
+
sf::String::replace
void replace(std::size_t position, std::size_t length, const String &replaceWith)
Replace a substring with another string.
+
sf::String::toAnsiString
std::string toAnsiString(const std::locale &locale=std::locale()) const
Convert the Unicode string to an ANSI string.
+
sf::String::getSize
std::size_t getSize() const
Get the size of the string.
+
sf::String::String
String(const Uint32 *utf32String)
Construct from a null-terminated C-style UTF-32 string.
+
sf::String::toUtf32
std::basic_string< Uint32 > toUtf32() const
Convert the Unicode string to a UTF-32 string.
+
sf::String::String
String(wchar_t wideChar)
Construct from single wide character.
+
sf::String::end
ConstIterator end() const
Return an iterator to the end of the string.
+
sf::String::String
String(const String &copy)
Copy constructor.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/System_2Export_8hpp_source.html b/Space-Invaders/sfml/doc/html/System_2Export_8hpp_source.html new file mode 100644 index 000000000..eb98b7783 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/System_2Export_8hpp_source.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
System/Export.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SYSTEM_EXPORT_HPP
+
26#define SFML_SYSTEM_EXPORT_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32
+
33
+
35// Define portable import / export macros
+
37#if defined(SFML_SYSTEM_EXPORTS)
+
38
+
39 #define SFML_SYSTEM_API SFML_API_EXPORT
+
40
+
41#else
+
42
+
43 #define SFML_SYSTEM_API SFML_API_IMPORT
+
44
+
45#endif
+
46
+
47
+
48#endif // SFML_SYSTEM_EXPORT_HPP
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/System_8hpp_source.html b/Space-Invaders/sfml/doc/html/System_8hpp_source.html new file mode 100644 index 000000000..0eba4c00d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/System_8hpp_source.html @@ -0,0 +1,152 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
System.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SYSTEM_HPP
+
26#define SFML_SYSTEM_HPP
+
27
+
29// Headers
+
31
+
32#include <SFML/Config.hpp>
+
33#include <SFML/System/Clock.hpp>
+
34#include <SFML/System/Err.hpp>
+
35#include <SFML/System/FileInputStream.hpp>
+
36#include <SFML/System/InputStream.hpp>
+
37#include <SFML/System/Lock.hpp>
+
38#include <SFML/System/MemoryInputStream.hpp>
+
39#include <SFML/System/Mutex.hpp>
+
40#include <SFML/System/NonCopyable.hpp>
+
41#include <SFML/System/Sleep.hpp>
+
42#include <SFML/System/String.hpp>
+
43#include <SFML/System/Thread.hpp>
+
44#include <SFML/System/ThreadLocal.hpp>
+
45#include <SFML/System/ThreadLocalPtr.hpp>
+
46#include <SFML/System/Time.hpp>
+
47#include <SFML/System/Utf.hpp>
+
48#include <SFML/System/Vector2.hpp>
+
49#include <SFML/System/Vector3.hpp>
+
50
+
51#endif // SFML_SYSTEM_HPP
+
52
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/TcpListener_8hpp_source.html b/Space-Invaders/sfml/doc/html/TcpListener_8hpp_source.html new file mode 100644 index 000000000..e0e533301 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/TcpListener_8hpp_source.html @@ -0,0 +1,171 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
TcpListener.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_TCPLISTENER_HPP
+
26#define SFML_TCPLISTENER_HPP
+
27
+
29// Headers
+
31#include <SFML/Network/Export.hpp>
+
32#include <SFML/Network/Socket.hpp>
+
33#include <SFML/Network/IpAddress.hpp>
+
34
+
35
+
36namespace sf
+
37{
+
38class TcpSocket;
+
39
+
44class SFML_NETWORK_API TcpListener : public Socket
+
45{
+
46public:
+
47
+
52 TcpListener();
+
53
+
65 unsigned short getLocalPort() const;
+
66
+
89 Status listen(unsigned short port, const IpAddress& address = IpAddress::Any);
+
90
+
100 void close();
+
101
+
115 Status accept(TcpSocket& socket);
+
116};
+
117
+
118
+
119} // namespace sf
+
120
+
121
+
122#endif // SFML_TCPLISTENER_HPP
+
123
+
124
+
sf::IpAddress
Encapsulate an IPv4 network address.
Definition: IpAddress.hpp:45
+
sf::Socket
Base class for all the socket types.
Definition: Socket.hpp:46
+
sf::Socket::Status
Status
Status codes that may be returned by socket functions.
Definition: Socket.hpp:54
+
sf::TcpListener
Socket that listens to new TCP connections.
Definition: TcpListener.hpp:45
+
sf::TcpListener::close
void close()
Stop listening and close the socket.
+
sf::TcpListener::TcpListener
TcpListener()
Default constructor.
+
sf::TcpListener::getLocalPort
unsigned short getLocalPort() const
Get the port to which the socket is bound locally.
+
sf::TcpListener::listen
Status listen(unsigned short port, const IpAddress &address=IpAddress::Any)
Start listening for incoming connection attempts.
+
sf::TcpListener::accept
Status accept(TcpSocket &socket)
Accept a new connection.
+
sf::TcpSocket
Specialized socket using the TCP protocol.
Definition: TcpSocket.hpp:47
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/TcpSocket_8hpp_source.html b/Space-Invaders/sfml/doc/html/TcpSocket_8hpp_source.html new file mode 100644 index 000000000..0584e07a5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/TcpSocket_8hpp_source.html @@ -0,0 +1,208 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
TcpSocket.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_TCPSOCKET_HPP
+
26#define SFML_TCPSOCKET_HPP
+
27
+
29// Headers
+
31#include <SFML/Network/Export.hpp>
+
32#include <SFML/Network/Socket.hpp>
+
33#include <SFML/System/Time.hpp>
+
34
+
35
+
36namespace sf
+
37{
+
38class TcpListener;
+
39class IpAddress;
+
40class Packet;
+
41
+
46class SFML_NETWORK_API TcpSocket : public Socket
+
47{
+
48public:
+
49
+
54 TcpSocket();
+
55
+
66 unsigned short getLocalPort() const;
+
67
+
79 IpAddress getRemoteAddress() const;
+
80
+
92 unsigned short getRemotePort() const;
+
93
+
112 Status connect(const IpAddress& remoteAddress, unsigned short remotePort, Time timeout = Time::Zero);
+
113
+
123 void disconnect();
+
124
+
141 Status send(const void* data, std::size_t size);
+
142
+
157 Status send(const void* data, std::size_t size, std::size_t& sent);
+
158
+
175 Status receive(void* data, std::size_t size, std::size_t& received);
+
176
+
193 Status send(Packet& packet);
+
194
+
209 Status receive(Packet& packet);
+
210
+
211private:
+
212
+
213 friend class TcpListener;
+
214
+
219 struct PendingPacket
+
220 {
+
221 PendingPacket();
+
222
+
223 Uint32 Size;
+
224 std::size_t SizeReceived;
+
225 std::vector<char> Data;
+
226 };
+
227
+
229 // Member data
+
231 PendingPacket m_pendingPacket;
+
232};
+
233
+
234} // namespace sf
+
235
+
236
+
237#endif // SFML_TCPSOCKET_HPP
+
238
+
239
+
sf::IpAddress
Encapsulate an IPv4 network address.
Definition: IpAddress.hpp:45
+
sf::Packet
Utility class to build blocks of data to transfer over the network.
Definition: Packet.hpp:48
+
sf::Socket
Base class for all the socket types.
Definition: Socket.hpp:46
+
sf::Socket::Status
Status
Status codes that may be returned by socket functions.
Definition: Socket.hpp:54
+
sf::TcpListener
Socket that listens to new TCP connections.
Definition: TcpListener.hpp:45
+
sf::TcpSocket
Specialized socket using the TCP protocol.
Definition: TcpSocket.hpp:47
+
sf::TcpSocket::send
Status send(Packet &packet)
Send a formatted packet of data to the remote peer.
+
sf::TcpSocket::send
Status send(const void *data, std::size_t size, std::size_t &sent)
Send raw data to the remote peer.
+
sf::TcpSocket::TcpSocket
TcpSocket()
Default constructor.
+
sf::TcpSocket::connect
Status connect(const IpAddress &remoteAddress, unsigned short remotePort, Time timeout=Time::Zero)
Connect the socket to a remote peer.
+
sf::TcpSocket::receive
Status receive(void *data, std::size_t size, std::size_t &received)
Receive raw data from the remote peer.
+
sf::TcpSocket::getRemotePort
unsigned short getRemotePort() const
Get the port of the connected peer to which the socket is connected.
+
sf::TcpSocket::getLocalPort
unsigned short getLocalPort() const
Get the port to which the socket is bound locally.
+
sf::TcpSocket::receive
Status receive(Packet &packet)
Receive a formatted packet of data from the remote peer.
+
sf::TcpSocket::getRemoteAddress
IpAddress getRemoteAddress() const
Get the address of the connected peer.
+
sf::TcpSocket::disconnect
void disconnect()
Disconnect the socket from its remote peer.
+
sf::TcpSocket::send
Status send(const void *data, std::size_t size)
Send raw data to the remote peer.
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Text_8hpp_source.html b/Space-Invaders/sfml/doc/html/Text_8hpp_source.html new file mode 100644 index 000000000..c31ec3aaf --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Text_8hpp_source.html @@ -0,0 +1,272 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Text.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_TEXT_HPP
+
26#define SFML_TEXT_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Drawable.hpp>
+
33#include <SFML/Graphics/Transformable.hpp>
+
34#include <SFML/Graphics/Font.hpp>
+
35#include <SFML/Graphics/Rect.hpp>
+
36#include <SFML/Graphics/VertexArray.hpp>
+
37#include <SFML/System/String.hpp>
+
38#include <string>
+
39#include <vector>
+
40
+
41
+
42namespace sf
+
43{
+
48class SFML_GRAPHICS_API Text : public Drawable, public Transformable
+
49{
+
50public:
+
51
+
56 enum Style
+
57 {
+
58 Regular = 0,
+
59 Bold = 1 << 0,
+
60 Italic = 1 << 1,
+
61 Underlined = 1 << 2,
+
62 StrikeThrough = 1 << 3
+
63 };
+
64
+
71 Text();
+
72
+
88 Text(const String& string, const Font& font, unsigned int characterSize = 30);
+
89
+
109 void setString(const String& string);
+
110
+
126 void setFont(const Font& font);
+
127
+
145 void setCharacterSize(unsigned int size);
+
146
+
159 void setLineSpacing(float spacingFactor);
+
160
+
178 void setLetterSpacing(float spacingFactor);
+
179
+
192 void setStyle(Uint32 style);
+
193
+
210 SFML_DEPRECATED void setColor(const Color& color);
+
211
+
224 void setFillColor(const Color& color);
+
225
+
236 void setOutlineColor(const Color& color);
+
237
+
251 void setOutlineThickness(float thickness);
+
252
+
270 const String& getString() const;
+
271
+
284 const Font* getFont() const;
+
285
+
294 unsigned int getCharacterSize() const;
+
295
+
304 float getLetterSpacing() const;
+
305
+
314 float getLineSpacing() const;
+
315
+
324 Uint32 getStyle() const;
+
325
+
338 SFML_DEPRECATED const Color& getColor() const;
+
339
+
348 const Color& getFillColor() const;
+
349
+
358 const Color& getOutlineColor() const;
+
359
+
368 float getOutlineThickness() const;
+
369
+
385 Vector2f findCharacterPos(std::size_t index) const;
+
386
+
399 FloatRect getLocalBounds() const;
+
400
+
413 FloatRect getGlobalBounds() const;
+
414
+
415private:
+
416
+
424 virtual void draw(RenderTarget& target, RenderStates states) const;
+
425
+
433 void ensureGeometryUpdate() const;
+
434
+
436 // Member data
+
438 String m_string;
+
439 const Font* m_font;
+
440 unsigned int m_characterSize;
+
441 float m_letterSpacingFactor;
+
442 float m_lineSpacingFactor;
+
443 Uint32 m_style;
+
444 Color m_fillColor;
+
445 Color m_outlineColor;
+
446 float m_outlineThickness;
+
447 mutable VertexArray m_vertices;
+
448 mutable VertexArray m_outlineVertices;
+
449 mutable FloatRect m_bounds;
+
450 mutable bool m_geometryNeedUpdate;
+
451 mutable Uint64 m_fontTextureId;
+
452};
+
453
+
454} // namespace sf
+
455
+
456
+
457#endif // SFML_TEXT_HPP
+
458
+
459
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+
sf::Drawable
Abstract base class for objects that can be drawn to a render target.
Definition: Drawable.hpp:45
+
sf::Font
Class for loading and manipulating character fonts.
Definition: Font.hpp:49
+ +
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+
sf::Text
Graphical text that can be drawn to a render target.
Definition: Text.hpp:49
+
sf::Text::getLetterSpacing
float getLetterSpacing() const
Get the size of the letter spacing factor.
+
sf::Text::getStyle
Uint32 getStyle() const
Get the text's style.
+
sf::Text::getFillColor
const Color & getFillColor() const
Get the fill color of the text.
+
sf::Text::setFont
void setFont(const Font &font)
Set the text's font.
+
sf::Text::findCharacterPos
Vector2f findCharacterPos(std::size_t index) const
Return the position of the index-th character.
+
sf::Text::getLocalBounds
FloatRect getLocalBounds() const
Get the local bounding rectangle of the entity.
+
sf::Text::getCharacterSize
unsigned int getCharacterSize() const
Get the character size.
+
sf::Text::Text
Text(const String &string, const Font &font, unsigned int characterSize=30)
Construct the text from a string, font and size.
+
sf::Text::getLineSpacing
float getLineSpacing() const
Get the size of the line spacing factor.
+
sf::Text::setString
void setString(const String &string)
Set the text's string.
+
sf::Text::setOutlineColor
void setOutlineColor(const Color &color)
Set the outline color of the text.
+
sf::Text::Style
Style
Enumeration of the string drawing styles.
Definition: Text.hpp:57
+
sf::Text::setOutlineThickness
void setOutlineThickness(float thickness)
Set the thickness of the text's outline.
+
sf::Text::getString
const String & getString() const
Get the text's string.
+
sf::Text::getColor
const Color & getColor() const
Get the fill color of the text.
+
sf::Text::setLetterSpacing
void setLetterSpacing(float spacingFactor)
Set the letter spacing factor.
+
sf::Text::setFillColor
void setFillColor(const Color &color)
Set the fill color of the text.
+
sf::Text::getGlobalBounds
FloatRect getGlobalBounds() const
Get the global bounding rectangle of the entity.
+
sf::Text::setStyle
void setStyle(Uint32 style)
Set the text's style.
+
sf::Text::getFont
const Font * getFont() const
Get the text's font.
+
sf::Text::getOutlineColor
const Color & getOutlineColor() const
Get the outline color of the text.
+
sf::Text::setCharacterSize
void setCharacterSize(unsigned int size)
Set the character size.
+
sf::Text::setLineSpacing
void setLineSpacing(float spacingFactor)
Set the line spacing factor.
+
sf::Text::getOutlineThickness
float getOutlineThickness() const
Get the outline thickness of the text.
+
sf::Text::setColor
void setColor(const Color &color)
Set the fill color of the text.
+
sf::Text::Text
Text()
Default constructor.
+
sf::Transformable
Decomposed transform defined by a position, a rotation and a scale.
Definition: Transformable.hpp:42
+ +
sf::VertexArray
Define a set of one or more 2D primitives.
Definition: VertexArray.hpp:46
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Texture_8hpp_source.html b/Space-Invaders/sfml/doc/html/Texture_8hpp_source.html new file mode 100644 index 000000000..870371d1e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Texture_8hpp_source.html @@ -0,0 +1,284 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Texture.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_TEXTURE_HPP
+
26#define SFML_TEXTURE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Image.hpp>
+
33#include <SFML/Window/GlResource.hpp>
+
34
+
35
+
36namespace sf
+
37{
+
38class InputStream;
+
39class RenderTarget;
+
40class RenderTexture;
+
41class Text;
+
42class Window;
+
43
+
48class SFML_GRAPHICS_API Texture : GlResource
+
49{
+
50public:
+
51
+
56 enum CoordinateType
+
57 {
+
58 Normalized,
+
59 Pixels
+
60 };
+
61
+
62public:
+
63
+
70 Texture();
+
71
+
78 Texture(const Texture& copy);
+
79
+
84 ~Texture();
+
85
+
97 bool create(unsigned int width, unsigned int height);
+
98
+
128 bool loadFromFile(const std::string& filename, const IntRect& area = IntRect());
+
129
+
160 bool loadFromMemory(const void* data, std::size_t size, const IntRect& area = IntRect());
+
161
+
191 bool loadFromStream(InputStream& stream, const IntRect& area = IntRect());
+
192
+
215 bool loadFromImage(const Image& image, const IntRect& area = IntRect());
+
216
+
223 Vector2u getSize() const;
+
224
+
238 Image copyToImage() const;
+
239
+
256 void update(const Uint8* pixels);
+
257
+
278 void update(const Uint8* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y);
+
279
+
298 void update(const Texture& texture);
+
299
+
315 void update(const Texture& texture, unsigned int x, unsigned int y);
+
316
+
335 void update(const Image& image);
+
336
+
352 void update(const Image& image, unsigned int x, unsigned int y);
+
353
+
372 void update(const Window& window);
+
373
+
389 void update(const Window& window, unsigned int x, unsigned int y);
+
390
+
405 void setSmooth(bool smooth);
+
406
+
415 bool isSmooth() const;
+
416
+
440 void setSrgb(bool sRgb);
+
441
+
450 bool isSrgb() const;
+
451
+
474 void setRepeated(bool repeated);
+
475
+
484 bool isRepeated() const;
+
485
+
509 bool generateMipmap();
+
510
+
519 Texture& operator =(const Texture& right);
+
520
+
527 void swap(Texture& right);
+
528
+
539 unsigned int getNativeHandle() const;
+
540
+
572 static void bind(const Texture* texture, CoordinateType coordinateType = Normalized);
+
573
+
584 static unsigned int getMaximumSize();
+
585
+
586private:
+
587
+
588 friend class Text;
+
589 friend class RenderTexture;
+
590 friend class RenderTarget;
+
591
+
605 static unsigned int getValidSize(unsigned int size);
+
606
+
614 void invalidateMipmap();
+
615
+
617 // Member data
+
619 Vector2u m_size;
+
620 Vector2u m_actualSize;
+
621 unsigned int m_texture;
+
622 bool m_isSmooth;
+
623 bool m_sRgb;
+
624 bool m_isRepeated;
+
625 mutable bool m_pixelsFlipped;
+
626 bool m_fboAttachment;
+
627 bool m_hasMipmap;
+
628 Uint64 m_cacheId;
+
629};
+
630
+
631} // namespace sf
+
632
+
633
+
634#endif // SFML_TEXTURE_HPP
+
635
+
sf::GlResource
Base class for classes that require an OpenGL context.
Definition: GlResource.hpp:47
+
sf::Image
Class for loading, manipulating and saving images.
Definition: Image.hpp:47
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+ +
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::RenderTexture
Target for off-screen 2D rendering into a texture.
Definition: RenderTexture.hpp:49
+
sf::Text
Graphical text that can be drawn to a render target.
Definition: Text.hpp:49
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Texture::update
void update(const Image &image)
Update the texture from an image.
+
sf::Texture::getMaximumSize
static unsigned int getMaximumSize()
Get the maximum texture size allowed.
+
sf::Texture::setSmooth
void setSmooth(bool smooth)
Enable or disable the smooth filter.
+
sf::Texture::update
void update(const Uint8 *pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y)
Update a part of the texture from an array of pixels.
+
sf::Texture::update
void update(const Window &window, unsigned int x, unsigned int y)
Update a part of the texture from the contents of a window.
+
sf::Texture::loadFromMemory
bool loadFromMemory(const void *data, std::size_t size, const IntRect &area=IntRect())
Load the texture from a file in memory.
+
sf::Texture::Texture
Texture()
Default constructor.
+
sf::Texture::isSmooth
bool isSmooth() const
Tell whether the smooth filter is enabled or not.
+
sf::Texture::Texture
Texture(const Texture &copy)
Copy constructor.
+
sf::Texture::getNativeHandle
unsigned int getNativeHandle() const
Get the underlying OpenGL handle of the texture.
+
sf::Texture::generateMipmap
bool generateMipmap()
Generate a mipmap using the current texture data.
+
sf::Texture::copyToImage
Image copyToImage() const
Copy the texture pixels to an image.
+
sf::Texture::loadFromStream
bool loadFromStream(InputStream &stream, const IntRect &area=IntRect())
Load the texture from a custom stream.
+
sf::Texture::update
void update(const Image &image, unsigned int x, unsigned int y)
Update a part of the texture from an image.
+
sf::Texture::create
bool create(unsigned int width, unsigned int height)
Create the texture.
+
sf::Texture::update
void update(const Texture &texture, unsigned int x, unsigned int y)
Update a part of this texture from another texture.
+
sf::Texture::loadFromFile
bool loadFromFile(const std::string &filename, const IntRect &area=IntRect())
Load the texture from a file on disk.
+
sf::Texture::swap
void swap(Texture &right)
Swap the contents of this texture with those of another.
+
sf::Texture::~Texture
~Texture()
Destructor.
+
sf::Texture::isSrgb
bool isSrgb() const
Tell whether the texture source is converted from sRGB or not.
+
sf::Texture::getSize
Vector2u getSize() const
Return the size of the texture.
+
sf::Texture::CoordinateType
CoordinateType
Types of texture coordinates that can be used for rendering.
Definition: Texture.hpp:57
+
sf::Texture::Normalized
@ Normalized
Texture coordinates in range [0 .. 1].
Definition: Texture.hpp:58
+
sf::Texture::setRepeated
void setRepeated(bool repeated)
Enable or disable repeating.
+
sf::Texture::loadFromImage
bool loadFromImage(const Image &image, const IntRect &area=IntRect())
Load the texture from an image.
+
sf::Texture::update
void update(const Window &window)
Update the texture from the contents of a window.
+
sf::Texture::update
void update(const Uint8 *pixels)
Update the whole texture from an array of pixels.
+
sf::Texture::bind
static void bind(const Texture *texture, CoordinateType coordinateType=Normalized)
Bind a texture for rendering.
+
sf::Texture::isRepeated
bool isRepeated() const
Tell whether the texture is repeated or not.
+
sf::Texture::setSrgb
void setSrgb(bool sRgb)
Enable or disable conversion from sRGB.
+
sf::Texture::update
void update(const Texture &texture)
Update a part of this texture from another texture.
+ +
sf::Window
Window that serves as a target for OpenGL rendering.
Definition: Window/Window.hpp:50
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/ThreadLocalPtr_8hpp_source.html b/Space-Invaders/sfml/doc/html/ThreadLocalPtr_8hpp_source.html new file mode 100644 index 000000000..833e59d3c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/ThreadLocalPtr_8hpp_source.html @@ -0,0 +1,167 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
ThreadLocalPtr.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_THREADLOCALPTR_HPP
+
26#define SFML_THREADLOCALPTR_HPP
+
27
+
29// Headers
+
31#include <SFML/System/ThreadLocal.hpp>
+
32
+
33
+
34namespace sf
+
35{
+
40template <typename T>
+
41class ThreadLocalPtr : private ThreadLocal
+
42{
+
43public:
+
44
+
51 ThreadLocalPtr(T* value = NULL);
+
52
+
62 T& operator *() const;
+
63
+
73 T* operator ->() const;
+
74
+
82 operator T*() const;
+
83
+
92 ThreadLocalPtr<T>& operator =(T* value);
+
93
+
102 ThreadLocalPtr<T>& operator =(const ThreadLocalPtr<T>& right);
+
103};
+
104
+
105} // namespace sf
+
106
+
107#include <SFML/System/ThreadLocalPtr.inl>
+
108
+
109
+
110#endif // SFML_THREADLOCALPTR_HPP
+
111
+
112
+
sf::ThreadLocalPtr
Pointer to a thread-local variable.
Definition: ThreadLocalPtr.hpp:42
+
sf::ThreadLocalPtr::operator=
ThreadLocalPtr< T > & operator=(T *value)
Assignment operator for a raw pointer parameter.
+
sf::ThreadLocalPtr::operator->
T * operator->() const
Overload of operator ->
+
sf::ThreadLocalPtr::ThreadLocalPtr
ThreadLocalPtr(T *value=NULL)
Default constructor.
+
sf::ThreadLocalPtr::operator*
T & operator*() const
Overload of unary operator *.
+
sf::ThreadLocal
Defines variables with thread-local storage.
Definition: ThreadLocal.hpp:48
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/ThreadLocal_8hpp_source.html b/Space-Invaders/sfml/doc/html/ThreadLocal_8hpp_source.html new file mode 100644 index 000000000..bb1eb9653 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/ThreadLocal_8hpp_source.html @@ -0,0 +1,172 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
ThreadLocal.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_THREADLOCAL_HPP
+
26#define SFML_THREADLOCAL_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Export.hpp>
+
32#include <SFML/System/NonCopyable.hpp>
+
33#include <cstdlib>
+
34
+
35
+
36namespace sf
+
37{
+
38namespace priv
+
39{
+
40 class ThreadLocalImpl;
+
41}
+
42
+
47class SFML_SYSTEM_API ThreadLocal : NonCopyable
+
48{
+
49public:
+
50
+
57 ThreadLocal(void* value = NULL);
+
58
+
63 ~ThreadLocal();
+
64
+
71 void setValue(void* value);
+
72
+
79 void* getValue() const;
+
80
+
81private:
+
82
+
84 // Member data
+
86 priv::ThreadLocalImpl* m_impl;
+
87};
+
88
+
89} // namespace sf
+
90
+
91
+
92#endif // SFML_THREADLOCAL_HPP
+
93
+
94
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::ThreadLocal
Defines variables with thread-local storage.
Definition: ThreadLocal.hpp:48
+
sf::ThreadLocal::getValue
void * getValue() const
Retrieve the thread-specific value of the variable.
+
sf::ThreadLocal::ThreadLocal
ThreadLocal(void *value=NULL)
Default constructor.
+
sf::ThreadLocal::setValue
void setValue(void *value)
Set the thread-specific value of the variable.
+
sf::ThreadLocal::~ThreadLocal
~ThreadLocal()
Destructor.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Thread_8hpp_source.html b/Space-Invaders/sfml/doc/html/Thread_8hpp_source.html new file mode 100644 index 000000000..8bdb19e06 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Thread_8hpp_source.html @@ -0,0 +1,191 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Thread.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_THREAD_HPP
+
26#define SFML_THREAD_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Export.hpp>
+
32#include <SFML/System/NonCopyable.hpp>
+
33#include <cstdlib>
+
34
+
35
+
36namespace sf
+
37{
+
38namespace priv
+
39{
+
40 class ThreadImpl;
+
41 struct ThreadFunc;
+
42}
+
43
+
48class SFML_SYSTEM_API Thread : NonCopyable
+
49{
+
50public:
+
51
+
74 template <typename F>
+
75 Thread(F function);
+
76
+
102 template <typename F, typename A>
+
103 Thread(F function, A argument);
+
104
+
125 template <typename C>
+
126 Thread(void(C::*function)(), C* object);
+
127
+
135 ~Thread();
+
136
+
146 void launch();
+
147
+
159 void wait();
+
160
+
172 void terminate();
+
173
+
174private:
+
175
+
176 friend class priv::ThreadImpl;
+
177
+
184 void run();
+
185
+
187 // Member data
+
189 priv::ThreadImpl* m_impl;
+
190 priv::ThreadFunc* m_entryPoint;
+
191};
+
192
+
193#include <SFML/System/Thread.inl>
+
194
+
195} // namespace sf
+
196
+
197#endif // SFML_THREAD_HPP
+
198
+
199
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::Thread
Utility class to manipulate threads.
Definition: Thread.hpp:49
+
sf::Thread::Thread
Thread(F function)
Construct the thread from a functor with no argument.
+
sf::Thread::Thread
Thread(F function, A argument)
Construct the thread from a functor with an argument.
+
sf::Thread::wait
void wait()
Wait until the thread finishes.
+
sf::Thread::launch
void launch()
Run the thread.
+
sf::Thread::Thread
Thread(void(C::*function)(), C *object)
Construct the thread from a member function and an object.
+
sf::Thread::terminate
void terminate()
Terminate the thread.
+
sf::Thread::~Thread
~Thread()
Destructor.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Time_8hpp_source.html b/Space-Invaders/sfml/doc/html/Time_8hpp_source.html new file mode 100644 index 000000000..0be22cc48 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Time_8hpp_source.html @@ -0,0 +1,233 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Time.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_TIME_HPP
+
26#define SFML_TIME_HPP
+
27
+
29// Headers
+
31#include <SFML/System/Export.hpp>
+
32
+
33
+
34namespace sf
+
35{
+
40class SFML_SYSTEM_API Time
+
41{
+
42public:
+
43
+
50 Time();
+
51
+
60 float asSeconds() const;
+
61
+
70 Int32 asMilliseconds() const;
+
71
+
80 Int64 asMicroseconds() const;
+
81
+
83 // Static member data
+
85 static const Time Zero;
+
86
+
87private:
+
88
+
89 friend SFML_SYSTEM_API Time seconds(float);
+
90 friend SFML_SYSTEM_API Time milliseconds(Int32);
+
91 friend SFML_SYSTEM_API Time microseconds(Int64);
+
92
+
102 explicit Time(Int64 microseconds);
+
103
+
104private:
+
105
+
107 // Member data
+
109 Int64 m_microseconds;
+
110};
+
111
+
123SFML_SYSTEM_API Time seconds(float amount);
+
124
+
136SFML_SYSTEM_API Time milliseconds(Int32 amount);
+
137
+
149SFML_SYSTEM_API Time microseconds(Int64 amount);
+
150
+
161SFML_SYSTEM_API bool operator ==(Time left, Time right);
+
162
+
173SFML_SYSTEM_API bool operator !=(Time left, Time right);
+
174
+
185SFML_SYSTEM_API bool operator <(Time left, Time right);
+
186
+
197SFML_SYSTEM_API bool operator >(Time left, Time right);
+
198
+
209SFML_SYSTEM_API bool operator <=(Time left, Time right);
+
210
+
221SFML_SYSTEM_API bool operator >=(Time left, Time right);
+
222
+
232SFML_SYSTEM_API Time operator -(Time right);
+
233
+
244SFML_SYSTEM_API Time operator +(Time left, Time right);
+
245
+
256SFML_SYSTEM_API Time& operator +=(Time& left, Time right);
+
257
+
268SFML_SYSTEM_API Time operator -(Time left, Time right);
+
269
+
280SFML_SYSTEM_API Time& operator -=(Time& left, Time right);
+
281
+
292SFML_SYSTEM_API Time operator *(Time left, float right);
+
293
+
304SFML_SYSTEM_API Time operator *(Time left, Int64 right);
+
305
+
316SFML_SYSTEM_API Time operator *(float left, Time right);
+
317
+
328SFML_SYSTEM_API Time operator *(Int64 left, Time right);
+
329
+
340SFML_SYSTEM_API Time& operator *=(Time& left, float right);
+
341
+
352SFML_SYSTEM_API Time& operator *=(Time& left, Int64 right);
+
353
+
364SFML_SYSTEM_API Time operator /(Time left, float right);
+
365
+
376SFML_SYSTEM_API Time operator /(Time left, Int64 right);
+
377
+
388SFML_SYSTEM_API Time& operator /=(Time& left, float right);
+
389
+
400SFML_SYSTEM_API Time& operator /=(Time& left, Int64 right);
+
401
+
412SFML_SYSTEM_API float operator /(Time left, Time right);
+
413
+
424SFML_SYSTEM_API Time operator %(Time left, Time right);
+
425
+
436SFML_SYSTEM_API Time& operator %=(Time& left, Time right);
+
437
+
438} // namespace sf
+
439
+
440
+
441#endif // SFML_TIME_HPP
+
442
+
443
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
sf::Time::asMicroseconds
Int64 asMicroseconds() const
Return the time value as a number of microseconds.
+
sf::Time::microseconds
Time microseconds(Int64 amount)
Construct a time value from a number of microseconds.
+
sf::Time::Zero
static const Time Zero
Predefined "zero" time value.
Definition: Time.hpp:85
+
sf::Time::milliseconds
Time milliseconds(Int32 amount)
Construct a time value from a number of milliseconds.
+
sf::Time::asMilliseconds
Int32 asMilliseconds() const
Return the time value as a number of milliseconds.
+
sf::Time::asSeconds
float asSeconds() const
Return the time value as a number of seconds.
+
sf::Time::Time
Time()
Default constructor.
+
sf::Time::seconds
Time seconds(float amount)
Construct a time value from a number of seconds.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Touch_8hpp_source.html b/Space-Invaders/sfml/doc/html/Touch_8hpp_source.html new file mode 100644 index 000000000..869b454eb --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Touch_8hpp_source.html @@ -0,0 +1,161 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Touch.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_TOUCH_HPP
+
26#define SFML_TOUCH_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32#include <SFML/System/Vector2.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
37class WindowBase;
+
38
+
43class SFML_WINDOW_API Touch
+
44{
+
45public:
+
46
+
55 static bool isDown(unsigned int finger);
+
56
+
68 static Vector2i getPosition(unsigned int finger);
+
69
+
82 static Vector2i getPosition(unsigned int finger, const WindowBase& relativeTo);
+
83};
+
84
+
85} // namespace sf
+
86
+
87
+
88#endif // SFML_TOUCH_HPP
+
89
+
90
+
sf::Touch
Give access to the real-time state of the touches.
Definition: Touch.hpp:44
+
sf::Touch::isDown
static bool isDown(unsigned int finger)
Check if a touch event is currently down.
+
sf::Touch::getPosition
static Vector2i getPosition(unsigned int finger, const WindowBase &relativeTo)
Get the current position of a touch in window coordinates.
+
sf::Touch::getPosition
static Vector2i getPosition(unsigned int finger)
Get the current position of a touch in desktop coordinates.
+
sf::Vector2
Utility template class for manipulating 2-dimensional vectors.
Definition: Vector2.hpp:38
+
sf::WindowBase
Window that serves as a base for other windows.
Definition: WindowBase.hpp:57
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Transform_8hpp_source.html b/Space-Invaders/sfml/doc/html/Transform_8hpp_source.html new file mode 100644 index 000000000..6f351a43a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Transform_8hpp_source.html @@ -0,0 +1,223 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Transform.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_TRANSFORM_HPP
+
26#define SFML_TRANSFORM_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Rect.hpp>
+
33#include <SFML/System/Vector2.hpp>
+
34
+
35
+
36namespace sf
+
37{
+
42class SFML_GRAPHICS_API Transform
+
43{
+
44public:
+
45
+
52 Transform();
+
53
+
68 Transform(float a00, float a01, float a02,
+
69 float a10, float a11, float a12,
+
70 float a20, float a21, float a22);
+
71
+
87 const float* getMatrix() const;
+
88
+
98 Transform getInverse() const;
+
99
+
115 Vector2f transformPoint(float x, float y) const;
+
116
+
131 Vector2f transformPoint(const Vector2f& point) const;
+
132
+
147 FloatRect transformRect(const FloatRect& rectangle) const;
+
148
+
167 Transform& combine(const Transform& transform);
+
168
+
187 Transform& translate(float x, float y);
+
188
+
206 Transform& translate(const Vector2f& offset);
+
207
+
225 Transform& rotate(float angle);
+
226
+
251 Transform& rotate(float angle, float centerX, float centerY);
+
252
+
276 Transform& rotate(float angle, const Vector2f& center);
+
277
+
296 Transform& scale(float scaleX, float scaleY);
+
297
+
323 Transform& scale(float scaleX, float scaleY, float centerX, float centerY);
+
324
+
342 Transform& scale(const Vector2f& factors);
+
343
+
367 Transform& scale(const Vector2f& factors, const Vector2f& center);
+
368
+
370 // Static member data
+
372 static const Transform Identity;
+
373
+
374private:
+
375
+
377 // Member data
+
379 float m_matrix[16];
+
380};
+
381
+
394SFML_GRAPHICS_API Transform operator *(const Transform& left, const Transform& right);
+
395
+
408SFML_GRAPHICS_API Transform& operator *=(Transform& left, const Transform& right);
+
409
+
422SFML_GRAPHICS_API Vector2f operator *(const Transform& left, const Vector2f& right);
+
423
+
437SFML_GRAPHICS_API bool operator ==(const Transform& left, const Transform& right);
+
438
+
451SFML_GRAPHICS_API bool operator !=(const Transform& left, const Transform& right);
+
452
+
453} // namespace sf
+
454
+
455
+
456#endif // SFML_TRANSFORM_HPP
+
457
+
458
+ +
sf::Transform
Define a 3x3 transform matrix.
Definition: Transform.hpp:43
+
sf::Transform::translate
Transform & translate(float x, float y)
Combine the current transform with a translation.
+
sf::Transform::rotate
Transform & rotate(float angle, const Vector2f &center)
Combine the current transform with a rotation.
+
sf::Transform::getInverse
Transform getInverse() const
Return the inverse of the transform.
+
sf::Transform::scale
Transform & scale(const Vector2f &factors)
Combine the current transform with a scaling.
+
sf::Transform::translate
Transform & translate(const Vector2f &offset)
Combine the current transform with a translation.
+
sf::Transform::transformRect
FloatRect transformRect(const FloatRect &rectangle) const
Transform a rectangle.
+
sf::Transform::scale
Transform & scale(const Vector2f &factors, const Vector2f &center)
Combine the current transform with a scaling.
+
sf::Transform::Transform
Transform(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22)
Construct a transform from a 3x3 matrix.
+
sf::Transform::scale
Transform & scale(float scaleX, float scaleY)
Combine the current transform with a scaling.
+
sf::Transform::Identity
static const Transform Identity
The identity transform (does nothing)
Definition: Transform.hpp:372
+
sf::Transform::transformPoint
Vector2f transformPoint(const Vector2f &point) const
Transform a 2D point.
+
sf::Transform::getMatrix
const float * getMatrix() const
Return the transform as a 4x4 matrix.
+
sf::Transform::Transform
Transform()
Default constructor.
+
sf::Transform::rotate
Transform & rotate(float angle)
Combine the current transform with a rotation.
+
sf::Transform::rotate
Transform & rotate(float angle, float centerX, float centerY)
Combine the current transform with a rotation.
+
sf::Transform::combine
Transform & combine(const Transform &transform)
Combine the current transform with another one.
+
sf::Transform::scale
Transform & scale(float scaleX, float scaleY, float centerX, float centerY)
Combine the current transform with a scaling.
+
sf::Transform::transformPoint
Vector2f transformPoint(float x, float y) const
Transform a 2D point.
+ +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Transformable_8hpp_source.html b/Space-Invaders/sfml/doc/html/Transformable_8hpp_source.html new file mode 100644 index 000000000..ba6fd0c91 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Transformable_8hpp_source.html @@ -0,0 +1,222 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Transformable.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_TRANSFORMABLE_HPP
+
26#define SFML_TRANSFORMABLE_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Transform.hpp>
+
33
+
34
+
35namespace sf
+
36{
+
41class SFML_GRAPHICS_API Transformable
+
42{
+
43public:
+
44
+
49 Transformable();
+
50
+
55 virtual ~Transformable();
+
56
+
70 void setPosition(float x, float y);
+
71
+
84 void setPosition(const Vector2f& position);
+
85
+
98 void setRotation(float angle);
+
99
+
113 void setScale(float factorX, float factorY);
+
114
+
127 void setScale(const Vector2f& factors);
+
128
+
145 void setOrigin(float x, float y);
+
146
+
162 void setOrigin(const Vector2f& origin);
+
163
+
172 const Vector2f& getPosition() const;
+
173
+
184 float getRotation() const;
+
185
+
194 const Vector2f& getScale() const;
+
195
+
204 const Vector2f& getOrigin() const;
+
205
+
223 void move(float offsetX, float offsetY);
+
224
+
240 void move(const Vector2f& offset);
+
241
+
255 void rotate(float angle);
+
256
+
274 void scale(float factorX, float factorY);
+
275
+
292 void scale(const Vector2f& factor);
+
293
+
302 const Transform& getTransform() const;
+
303
+
312 const Transform& getInverseTransform() const;
+
313
+
314private:
+
315
+
317 // Member data
+
319 Vector2f m_origin;
+
320 Vector2f m_position;
+
321 float m_rotation;
+
322 Vector2f m_scale;
+
323 mutable Transform m_transform;
+
324 mutable bool m_transformNeedUpdate;
+
325 mutable Transform m_inverseTransform;
+
326 mutable bool m_inverseTransformNeedUpdate;
+
327};
+
328
+
329} // namespace sf
+
330
+
331
+
332#endif // SFML_TRANSFORMABLE_HPP
+
333
+
334
+
sf::Transform
Define a 3x3 transform matrix.
Definition: Transform.hpp:43
+
sf::Transformable
Decomposed transform defined by a position, a rotation and a scale.
Definition: Transformable.hpp:42
+
sf::Transformable::setRotation
void setRotation(float angle)
set the orientation of the object
+
sf::Transformable::scale
void scale(float factorX, float factorY)
Scale the object.
+
sf::Transformable::getTransform
const Transform & getTransform() const
get the combined transform of the object
+
sf::Transformable::~Transformable
virtual ~Transformable()
Virtual destructor.
+
sf::Transformable::setScale
void setScale(const Vector2f &factors)
set the scale factors of the object
+
sf::Transformable::setPosition
void setPosition(float x, float y)
set the position of the object
+
sf::Transformable::setOrigin
void setOrigin(float x, float y)
set the local origin of the object
+
sf::Transformable::getScale
const Vector2f & getScale() const
get the current scale of the object
+
sf::Transformable::move
void move(float offsetX, float offsetY)
Move the object by a given offset.
+
sf::Transformable::getOrigin
const Vector2f & getOrigin() const
get the local origin of the object
+
sf::Transformable::getRotation
float getRotation() const
get the orientation of the object
+
sf::Transformable::setOrigin
void setOrigin(const Vector2f &origin)
set the local origin of the object
+
sf::Transformable::setScale
void setScale(float factorX, float factorY)
set the scale factors of the object
+
sf::Transformable::move
void move(const Vector2f &offset)
Move the object by a given offset.
+
sf::Transformable::getInverseTransform
const Transform & getInverseTransform() const
get the inverse of the combined transform of the object
+
sf::Transformable::scale
void scale(const Vector2f &factor)
Scale the object.
+
sf::Transformable::Transformable
Transformable()
Default constructor.
+
sf::Transformable::getPosition
const Vector2f & getPosition() const
get the position of the object
+
sf::Transformable::setPosition
void setPosition(const Vector2f &position)
set the position of the object
+
sf::Transformable::rotate
void rotate(float angle)
Rotate the object.
+ +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/UdpSocket_8hpp_source.html b/Space-Invaders/sfml/doc/html/UdpSocket_8hpp_source.html new file mode 100644 index 000000000..649ba3dd7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/UdpSocket_8hpp_source.html @@ -0,0 +1,191 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
UdpSocket.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_UDPSOCKET_HPP
+
26#define SFML_UDPSOCKET_HPP
+
27
+
29// Headers
+
31#include <SFML/Network/Export.hpp>
+
32#include <SFML/Network/Socket.hpp>
+
33#include <SFML/Network/IpAddress.hpp>
+
34#include <vector>
+
35
+
36
+
37namespace sf
+
38{
+
39class Packet;
+
40
+
45class SFML_NETWORK_API UdpSocket : public Socket
+
46{
+
47public:
+
48
+
50 // Constants
+
52 enum
+
53 {
+
54 MaxDatagramSize = 65507
+
55 };
+
56
+
61 UdpSocket();
+
62
+
74 unsigned short getLocalPort() const;
+
75
+
99 Status bind(unsigned short port, const IpAddress& address = IpAddress::Any);
+
100
+
113 void unbind();
+
114
+
132 Status send(const void* data, std::size_t size, const IpAddress& remoteAddress, unsigned short remotePort);
+
133
+
155 Status receive(void* data, std::size_t size, std::size_t& received, IpAddress& remoteAddress, unsigned short& remotePort);
+
156
+
173 Status send(Packet& packet, const IpAddress& remoteAddress, unsigned short remotePort);
+
174
+
190 Status receive(Packet& packet, IpAddress& remoteAddress, unsigned short& remotePort);
+
191
+
192private:
+
193
+
195 // Member data
+
197 std::vector<char> m_buffer;
+
198};
+
199
+
200} // namespace sf
+
201
+
202
+
203#endif // SFML_UDPSOCKET_HPP
+
204
+
205
+
sf::IpAddress
Encapsulate an IPv4 network address.
Definition: IpAddress.hpp:45
+
sf::Packet
Utility class to build blocks of data to transfer over the network.
Definition: Packet.hpp:48
+
sf::Socket
Base class for all the socket types.
Definition: Socket.hpp:46
+
sf::Socket::Status
Status
Status codes that may be returned by socket functions.
Definition: Socket.hpp:54
+
sf::UdpSocket
Specialized socket using the UDP protocol.
Definition: UdpSocket.hpp:46
+
sf::UdpSocket::unbind
void unbind()
Unbind the socket from the local port to which it is bound.
+
sf::UdpSocket::send
Status send(Packet &packet, const IpAddress &remoteAddress, unsigned short remotePort)
Send a formatted packet of data to a remote peer.
+
sf::UdpSocket::getLocalPort
unsigned short getLocalPort() const
Get the port to which the socket is bound locally.
+
sf::UdpSocket::send
Status send(const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort)
Send raw data to a remote peer.
+
sf::UdpSocket::UdpSocket
UdpSocket()
Default constructor.
+
sf::UdpSocket::bind
Status bind(unsigned short port, const IpAddress &address=IpAddress::Any)
Bind the socket to a specific port.
+
sf::UdpSocket::receive
Status receive(void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort)
Receive raw data from a remote peer.
+
sf::UdpSocket::receive
Status receive(Packet &packet, IpAddress &remoteAddress, unsigned short &remotePort)
Receive a formatted packet of data from a remote peer.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Utf_8hpp_source.html b/Space-Invaders/sfml/doc/html/Utf_8hpp_source.html new file mode 100644 index 000000000..96a04755f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Utf_8hpp_source.html @@ -0,0 +1,349 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Utf.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_UTF_HPP
+
26#define SFML_UTF_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32#include <algorithm>
+
33#include <locale>
+
34#include <string>
+
35#include <cstdlib>
+
36
+
37
+
38namespace sf
+
39{
+
40template <unsigned int N>
+
41class Utf;
+
42
+
47template <>
+
48class Utf<8>
+
49{
+
50public:
+
51
+
66 template <typename In>
+
67 static In decode(In begin, In end, Uint32& output, Uint32 replacement = 0);
+
68
+
82 template <typename Out>
+
83 static Out encode(Uint32 input, Out output, Uint8 replacement = 0);
+
84
+
97 template <typename In>
+
98 static In next(In begin, In end);
+
99
+
113 template <typename In>
+
114 static std::size_t count(In begin, In end);
+
115
+
130 template <typename In, typename Out>
+
131 static Out fromAnsi(In begin, In end, Out output, const std::locale& locale = std::locale());
+
132
+
143 template <typename In, typename Out>
+
144 static Out fromWide(In begin, In end, Out output);
+
145
+
156 template <typename In, typename Out>
+
157 static Out fromLatin1(In begin, In end, Out output);
+
158
+
174 template <typename In, typename Out>
+
175 static Out toAnsi(In begin, In end, Out output, char replacement = 0, const std::locale& locale = std::locale());
+
176
+
188 template <typename In, typename Out>
+
189 static Out toWide(In begin, In end, Out output, wchar_t replacement = 0);
+
190
+
202 template <typename In, typename Out>
+
203 static Out toLatin1(In begin, In end, Out output, char replacement = 0);
+
204
+
220 template <typename In, typename Out>
+
221 static Out toUtf8(In begin, In end, Out output);
+
222
+
233 template <typename In, typename Out>
+
234 static Out toUtf16(In begin, In end, Out output);
+
235
+
246 template <typename In, typename Out>
+
247 static Out toUtf32(In begin, In end, Out output);
+
248};
+
249
+
254template <>
+
255class Utf<16>
+
256{
+
257public:
+
258
+
273 template <typename In>
+
274 static In decode(In begin, In end, Uint32& output, Uint32 replacement = 0);
+
275
+
289 template <typename Out>
+
290 static Out encode(Uint32 input, Out output, Uint16 replacement = 0);
+
291
+
304 template <typename In>
+
305 static In next(In begin, In end);
+
306
+
320 template <typename In>
+
321 static std::size_t count(In begin, In end);
+
322
+
337 template <typename In, typename Out>
+
338 static Out fromAnsi(In begin, In end, Out output, const std::locale& locale = std::locale());
+
339
+
350 template <typename In, typename Out>
+
351 static Out fromWide(In begin, In end, Out output);
+
352
+
363 template <typename In, typename Out>
+
364 static Out fromLatin1(In begin, In end, Out output);
+
365
+
381 template <typename In, typename Out>
+
382 static Out toAnsi(In begin, In end, Out output, char replacement = 0, const std::locale& locale = std::locale());
+
383
+
395 template <typename In, typename Out>
+
396 static Out toWide(In begin, In end, Out output, wchar_t replacement = 0);
+
397
+
409 template <typename In, typename Out>
+
410 static Out toLatin1(In begin, In end, Out output, char replacement = 0);
+
411
+
422 template <typename In, typename Out>
+
423 static Out toUtf8(In begin, In end, Out output);
+
424
+
440 template <typename In, typename Out>
+
441 static Out toUtf16(In begin, In end, Out output);
+
442
+
453 template <typename In, typename Out>
+
454 static Out toUtf32(In begin, In end, Out output);
+
455};
+
456
+
461template <>
+
462class Utf<32>
+
463{
+
464public:
+
465
+
481 template <typename In>
+
482 static In decode(In begin, In end, Uint32& output, Uint32 replacement = 0);
+
483
+
498 template <typename Out>
+
499 static Out encode(Uint32 input, Out output, Uint32 replacement = 0);
+
500
+
513 template <typename In>
+
514 static In next(In begin, In end);
+
515
+
528 template <typename In>
+
529 static std::size_t count(In begin, In end);
+
530
+
545 template <typename In, typename Out>
+
546 static Out fromAnsi(In begin, In end, Out output, const std::locale& locale = std::locale());
+
547
+
558 template <typename In, typename Out>
+
559 static Out fromWide(In begin, In end, Out output);
+
560
+
571 template <typename In, typename Out>
+
572 static Out fromLatin1(In begin, In end, Out output);
+
573
+
589 template <typename In, typename Out>
+
590 static Out toAnsi(In begin, In end, Out output, char replacement = 0, const std::locale& locale = std::locale());
+
591
+
603 template <typename In, typename Out>
+
604 static Out toWide(In begin, In end, Out output, wchar_t replacement = 0);
+
605
+
617 template <typename In, typename Out>
+
618 static Out toLatin1(In begin, In end, Out output, char replacement = 0);
+
619
+
630 template <typename In, typename Out>
+
631 static Out toUtf8(In begin, In end, Out output);
+
632
+
643 template <typename In, typename Out>
+
644 static Out toUtf16(In begin, In end, Out output);
+
645
+
661 template <typename In, typename Out>
+
662 static Out toUtf32(In begin, In end, Out output);
+
663
+
677 template <typename In>
+
678 static Uint32 decodeAnsi(In input, const std::locale& locale = std::locale());
+
679
+
692 template <typename In>
+
693 static Uint32 decodeWide(In input);
+
694
+
710 template <typename Out>
+
711 static Out encodeAnsi(Uint32 codepoint, Out output, char replacement = 0, const std::locale& locale = std::locale());
+
712
+
727 template <typename Out>
+
728 static Out encodeWide(Uint32 codepoint, Out output, wchar_t replacement = 0);
+
729};
+
730
+
731#include <SFML/System/Utf.inl>
+
732
+
733// Make typedefs to get rid of the template syntax
+
734typedef Utf<8> Utf8;
+
735typedef Utf<16> Utf16;
+
736typedef Utf<32> Utf32;
+
737
+
738} // namespace sf
+
739
+
740
+
741#endif // SFML_UTF_HPP
+
742
+
743
+
sf::Utf< 16 >
Specialization of the Utf template for UTF-16.
Definition: Utf.hpp:256
+
sf::Utf< 16 >::toUtf16
static Out toUtf16(In begin, In end, Out output)
Convert a UTF-16 characters range to UTF-16.
+
sf::Utf< 16 >::decode
static In decode(In begin, In end, Uint32 &output, Uint32 replacement=0)
Decode a single UTF-16 character.
+
sf::Utf< 16 >::fromWide
static Out fromWide(In begin, In end, Out output)
Convert a wide characters range to UTF-16.
+
sf::Utf< 16 >::toWide
static Out toWide(In begin, In end, Out output, wchar_t replacement=0)
Convert an UTF-16 characters range to wide characters.
+
sf::Utf< 16 >::encode
static Out encode(Uint32 input, Out output, Uint16 replacement=0)
Encode a single UTF-16 character.
+
sf::Utf< 16 >::fromLatin1
static Out fromLatin1(In begin, In end, Out output)
Convert a latin-1 (ISO-5589-1) characters range to UTF-16.
+
sf::Utf< 16 >::toAnsi
static Out toAnsi(In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale())
Convert an UTF-16 characters range to ANSI characters.
+
sf::Utf< 16 >::count
static std::size_t count(In begin, In end)
Count the number of characters of a UTF-16 sequence.
+
sf::Utf< 16 >::toUtf32
static Out toUtf32(In begin, In end, Out output)
Convert a UTF-16 characters range to UTF-32.
+
sf::Utf< 16 >::fromAnsi
static Out fromAnsi(In begin, In end, Out output, const std::locale &locale=std::locale())
Convert an ANSI characters range to UTF-16.
+
sf::Utf< 16 >::next
static In next(In begin, In end)
Advance to the next UTF-16 character.
+
sf::Utf< 16 >::toLatin1
static Out toLatin1(In begin, In end, Out output, char replacement=0)
Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters.
+
sf::Utf< 16 >::toUtf8
static Out toUtf8(In begin, In end, Out output)
Convert a UTF-16 characters range to UTF-8.
+
sf::Utf< 32 >
Specialization of the Utf template for UTF-32.
Definition: Utf.hpp:463
+
sf::Utf< 32 >::decodeWide
static Uint32 decodeWide(In input)
Decode a single wide character to UTF-32.
+
sf::Utf< 32 >::fromLatin1
static Out fromLatin1(In begin, In end, Out output)
Convert a latin-1 (ISO-5589-1) characters range to UTF-32.
+
sf::Utf< 32 >::toLatin1
static Out toLatin1(In begin, In end, Out output, char replacement=0)
Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters.
+
sf::Utf< 32 >::toWide
static Out toWide(In begin, In end, Out output, wchar_t replacement=0)
Convert an UTF-32 characters range to wide characters.
+
sf::Utf< 32 >::toUtf8
static Out toUtf8(In begin, In end, Out output)
Convert a UTF-32 characters range to UTF-8.
+
sf::Utf< 32 >::encode
static Out encode(Uint32 input, Out output, Uint32 replacement=0)
Encode a single UTF-32 character.
+
sf::Utf< 32 >::fromAnsi
static Out fromAnsi(In begin, In end, Out output, const std::locale &locale=std::locale())
Convert an ANSI characters range to UTF-32.
+
sf::Utf< 32 >::toUtf16
static Out toUtf16(In begin, In end, Out output)
Convert a UTF-32 characters range to UTF-16.
+
sf::Utf< 32 >::encodeWide
static Out encodeWide(Uint32 codepoint, Out output, wchar_t replacement=0)
Encode a single UTF-32 character to wide.
+
sf::Utf< 32 >::decodeAnsi
static Uint32 decodeAnsi(In input, const std::locale &locale=std::locale())
Decode a single ANSI character to UTF-32.
+
sf::Utf< 32 >::toAnsi
static Out toAnsi(In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale())
Convert an UTF-32 characters range to ANSI characters.
+
sf::Utf< 32 >::next
static In next(In begin, In end)
Advance to the next UTF-32 character.
+
sf::Utf< 32 >::count
static std::size_t count(In begin, In end)
Count the number of characters of a UTF-32 sequence.
+
sf::Utf< 32 >::toUtf32
static Out toUtf32(In begin, In end, Out output)
Convert a UTF-32 characters range to UTF-32.
+
sf::Utf< 32 >::fromWide
static Out fromWide(In begin, In end, Out output)
Convert a wide characters range to UTF-32.
+
sf::Utf< 32 >::decode
static In decode(In begin, In end, Uint32 &output, Uint32 replacement=0)
Decode a single UTF-32 character.
+
sf::Utf< 32 >::encodeAnsi
static Out encodeAnsi(Uint32 codepoint, Out output, char replacement=0, const std::locale &locale=std::locale())
Encode a single UTF-32 character to ANSI.
+
sf::Utf< 8 >
Specialization of the Utf template for UTF-8.
Definition: Utf.hpp:49
+
sf::Utf< 8 >::next
static In next(In begin, In end)
Advance to the next UTF-8 character.
+
sf::Utf< 8 >::fromAnsi
static Out fromAnsi(In begin, In end, Out output, const std::locale &locale=std::locale())
Convert an ANSI characters range to UTF-8.
+
sf::Utf< 8 >::toAnsi
static Out toAnsi(In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale())
Convert an UTF-8 characters range to ANSI characters.
+
sf::Utf< 8 >::decode
static In decode(In begin, In end, Uint32 &output, Uint32 replacement=0)
Decode a single UTF-8 character.
+
sf::Utf< 8 >::encode
static Out encode(Uint32 input, Out output, Uint8 replacement=0)
Encode a single UTF-8 character.
+
sf::Utf< 8 >::toUtf32
static Out toUtf32(In begin, In end, Out output)
Convert a UTF-8 characters range to UTF-32.
+
sf::Utf< 8 >::fromLatin1
static Out fromLatin1(In begin, In end, Out output)
Convert a latin-1 (ISO-5589-1) characters range to UTF-8.
+
sf::Utf< 8 >::toUtf16
static Out toUtf16(In begin, In end, Out output)
Convert a UTF-8 characters range to UTF-16.
+
sf::Utf< 8 >::fromWide
static Out fromWide(In begin, In end, Out output)
Convert a wide characters range to UTF-8.
+
sf::Utf< 8 >::toWide
static Out toWide(In begin, In end, Out output, wchar_t replacement=0)
Convert an UTF-8 characters range to wide characters.
+
sf::Utf< 8 >::toLatin1
static Out toLatin1(In begin, In end, Out output, char replacement=0)
Convert an UTF-8 characters range to latin-1 (ISO-5589-1) characters.
+
sf::Utf< 8 >::toUtf8
static Out toUtf8(In begin, In end, Out output)
Convert a UTF-8 characters range to UTF-8.
+
sf::Utf< 8 >::count
static std::size_t count(In begin, In end)
Count the number of characters of a UTF-8 sequence.
+
sf::Utf
Utility class providing generic functions for UTF conversions.
Definition: Utf.hpp:41
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Vector2_8hpp_source.html b/Space-Invaders/sfml/doc/html/Vector2_8hpp_source.html new file mode 100644 index 000000000..4db4781c9 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Vector2_8hpp_source.html @@ -0,0 +1,204 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Vector2.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_VECTOR2_HPP
+
26#define SFML_VECTOR2_HPP
+
27
+
28
+
29namespace sf
+
30{
+
36template <typename T>
+
37class Vector2
+
38{
+
39public:
+
40
+
47 Vector2();
+
48
+
56 Vector2(T X, T Y);
+
57
+
69 template <typename U>
+
70 explicit Vector2(const Vector2<U>& vector);
+
71
+
73 // Member data
+
75 T x;
+
76 T y;
+
77};
+
78
+
88template <typename T>
+
89Vector2<T> operator -(const Vector2<T>& right);
+
90
+
104template <typename T>
+
105Vector2<T>& operator +=(Vector2<T>& left, const Vector2<T>& right);
+
106
+
120template <typename T>
+
121Vector2<T>& operator -=(Vector2<T>& left, const Vector2<T>& right);
+
122
+
133template <typename T>
+
134Vector2<T> operator +(const Vector2<T>& left, const Vector2<T>& right);
+
135
+
146template <typename T>
+
147Vector2<T> operator -(const Vector2<T>& left, const Vector2<T>& right);
+
148
+
159template <typename T>
+
160Vector2<T> operator *(const Vector2<T>& left, T right);
+
161
+
172template <typename T>
+
173Vector2<T> operator *(T left, const Vector2<T>& right);
+
174
+
188template <typename T>
+
189Vector2<T>& operator *=(Vector2<T>& left, T right);
+
190
+
201template <typename T>
+
202Vector2<T> operator /(const Vector2<T>& left, T right);
+
203
+
217template <typename T>
+
218Vector2<T>& operator /=(Vector2<T>& left, T right);
+
219
+
232template <typename T>
+
233bool operator ==(const Vector2<T>& left, const Vector2<T>& right);
+
234
+
247template <typename T>
+
248bool operator !=(const Vector2<T>& left, const Vector2<T>& right);
+
249
+
250#include <SFML/System/Vector2.inl>
+
251
+
252// Define the most common types
+
253typedef Vector2<int> Vector2i;
+
254typedef Vector2<unsigned int> Vector2u;
+
255typedef Vector2<float> Vector2f;
+
256
+
257} // namespace sf
+
258
+
259
+
260#endif // SFML_VECTOR2_HPP
+
261
+
262
+
sf::Vector2
Utility template class for manipulating 2-dimensional vectors.
Definition: Vector2.hpp:38
+
sf::Vector2::x
T x
X coordinate of the vector.
Definition: Vector2.hpp:75
+
sf::Vector2::Vector2
Vector2(const Vector2< U > &vector)
Construct the vector from another type of vector.
+
sf::Vector2::y
T y
Y coordinate of the vector.
Definition: Vector2.hpp:76
+
sf::Vector2::Vector2
Vector2()
Default constructor.
+
sf::Vector2::Vector2
Vector2(T X, T Y)
Construct the vector from its coordinates.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Vector3_8hpp_source.html b/Space-Invaders/sfml/doc/html/Vector3_8hpp_source.html new file mode 100644 index 000000000..38ef030cd --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Vector3_8hpp_source.html @@ -0,0 +1,205 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Vector3.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_VECTOR3_HPP
+
26#define SFML_VECTOR3_HPP
+
27
+
28
+
29namespace sf
+
30{
+
36template <typename T>
+
37class Vector3
+
38{
+
39public:
+
40
+
47 Vector3();
+
48
+
57 Vector3(T X, T Y, T Z);
+
58
+
70 template <typename U>
+
71 explicit Vector3(const Vector3<U>& vector);
+
72
+
74 // Member data
+
76 T x;
+
77 T y;
+
78 T z;
+
79};
+
80
+
90template <typename T>
+
91Vector3<T> operator -(const Vector3<T>& left);
+
92
+
106template <typename T>
+
107Vector3<T>& operator +=(Vector3<T>& left, const Vector3<T>& right);
+
108
+
122template <typename T>
+
123Vector3<T>& operator -=(Vector3<T>& left, const Vector3<T>& right);
+
124
+
135template <typename T>
+
136Vector3<T> operator +(const Vector3<T>& left, const Vector3<T>& right);
+
137
+
148template <typename T>
+
149Vector3<T> operator -(const Vector3<T>& left, const Vector3<T>& right);
+
150
+
161template <typename T>
+
162Vector3<T> operator *(const Vector3<T>& left, T right);
+
163
+
174template <typename T>
+
175Vector3<T> operator *(T left, const Vector3<T>& right);
+
176
+
190template <typename T>
+
191Vector3<T>& operator *=(Vector3<T>& left, T right);
+
192
+
203template <typename T>
+
204Vector3<T> operator /(const Vector3<T>& left, T right);
+
205
+
219template <typename T>
+
220Vector3<T>& operator /=(Vector3<T>& left, T right);
+
221
+
234template <typename T>
+
235bool operator ==(const Vector3<T>& left, const Vector3<T>& right);
+
236
+
249template <typename T>
+
250bool operator !=(const Vector3<T>& left, const Vector3<T>& right);
+
251
+
252#include <SFML/System/Vector3.inl>
+
253
+
254// Define the most common types
+
255typedef Vector3<int> Vector3i;
+
256typedef Vector3<float> Vector3f;
+
257
+
258} // namespace sf
+
259
+
260
+
261#endif // SFML_VECTOR3_HPP
+
262
+
263
+
sf::Vector3
Utility template class for manipulating 3-dimensional vectors.
Definition: Vector3.hpp:38
+
sf::Vector3::z
T z
Z coordinate of the vector.
Definition: Vector3.hpp:78
+
sf::Vector3::x
T x
X coordinate of the vector.
Definition: Vector3.hpp:76
+
sf::Vector3::y
T y
Y coordinate of the vector.
Definition: Vector3.hpp:77
+
sf::Vector3::Vector3
Vector3(T X, T Y, T Z)
Construct the vector from its coordinates.
+
sf::Vector3::Vector3
Vector3(const Vector3< U > &vector)
Construct the vector from another type of vector.
+
sf::Vector3::Vector3
Vector3()
Default constructor.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/VertexArray_8hpp_source.html b/Space-Invaders/sfml/doc/html/VertexArray_8hpp_source.html new file mode 100644 index 000000000..79cc1c652 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/VertexArray_8hpp_source.html @@ -0,0 +1,199 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
VertexArray.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_VERTEXARRAY_HPP
+
26#define SFML_VERTEXARRAY_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Vertex.hpp>
+
33#include <SFML/Graphics/PrimitiveType.hpp>
+
34#include <SFML/Graphics/Rect.hpp>
+
35#include <SFML/Graphics/Drawable.hpp>
+
36#include <vector>
+
37
+
38
+
39namespace sf
+
40{
+
45class SFML_GRAPHICS_API VertexArray : public Drawable
+
46{
+
47public:
+
48
+
55 VertexArray();
+
56
+
64 explicit VertexArray(PrimitiveType type, std::size_t vertexCount = 0);
+
65
+
72 std::size_t getVertexCount() const;
+
73
+
88 Vertex& operator [](std::size_t index);
+
89
+
104 const Vertex& operator [](std::size_t index) const;
+
105
+
115 void clear();
+
116
+
129 void resize(std::size_t vertexCount);
+
130
+
137 void append(const Vertex& vertex);
+
138
+
153 void setPrimitiveType(PrimitiveType type);
+
154
+
161 PrimitiveType getPrimitiveType() const;
+
162
+
172 FloatRect getBounds() const;
+
173
+
174private:
+
175
+
183 virtual void draw(RenderTarget& target, RenderStates states) const;
+
184
+
185private:
+
186
+
188 // Member data
+
190 std::vector<Vertex> m_vertices;
+
191 PrimitiveType m_primitiveType;
+
192};
+
193
+
194} // namespace sf
+
195
+
196
+
197#endif // SFML_VERTEXARRAY_HPP
+
198
+
199
+
sf::Drawable
Abstract base class for objects that can be drawn to a render target.
Definition: Drawable.hpp:45
+ +
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::VertexArray
Define a set of one or more 2D primitives.
Definition: VertexArray.hpp:46
+
sf::VertexArray::resize
void resize(std::size_t vertexCount)
Resize the vertex array.
+
sf::VertexArray::VertexArray
VertexArray()
Default constructor.
+
sf::VertexArray::clear
void clear()
Clear the vertex array.
+
sf::VertexArray::VertexArray
VertexArray(PrimitiveType type, std::size_t vertexCount=0)
Construct the vertex array with a type and an initial number of vertices.
+
sf::VertexArray::append
void append(const Vertex &vertex)
Add a vertex to the array.
+
sf::VertexArray::getPrimitiveType
PrimitiveType getPrimitiveType() const
Get the type of primitives drawn by the vertex array.
+
sf::VertexArray::setPrimitiveType
void setPrimitiveType(PrimitiveType type)
Set the type of primitives to draw.
+
sf::VertexArray::getBounds
FloatRect getBounds() const
Compute the bounding rectangle of the vertex array.
+
sf::VertexArray::getVertexCount
std::size_t getVertexCount() const
Return the vertex count.
+
sf::Vertex
Define a point with color and texture coordinates.
Definition: Vertex.hpp:43
+
sf::PrimitiveType
PrimitiveType
Types of primitives that a sf::VertexArray can render.
Definition: PrimitiveType.hpp:40
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/VertexBuffer_8hpp_source.html b/Space-Invaders/sfml/doc/html/VertexBuffer_8hpp_source.html new file mode 100644 index 000000000..c8f62b89b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/VertexBuffer_8hpp_source.html @@ -0,0 +1,240 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
VertexBuffer.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_VERTEXBUFFER_HPP
+
26#define SFML_VERTEXBUFFER_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/PrimitiveType.hpp>
+
33#include <SFML/Graphics/Drawable.hpp>
+
34#include <SFML/Window/GlResource.hpp>
+
35
+
36
+
37namespace sf
+
38{
+
39class RenderTarget;
+
40class Vertex;
+
41
+
46class SFML_GRAPHICS_API VertexBuffer : public Drawable, private GlResource
+
47{
+
48public:
+
49
+
60 enum Usage
+
61 {
+
62 Stream,
+
63 Dynamic,
+
64 Static
+
65 };
+
66
+
73 VertexBuffer();
+
74
+
83 explicit VertexBuffer(PrimitiveType type);
+
84
+
93 explicit VertexBuffer(Usage usage);
+
94
+
105 VertexBuffer(PrimitiveType type, Usage usage);
+
106
+
113 VertexBuffer(const VertexBuffer& copy);
+
114
+
119 ~VertexBuffer();
+
120
+
137 bool create(std::size_t vertexCount);
+
138
+
145 std::size_t getVertexCount() const;
+
146
+
165 bool update(const Vertex* vertices);
+
166
+
198 bool update(const Vertex* vertices, std::size_t vertexCount, unsigned int offset);
+
199
+
208 bool update(const VertexBuffer& vertexBuffer);
+
209
+
218 VertexBuffer& operator =(const VertexBuffer& right);
+
219
+
226 void swap(VertexBuffer& right);
+
227
+
238 unsigned int getNativeHandle() const;
+
239
+
251 void setPrimitiveType(PrimitiveType type);
+
252
+
259 PrimitiveType getPrimitiveType() const;
+
260
+
276 void setUsage(Usage usage);
+
277
+
284 Usage getUsage() const;
+
285
+
307 static void bind(const VertexBuffer* vertexBuffer);
+
308
+
319 static bool isAvailable();
+
320
+
321private:
+
322
+
330 virtual void draw(RenderTarget& target, RenderStates states) const;
+
331
+
332private:
+
333
+
335 // Member data
+
337 unsigned int m_buffer;
+
338 std::size_t m_size;
+
339 PrimitiveType m_primitiveType;
+
340 Usage m_usage;
+
341};
+
342
+
343} // namespace sf
+
344
+
345
+
346#endif // SFML_VERTEXBUFFER_HPP
+
347
+
348
+
sf::Drawable
Abstract base class for objects that can be drawn to a render target.
Definition: Drawable.hpp:45
+
sf::GlResource
Base class for classes that require an OpenGL context.
Definition: GlResource.hpp:47
+
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::VertexBuffer
Vertex buffer storage for one or more 2D primitives.
Definition: VertexBuffer.hpp:47
+
sf::VertexBuffer::getPrimitiveType
PrimitiveType getPrimitiveType() const
Get the type of primitives drawn by the vertex buffer.
+
sf::VertexBuffer::bind
static void bind(const VertexBuffer *vertexBuffer)
Bind a vertex buffer for rendering.
+
sf::VertexBuffer::VertexBuffer
VertexBuffer(const VertexBuffer &copy)
Copy constructor.
+
sf::VertexBuffer::VertexBuffer
VertexBuffer(PrimitiveType type, Usage usage)
Construct a VertexBuffer with a specific PrimitiveType and usage specifier.
+
sf::VertexBuffer::getNativeHandle
unsigned int getNativeHandle() const
Get the underlying OpenGL handle of the vertex buffer.
+
sf::VertexBuffer::swap
void swap(VertexBuffer &right)
Swap the contents of this vertex buffer with those of another.
+
sf::VertexBuffer::Usage
Usage
Usage specifiers.
Definition: VertexBuffer.hpp:61
+
sf::VertexBuffer::Dynamic
@ Dynamic
Occasionally changing data.
Definition: VertexBuffer.hpp:63
+
sf::VertexBuffer::Stream
@ Stream
Constantly changing data.
Definition: VertexBuffer.hpp:62
+
sf::VertexBuffer::VertexBuffer
VertexBuffer(PrimitiveType type)
Construct a VertexBuffer with a specific PrimitiveType.
+
sf::VertexBuffer::update
bool update(const VertexBuffer &vertexBuffer)
Copy the contents of another buffer into this buffer.
+
sf::VertexBuffer::getUsage
Usage getUsage() const
Get the usage specifier of this vertex buffer.
+
sf::VertexBuffer::isAvailable
static bool isAvailable()
Tell whether or not the system supports vertex buffers.
+
sf::VertexBuffer::getVertexCount
std::size_t getVertexCount() const
Return the vertex count.
+
sf::VertexBuffer::setPrimitiveType
void setPrimitiveType(PrimitiveType type)
Set the type of primitives to draw.
+
sf::VertexBuffer::create
bool create(std::size_t vertexCount)
Create the vertex buffer.
+
sf::VertexBuffer::VertexBuffer
VertexBuffer()
Default constructor.
+
sf::VertexBuffer::setUsage
void setUsage(Usage usage)
Set the usage specifier of this vertex buffer.
+
sf::VertexBuffer::~VertexBuffer
~VertexBuffer()
Destructor.
+
sf::VertexBuffer::update
bool update(const Vertex *vertices)
Update the whole buffer from an array of vertices.
+
sf::VertexBuffer::update
bool update(const Vertex *vertices, std::size_t vertexCount, unsigned int offset)
Update a part of the buffer from an array of vertices.
+
sf::VertexBuffer::VertexBuffer
VertexBuffer(Usage usage)
Construct a VertexBuffer with a specific usage specifier.
+
sf::Vertex
Define a point with color and texture coordinates.
Definition: Vertex.hpp:43
+
sf::PrimitiveType
PrimitiveType
Types of primitives that a sf::VertexArray can render.
Definition: PrimitiveType.hpp:40
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Vertex_8hpp_source.html b/Space-Invaders/sfml/doc/html/Vertex_8hpp_source.html new file mode 100644 index 000000000..fb552305d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Vertex_8hpp_source.html @@ -0,0 +1,174 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Vertex.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_VERTEX_HPP
+
26#define SFML_VERTEX_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Color.hpp>
+
33#include <SFML/System/Vector2.hpp>
+
34
+
35
+
36namespace sf
+
37{
+
42class SFML_GRAPHICS_API Vertex
+
43{
+
44public:
+
45
+
50 Vertex();
+
51
+
60 Vertex(const Vector2f& thePosition);
+
61
+
71 Vertex(const Vector2f& thePosition, const Color& theColor);
+
72
+
82 Vertex(const Vector2f& thePosition, const Vector2f& theTexCoords);
+
83
+
92 Vertex(const Vector2f& thePosition, const Color& theColor, const Vector2f& theTexCoords);
+
93
+
95 // Member data
+
97 Vector2f position;
+
98 Color color;
+
99 Vector2f texCoords;
+
100};
+
101
+
102} // namespace sf
+
103
+
104
+
105#endif // SFML_VERTEX_HPP
+
106
+
107
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+ +
sf::Vertex
Define a point with color and texture coordinates.
Definition: Vertex.hpp:43
+
sf::Vertex::Vertex
Vertex(const Vector2f &thePosition)
Construct the vertex from its position.
+
sf::Vertex::Vertex
Vertex()
Default constructor.
+
sf::Vertex::Vertex
Vertex(const Vector2f &thePosition, const Color &theColor)
Construct the vertex from its position and color.
+
sf::Vertex::color
Color color
Color of the vertex.
Definition: Vertex.hpp:98
+
sf::Vertex::position
Vector2f position
2D position of the vertex
Definition: Vertex.hpp:97
+
sf::Vertex::texCoords
Vector2f texCoords
Coordinates of the texture's pixel to map to the vertex.
Definition: Vertex.hpp:99
+
sf::Vertex::Vertex
Vertex(const Vector2f &thePosition, const Vector2f &theTexCoords)
Construct the vertex from its position and texture coordinates.
+
sf::Vertex::Vertex
Vertex(const Vector2f &thePosition, const Color &theColor, const Vector2f &theTexCoords)
Construct the vertex from its position, color and texture coordinates.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/VideoMode_8hpp_source.html b/Space-Invaders/sfml/doc/html/VideoMode_8hpp_source.html new file mode 100644 index 000000000..598e58c9d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/VideoMode_8hpp_source.html @@ -0,0 +1,183 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
VideoMode.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_VIDEOMODE_HPP
+
26#define SFML_VIDEOMODE_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32#include <vector>
+
33
+
34
+
35namespace sf
+
36{
+
41class SFML_WINDOW_API VideoMode
+
42{
+
43public:
+
44
+
51 VideoMode();
+
52
+
61 VideoMode(unsigned int modeWidth, unsigned int modeHeight, unsigned int modeBitsPerPixel = 32);
+
62
+
69 static VideoMode getDesktopMode();
+
70
+
85 static const std::vector<VideoMode>& getFullscreenModes();
+
86
+
97 bool isValid() const;
+
98
+
100 // Member data
+
102 unsigned int width;
+
103 unsigned int height;
+
104 unsigned int bitsPerPixel;
+
105};
+
106
+
117SFML_WINDOW_API bool operator ==(const VideoMode& left, const VideoMode& right);
+
118
+
129SFML_WINDOW_API bool operator !=(const VideoMode& left, const VideoMode& right);
+
130
+
141SFML_WINDOW_API bool operator <(const VideoMode& left, const VideoMode& right);
+
142
+
153SFML_WINDOW_API bool operator >(const VideoMode& left, const VideoMode& right);
+
154
+
165SFML_WINDOW_API bool operator <=(const VideoMode& left, const VideoMode& right);
+
166
+
177SFML_WINDOW_API bool operator >=(const VideoMode& left, const VideoMode& right);
+
178
+
179} // namespace sf
+
180
+
181
+
182#endif // SFML_VIDEOMODE_HPP
+
183
+
184
+
sf::VideoMode
VideoMode defines a video mode (width, height, bpp)
Definition: VideoMode.hpp:42
+
sf::VideoMode::VideoMode
VideoMode()
Default constructor.
+
sf::VideoMode::getFullscreenModes
static const std::vector< VideoMode > & getFullscreenModes()
Retrieve all the video modes supported in fullscreen mode.
+
sf::VideoMode::VideoMode
VideoMode(unsigned int modeWidth, unsigned int modeHeight, unsigned int modeBitsPerPixel=32)
Construct the video mode with its attributes.
+
sf::VideoMode::height
unsigned int height
Video mode height, in pixels.
Definition: VideoMode.hpp:103
+
sf::VideoMode::width
unsigned int width
Video mode width, in pixels.
Definition: VideoMode.hpp:102
+
sf::VideoMode::bitsPerPixel
unsigned int bitsPerPixel
Video mode pixel depth, in bits per pixels.
Definition: VideoMode.hpp:104
+
sf::VideoMode::getDesktopMode
static VideoMode getDesktopMode()
Get the current desktop video mode.
+
sf::VideoMode::isValid
bool isValid() const
Tell whether or not the video mode is valid.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/View_8hpp_source.html b/Space-Invaders/sfml/doc/html/View_8hpp_source.html new file mode 100644 index 000000000..f7bf53c6f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/View_8hpp_source.html @@ -0,0 +1,225 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
View.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_VIEW_HPP
+
26#define SFML_VIEW_HPP
+
27
+
29// Headers
+
31#include <SFML/Graphics/Export.hpp>
+
32#include <SFML/Graphics/Rect.hpp>
+
33#include <SFML/Graphics/Transform.hpp>
+
34#include <SFML/System/Vector2.hpp>
+
35
+
36
+
37namespace sf
+
38{
+
43class SFML_GRAPHICS_API View
+
44{
+
45public:
+
46
+
53 View();
+
54
+
61 explicit View(const FloatRect& rectangle);
+
62
+
70 View(const Vector2f& center, const Vector2f& size);
+
71
+
81 void setCenter(float x, float y);
+
82
+
91 void setCenter(const Vector2f& center);
+
92
+
102 void setSize(float width, float height);
+
103
+
112 void setSize(const Vector2f& size);
+
113
+
124 void setRotation(float angle);
+
125
+
141 void setViewport(const FloatRect& viewport);
+
142
+
153 void reset(const FloatRect& rectangle);
+
154
+
163 const Vector2f& getCenter() const;
+
164
+
173 const Vector2f& getSize() const;
+
174
+
183 float getRotation() const;
+
184
+
193 const FloatRect& getViewport() const;
+
194
+
204 void move(float offsetX, float offsetY);
+
205
+
214 void move(const Vector2f& offset);
+
215
+
224 void rotate(float angle);
+
225
+
241 void zoom(float factor);
+
242
+
253 const Transform& getTransform() const;
+
254
+
265 const Transform& getInverseTransform() const;
+
266
+
267private:
+
268
+
270 // Member data
+
272 Vector2f m_center;
+
273 Vector2f m_size;
+
274 float m_rotation;
+
275 FloatRect m_viewport;
+
276 mutable Transform m_transform;
+
277 mutable Transform m_inverseTransform;
+
278 mutable bool m_transformUpdated;
+
279 mutable bool m_invTransformUpdated;
+
280};
+
281
+
282} // namespace sf
+
283
+
284
+
285#endif // SFML_VIEW_HPP
+
286
+
287
+ +
sf::Transform
Define a 3x3 transform matrix.
Definition: Transform.hpp:43
+ +
sf::View
2D camera that defines what region is shown on screen
Definition: View.hpp:44
+
sf::View::move
void move(float offsetX, float offsetY)
Move the view relatively to its current position.
+
sf::View::View
View(const FloatRect &rectangle)
Construct the view from a rectangle.
+
sf::View::setRotation
void setRotation(float angle)
Set the orientation of the view.
+
sf::View::View
View()
Default constructor.
+
sf::View::getRotation
float getRotation() const
Get the current orientation of the view.
+
sf::View::zoom
void zoom(float factor)
Resize the view rectangle relatively to its current size.
+
sf::View::move
void move(const Vector2f &offset)
Move the view relatively to its current position.
+
sf::View::getSize
const Vector2f & getSize() const
Get the size of the view.
+
sf::View::rotate
void rotate(float angle)
Rotate the view relatively to its current orientation.
+
sf::View::getCenter
const Vector2f & getCenter() const
Get the center of the view.
+
sf::View::setViewport
void setViewport(const FloatRect &viewport)
Set the target viewport.
+
sf::View::setSize
void setSize(float width, float height)
Set the size of the view.
+
sf::View::setSize
void setSize(const Vector2f &size)
Set the size of the view.
+
sf::View::getViewport
const FloatRect & getViewport() const
Get the target viewport rectangle of the view.
+
sf::View::getInverseTransform
const Transform & getInverseTransform() const
Get the inverse projection transform of the view.
+
sf::View::setCenter
void setCenter(float x, float y)
Set the center of the view.
+
sf::View::setCenter
void setCenter(const Vector2f &center)
Set the center of the view.
+
sf::View::reset
void reset(const FloatRect &rectangle)
Reset the view to the given rectangle.
+
sf::View::getTransform
const Transform & getTransform() const
Get the projection transform of the view.
+
sf::View::View
View(const Vector2f &center, const Vector2f &size)
Construct the view from its center and size.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Vulkan_8hpp_source.html b/Space-Invaders/sfml/doc/html/Vulkan_8hpp_source.html new file mode 100644 index 000000000..d2316c14d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Vulkan_8hpp_source.html @@ -0,0 +1,178 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Vulkan.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_VULKAN_HPP
+
26#define SFML_VULKAN_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Export.hpp>
+
32#include <SFML/Window/WindowHandle.hpp>
+
33#include <vector>
+
34#include <cstddef>
+
35#include <stdint.h>
+
36
+
37
+
38typedef struct VkInstance_T* VkInstance;
+
39
+
40#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+
41
+
42typedef struct VkSurfaceKHR_T* VkSurfaceKHR;
+
43
+
44#else
+
45
+
46typedef uint64_t VkSurfaceKHR;
+
47
+
48#endif
+
49
+
50struct VkAllocationCallbacks;
+
51
+
52
+
53namespace sf
+
54{
+
55
+
56typedef void (*VulkanFunctionPointer)();
+
57
+
62class SFML_WINDOW_API Vulkan
+
63{
+
64public:
+
65
+
82 static bool isAvailable(bool requireGraphics = true);
+
83
+
92 static VulkanFunctionPointer getFunction(const char* name);
+
93
+
100 static const std::vector<const char*>& getGraphicsRequiredInstanceExtensions();
+
101};
+
102
+
103} // namespace sf
+
104
+
105
+
106#endif // SFML_VULKAN_HPP
+
107
+
108
+
sf::Vulkan
Vulkan helper functions.
Definition: Vulkan.hpp:63
+
sf::Vulkan::getGraphicsRequiredInstanceExtensions
static const std::vector< const char * > & getGraphicsRequiredInstanceExtensions()
Get Vulkan instance extensions required for graphics.
+
sf::Vulkan::isAvailable
static bool isAvailable(bool requireGraphics=true)
Tell whether or not the system supports Vulkan.
+
sf::Vulkan::getFunction
static VulkanFunctionPointer getFunction(const char *name)
Get the address of a Vulkan function.
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/WindowBase_8hpp_source.html b/Space-Invaders/sfml/doc/html/WindowBase_8hpp_source.html new file mode 100644 index 000000000..74b430585 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/WindowBase_8hpp_source.html @@ -0,0 +1,273 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
WindowBase.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_WINDOWBASE_HPP
+
26#define SFML_WINDOWBASE_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/Cursor.hpp>
+
32#include <SFML/Window/Export.hpp>
+
33#include <SFML/Window/VideoMode.hpp>
+
34#include <SFML/Window/Vulkan.hpp>
+
35#include <SFML/Window/WindowHandle.hpp>
+
36#include <SFML/Window/WindowStyle.hpp>
+
37#include <SFML/System/Clock.hpp>
+
38#include <SFML/System/NonCopyable.hpp>
+
39#include <SFML/System/String.hpp>
+
40#include <SFML/System/Vector2.hpp>
+
41
+
42
+
43namespace sf
+
44{
+
45namespace priv
+
46{
+
47 class WindowImpl;
+
48}
+
49
+
50class Event;
+
51
+
56class SFML_WINDOW_API WindowBase : NonCopyable
+
57{
+
58public:
+
59
+
67 WindowBase();
+
68
+
83 WindowBase(VideoMode mode, const String& title, Uint32 style = Style::Default);
+
84
+
91 explicit WindowBase(WindowHandle handle);
+
92
+
99 virtual ~WindowBase();
+
100
+
113 virtual void create(VideoMode mode, const String& title, Uint32 style = Style::Default);
+
114
+
121 virtual void create(WindowHandle handle);
+
122
+
133 virtual void close();
+
134
+
145 bool isOpen() const;
+
146
+
170 bool pollEvent(Event& event);
+
171
+
197 bool waitEvent(Event& event);
+
198
+
207 Vector2i getPosition() const;
+
208
+
221 void setPosition(const Vector2i& position);
+
222
+
234 Vector2u getSize() const;
+
235
+
244 void setSize(const Vector2u& size);
+
245
+
254 void setTitle(const String& title);
+
255
+
273 void setIcon(unsigned int width, unsigned int height, const Uint8* pixels);
+
274
+
283 void setVisible(bool visible);
+
284
+
293 void setMouseCursorVisible(bool visible);
+
294
+
306 void setMouseCursorGrabbed(bool grabbed);
+
307
+
325 void setMouseCursor(const Cursor& cursor);
+
326
+
339 void setKeyRepeatEnabled(bool enabled);
+
340
+
352 void setJoystickThreshold(float threshold);
+
353
+
368 void requestFocus();
+
369
+
381 bool hasFocus() const;
+
382
+
395 WindowHandle getSystemHandle() const;
+
396
+
407 bool createVulkanSurface(const VkInstance& instance, VkSurfaceKHR& surface, const VkAllocationCallbacks* allocator = 0);
+
408
+
409protected:
+
410
+
419 virtual void onCreate();
+
420
+
428 virtual void onResize();
+
429
+
430private:
+
431
+
432 friend class Window;
+
433
+
446 bool filterEvent(const Event& event);
+
447
+
452 void initialize();
+
453
+
460 const WindowBase* getFullscreenWindow();
+
461
+
468 void setFullscreenWindow(const WindowBase* window);
+
469
+
471 // Member data
+
473 priv::WindowImpl* m_impl;
+
474 Vector2u m_size;
+
475};
+
476
+
477} // namespace sf
+
478
+
479
+
480#endif // SFML_WINDOWBASE_HPP
+
481
+
482
+
sf::Cursor
Cursor defines the appearance of a system cursor.
Definition: Cursor.hpp:47
+
sf::Event
Defines a system event and its parameters.
Definition: Event.hpp:45
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+
sf::Vector2
Utility template class for manipulating 2-dimensional vectors.
Definition: Vector2.hpp:38
+
sf::VideoMode
VideoMode defines a video mode (width, height, bpp)
Definition: VideoMode.hpp:42
+
sf::WindowBase
Window that serves as a base for other windows.
Definition: WindowBase.hpp:57
+
sf::WindowBase::setMouseCursorGrabbed
void setMouseCursorGrabbed(bool grabbed)
Grab or release the mouse cursor.
+
sf::WindowBase::setMouseCursor
void setMouseCursor(const Cursor &cursor)
Set the displayed cursor to a native system cursor.
+
sf::WindowBase::WindowBase
WindowBase()
Default constructor.
+
sf::WindowBase::getSize
Vector2u getSize() const
Get the size of the rendering region of the window.
+
sf::WindowBase::onCreate
virtual void onCreate()
Function called after the window has been created.
+
sf::WindowBase::create
virtual void create(VideoMode mode, const String &title, Uint32 style=Style::Default)
Create (or recreate) the window.
+
sf::WindowBase::requestFocus
void requestFocus()
Request the current window to be made the active foreground window.
+
sf::WindowBase::createVulkanSurface
bool createVulkanSurface(const VkInstance &instance, VkSurfaceKHR &surface, const VkAllocationCallbacks *allocator=0)
Create a Vulkan rendering surface.
+
sf::WindowBase::create
virtual void create(WindowHandle handle)
Create (or recreate) the window from an existing control.
+
sf::WindowBase::setVisible
void setVisible(bool visible)
Show or hide the window.
+
sf::WindowBase::getPosition
Vector2i getPosition() const
Get the position of the window.
+
sf::WindowBase::pollEvent
bool pollEvent(Event &event)
Pop the event on top of the event queue, if any, and return it.
+
sf::WindowBase::~WindowBase
virtual ~WindowBase()
Destructor.
+
sf::WindowBase::setSize
void setSize(const Vector2u &size)
Change the size of the rendering region of the window.
+
sf::WindowBase::onResize
virtual void onResize()
Function called after the window has been resized.
+
sf::WindowBase::close
virtual void close()
Close the window and destroy all the attached resources.
+
sf::WindowBase::waitEvent
bool waitEvent(Event &event)
Wait for an event and return it.
+
sf::WindowBase::isOpen
bool isOpen() const
Tell whether or not the window is open.
+
sf::WindowBase::WindowBase
WindowBase(VideoMode mode, const String &title, Uint32 style=Style::Default)
Construct a new window.
+
sf::WindowBase::WindowBase
WindowBase(WindowHandle handle)
Construct the window from an existing control.
+
sf::WindowBase::setPosition
void setPosition(const Vector2i &position)
Change the position of the window on screen.
+
sf::WindowBase::setTitle
void setTitle(const String &title)
Change the title of the window.
+
sf::WindowBase::setJoystickThreshold
void setJoystickThreshold(float threshold)
Change the joystick threshold.
+
sf::WindowBase::hasFocus
bool hasFocus() const
Check whether the window has the input focus.
+
sf::WindowBase::setIcon
void setIcon(unsigned int width, unsigned int height, const Uint8 *pixels)
Change the window's icon.
+
sf::WindowBase::getSystemHandle
WindowHandle getSystemHandle() const
Get the OS-specific handle of the window.
+
sf::WindowBase::setMouseCursorVisible
void setMouseCursorVisible(bool visible)
Show or hide the mouse cursor.
+
sf::WindowBase::setKeyRepeatEnabled
void setKeyRepeatEnabled(bool enabled)
Enable or disable automatic key-repeat.
+
sf::Window
Window that serves as a target for OpenGL rendering.
Definition: Window/Window.hpp:50
+
sf::WindowHandle
platform specific WindowHandle
Define a low-level window handle type, specific to each platform.
Definition: WindowHandle.hpp:68
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/WindowHandle_8hpp_source.html b/Space-Invaders/sfml/doc/html/WindowHandle_8hpp_source.html new file mode 100644 index 000000000..4bbfa7dc6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/WindowHandle_8hpp_source.html @@ -0,0 +1,177 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
WindowHandle.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_WINDOWHANDLE_HPP
+
26#define SFML_WINDOWHANDLE_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32
+
33// Windows' HWND is a typedef on struct HWND__*
+
34#if defined(SFML_SYSTEM_WINDOWS)
+
35 struct HWND__;
+
36#endif
+
37
+
38namespace sf
+
39{
+
40#if defined(SFML_SYSTEM_WINDOWS)
+
41
+
42 // Window handle is HWND (HWND__*) on Windows
+
43 typedef HWND__* WindowHandle;
+
44
+
45#elif defined(SFML_SYSTEM_LINUX) || defined(SFML_SYSTEM_FREEBSD) || defined(SFML_SYSTEM_OPENBSD) || defined(SFML_SYSTEM_NETBSD)
+
46
+
47 // Window handle is Window (unsigned long) on Unix - X11
+
48 typedef unsigned long WindowHandle;
+
49
+
50#elif defined(SFML_SYSTEM_MACOS)
+
51
+
52 // Window handle is NSWindow or NSView (void*) on Mac OS X - Cocoa
+
53 typedef void* WindowHandle;
+
54
+
55#elif defined(SFML_SYSTEM_IOS)
+
56
+
57 // Window handle is UIWindow (void*) on iOS - UIKit
+
58 typedef void* WindowHandle;
+
59
+
60#elif defined(SFML_SYSTEM_ANDROID)
+
61
+
62 // Window handle is ANativeWindow* (void*) on Android
+
63 typedef void* WindowHandle;
+
64
+
65#elif defined(SFML_DOXYGEN)
+
66
+
67 // Define typedef symbol so that Doxygen can attach some documentation to it
+
68 typedef "platform-specific" WindowHandle;
+
69
+
70#endif
+
71
+
72} // namespace sf
+
73
+
74
+
75#endif // SFML_WINDOWHANDLE_HPP
+
76
+
sf::WindowHandle
platform specific WindowHandle
Define a low-level window handle type, specific to each platform.
Definition: WindowHandle.hpp:68
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/WindowStyle_8hpp_source.html b/Space-Invaders/sfml/doc/html/WindowStyle_8hpp_source.html new file mode 100644 index 000000000..5748f476b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/WindowStyle_8hpp_source.html @@ -0,0 +1,156 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
WindowStyle.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_WINDOWSTYLE_HPP
+
26#define SFML_WINDOWSTYLE_HPP
+
27
+
28
+
29namespace sf
+
30{
+
31namespace Style
+
32{
+
38 enum
+
39 {
+
40 None = 0,
+
41 Titlebar = 1 << 0,
+
42 Resize = 1 << 1,
+
43 Close = 1 << 2,
+
44 Fullscreen = 1 << 3,
+
45
+
46 Default = Titlebar | Resize | Close
+
47 };
+
48}
+
49
+
50} // namespace sf
+
51
+
52
+
53#endif // SFML_WINDOWSTYLE_HPP
+
sf::Style::Default
@ Default
Default window style.
Definition: WindowStyle.hpp:46
+
sf::Style::Fullscreen
@ Fullscreen
Fullscreen mode (this flag and all others are mutually exclusive)
Definition: WindowStyle.hpp:44
+
sf::Style::None
@ None
No border / title bar (this flag and all others are mutually exclusive)
Definition: WindowStyle.hpp:40
+
sf::Style::Titlebar
@ Titlebar
Title bar + fixed border.
Definition: WindowStyle.hpp:41
+
sf::Style::Resize
@ Resize
Title bar + resizable border + maximize button.
Definition: WindowStyle.hpp:42
+
sf::Style::Close
@ Close
Title bar + close button.
Definition: WindowStyle.hpp:43
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Window_2Export_8hpp_source.html b/Space-Invaders/sfml/doc/html/Window_2Export_8hpp_source.html new file mode 100644 index 000000000..e6744b4e9 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Window_2Export_8hpp_source.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Window/Export.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_WINDOW_EXPORT_HPP
+
26#define SFML_WINDOW_EXPORT_HPP
+
27
+
29// Headers
+
31#include <SFML/Config.hpp>
+
32
+
33
+
35// Define portable import / export macros
+
37#if defined(SFML_WINDOW_EXPORTS)
+
38
+
39 #define SFML_WINDOW_API SFML_API_EXPORT
+
40
+
41#else
+
42
+
43 #define SFML_WINDOW_API SFML_API_IMPORT
+
44
+
45#endif
+
46
+
47
+
48#endif // SFML_WINDOW_EXPORT_HPP
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Window_2Window_8hpp_source.html b/Space-Invaders/sfml/doc/html/Window_2Window_8hpp_source.html new file mode 100644 index 000000000..8eaac96f1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Window_2Window_8hpp_source.html @@ -0,0 +1,218 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Window/Window.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_WINDOW_HPP
+
26#define SFML_WINDOW_HPP
+
27
+
29// Headers
+
31#include <SFML/Window/ContextSettings.hpp>
+
32#include <SFML/Window/GlResource.hpp>
+
33#include <SFML/Window/WindowBase.hpp>
+
34
+
35
+
36namespace sf
+
37{
+
38namespace priv
+
39{
+
40 class GlContext;
+
41}
+
42
+
43class Event;
+
44
+
49class SFML_WINDOW_API Window : public WindowBase, GlResource
+
50{
+
51public:
+
52
+
60 Window();
+
61
+
81 Window(VideoMode mode, const String& title, Uint32 style = Style::Default, const ContextSettings& settings = ContextSettings());
+
82
+
97 explicit Window(WindowHandle handle, const ContextSettings& settings = ContextSettings());
+
98
+
105 virtual ~Window();
+
106
+
119 virtual void create(VideoMode mode, const String& title, Uint32 style = Style::Default);
+
120
+
138 virtual void create(VideoMode mode, const String& title, Uint32 style, const ContextSettings& settings);
+
139
+
150 virtual void create(WindowHandle handle);
+
151
+
167 virtual void create(WindowHandle handle, const ContextSettings& settings);
+
168
+
179 virtual void close();
+
180
+
192 const ContextSettings& getSettings() const;
+
193
+
207 void setVerticalSyncEnabled(bool enabled);
+
208
+
224 void setFramerateLimit(unsigned int limit);
+
225
+
242 bool setActive(bool active = true) const;
+
243
+
252 void display();
+
253
+
254private:
+
255
+
268 bool filterEvent(const Event& event);
+
269
+
274 void initialize();
+
275
+
277 // Member data
+
279 priv::GlContext* m_context;
+
280 Clock m_clock;
+
281 Time m_frameTimeLimit;
+
282};
+
283
+
284} // namespace sf
+
285
+
286
+
287#endif // SFML_WINDOW_HPP
+
288
+
289
+
sf::Clock
Utility class that measures the elapsed time.
Definition: Clock.hpp:42
+
sf::Event
Defines a system event and its parameters.
Definition: Event.hpp:45
+
sf::GlResource
Base class for classes that require an OpenGL context.
Definition: GlResource.hpp:47
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
sf::VideoMode
VideoMode defines a video mode (width, height, bpp)
Definition: VideoMode.hpp:42
+
sf::WindowBase
Window that serves as a base for other windows.
Definition: WindowBase.hpp:57
+
sf::Window
Window that serves as a target for OpenGL rendering.
Definition: Window/Window.hpp:50
+
sf::Window::getSettings
const ContextSettings & getSettings() const
Get the settings of the OpenGL context of the window.
+
sf::Window::create
virtual void create(WindowHandle handle, const ContextSettings &settings)
Create (or recreate) the window from an existing control.
+
sf::Window::Window
Window(VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())
Construct a new window.
+
sf::Window::Window
Window()
Default constructor.
+
sf::Window::setVerticalSyncEnabled
void setVerticalSyncEnabled(bool enabled)
Enable or disable vertical synchronization.
+
sf::Window::create
virtual void create(WindowHandle handle)
Create (or recreate) the window from an existing control.
+
sf::Window::create
virtual void create(VideoMode mode, const String &title, Uint32 style, const ContextSettings &settings)
Create (or recreate) the window.
+
sf::Window::Window
Window(WindowHandle handle, const ContextSettings &settings=ContextSettings())
Construct the window from an existing control.
+
sf::Window::close
virtual void close()
Close the window and destroy all the attached resources.
+
sf::Window::setActive
bool setActive(bool active=true) const
Activate or deactivate the window as the current target for OpenGL rendering.
+
sf::Window::~Window
virtual ~Window()
Destructor.
+
sf::Window::create
virtual void create(VideoMode mode, const String &title, Uint32 style=Style::Default)
Create (or recreate) the window.
+
sf::Window::display
void display()
Display on screen what has been rendered to the window so far.
+
sf::Window::setFramerateLimit
void setFramerateLimit(unsigned int limit)
Limit the framerate to a maximum fixed frequency.
+
sf::WindowHandle
platform specific WindowHandle
Define a low-level window handle type, specific to each platform.
Definition: WindowHandle.hpp:68
+
sf::ContextSettings
Structure defining the settings of the OpenGL context attached to a window.
Definition: ContextSettings.hpp:38
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/Window_8hpp_source.html b/Space-Invaders/sfml/doc/html/Window_8hpp_source.html new file mode 100644 index 000000000..4f3a56f7e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/Window_8hpp_source.html @@ -0,0 +1,151 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Window.hpp
+
+
+
1
+
2//
+
3// SFML - Simple and Fast Multimedia Library
+
4// Copyright (C) 2007-2023 Laurent Gomila (laurent@sfml-dev.org)
+
5//
+
6// This software is provided 'as-is', without any express or implied warranty.
+
7// In no event will the authors be held liable for any damages arising from the use of this software.
+
8//
+
9// Permission is granted to anyone to use this software for any purpose,
+
10// including commercial applications, and to alter it and redistribute it freely,
+
11// subject to the following restrictions:
+
12//
+
13// 1. The origin of this software must not be misrepresented;
+
14// you must not claim that you wrote the original software.
+
15// If you use this software in a product, an acknowledgment
+
16// in the product documentation would be appreciated but is not required.
+
17//
+
18// 2. Altered source versions must be plainly marked as such,
+
19// and must not be misrepresented as being the original software.
+
20//
+
21// 3. This notice may not be removed or altered from any source distribution.
+
22//
+
24
+
25#ifndef SFML_SFML_WINDOW_HPP
+
26#define SFML_SFML_WINDOW_HPP
+
27
+
29// Headers
+
31
+
32#include <SFML/System.hpp>
+
33#include <SFML/Window/Clipboard.hpp>
+
34#include <SFML/Window/Context.hpp>
+
35#include <SFML/Window/ContextSettings.hpp>
+
36#include <SFML/Window/Cursor.hpp>
+
37#include <SFML/Window/Event.hpp>
+
38#include <SFML/Window/Joystick.hpp>
+
39#include <SFML/Window/Keyboard.hpp>
+
40#include <SFML/Window/Mouse.hpp>
+
41#include <SFML/Window/Sensor.hpp>
+
42#include <SFML/Window/Touch.hpp>
+
43#include <SFML/Window/VideoMode.hpp>
+
44#include <SFML/Window/Window.hpp>
+
45#include <SFML/Window/WindowHandle.hpp>
+
46#include <SFML/Window/WindowStyle.hpp>
+
47
+
48
+
49
+
50#endif // SFML_SFML_WINDOW_HPP
+
51
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/annotated.html b/Space-Invaders/sfml/doc/html/annotated.html new file mode 100644 index 000000000..932e1d690 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/annotated.html @@ -0,0 +1,212 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Class List
+
+
+
Here are the classes, structs, unions and interfaces with brief descriptions:
+
[detail level 123]
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ▼Nsf
 CAlResourceBase class for classes that require an OpenAL context
 CBlendModeBlending modes for drawing
 CCircleShapeSpecialized shape representing a circle
 CClipboardGive access to the system clipboard
 CClockUtility class that measures the elapsed time
 CColorUtility class for manipulating RGBA colors
 CContextClass holding a valid drawing context
 CContextSettingsStructure defining the settings of the OpenGL context attached to a window
 CConvexShapeSpecialized shape representing a convex polygon
 CCursorCursor defines the appearance of a system cursor
 CDrawableAbstract base class for objects that can be drawn to a render target
 ►CEventDefines a system event and its parameters
 CFileInputStreamImplementation of input stream based on a file
 ►CFontClass for loading and manipulating character fonts
 ►CFtpA FTP client
 ►CGlResourceBase class for classes that require an OpenGL context
 CGlyphStructure describing a glyph
 ►CHttpA HTTP client
 CImageClass for loading, manipulating and saving images
 CInputSoundFileProvide read access to sound files
 CInputStreamAbstract class for custom file input streams
 CIpAddressEncapsulate an IPv4 network address
 ►CJoystickGive access to the real-time state of the joysticks
 ►CKeyboardGive access to the real-time state of the keyboard
 CListenerThe audio listener is the point in the scene from where all the sounds are heard
 CLockAutomatic wrapper for locking and unlocking mutexes
 CMemoryInputStreamImplementation of input stream based on a memory chunk
 CMouseGive access to the real-time state of the mouse
 ►CMusicStreamed music played from an audio file
 CMutexBlocks concurrent access to shared resources from multiple threads
 CNonCopyableUtility class that makes any derived class non-copyable
 COutputSoundFileProvide write access to sound files
 CPacketUtility class to build blocks of data to transfer over the network
 CRectUtility class for manipulating 2D axis aligned rectangles
 CRectangleShapeSpecialized shape representing a rectangle
 CRenderStatesDefine the states used for drawing to a RenderTarget
 CRenderTargetBase class for all render targets (window, texture, ...)
 CRenderTextureTarget for off-screen 2D rendering into a texture
 CRenderWindowWindow that can serve as a target for 2D drawing
 CSensorGive access to the real-time state of the sensors
 ►CShaderShader class (vertex, geometry and fragment)
 CShapeBase class for textured shapes with outline
 CSocketBase class for all the socket types
 CSocketSelectorMultiplexer that allows to read from multiple sockets
 CSoundRegular sound that can be played in the audio environment
 CSoundBufferStorage for audio samples defining a sound
 CSoundBufferRecorderSpecialized SoundRecorder which stores the captured audio data into a sound buffer
 CSoundFileFactoryManages and instantiates sound file readers and writers
 ►CSoundFileReaderAbstract base class for sound file decoding
 CSoundFileWriterAbstract base class for sound file encoding
 CSoundRecorderAbstract base class for capturing sound data
 CSoundSourceBase class defining a sound's properties
 ►CSoundStreamAbstract base class for streamed audio sources
 CSpriteDrawable representation of a texture, with its own transformations, color, etc
 CStringUtility string class that automatically handles conversions between types and encodings
 CTcpListenerSocket that listens to new TCP connections
 CTcpSocketSpecialized socket using the TCP protocol
 CTextGraphical text that can be drawn to a render target
 CTextureImage living on the graphics card that can be used for drawing
 CThreadUtility class to manipulate threads
 CThreadLocalDefines variables with thread-local storage
 CThreadLocalPtrPointer to a thread-local variable
 CTimeRepresents a time value
 CTouchGive access to the real-time state of the touches
 CTransformDefine a 3x3 transform matrix
 CTransformableDecomposed transform defined by a position, a rotation and a scale
 CUdpSocketSpecialized socket using the UDP protocol
 CUtfUtility class providing generic functions for UTF conversions
 CUtf< 16 >Specialization of the Utf template for UTF-16
 CUtf< 32 >Specialization of the Utf template for UTF-32
 CUtf< 8 >Specialization of the Utf template for UTF-8
 CVector2Utility template class for manipulating 2-dimensional vectors
 CVector3Utility template class for manipulating 3-dimensional vectors
 CVertexDefine a point with color and texture coordinates
 CVertexArrayDefine a set of one or more 2D primitives
 CVertexBufferVertex buffer storage for one or more 2D primitives
 CVideoModeVideoMode defines a video mode (width, height, bpp)
 CView2D camera that defines what region is shown on screen
 CVulkanVulkan helper functions
 CWindowWindow that serves as a target for OpenGL rendering
 CWindowBaseWindow that serves as a base for other windows
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/bc_s.png b/Space-Invaders/sfml/doc/html/bc_s.png new file mode 100644 index 000000000..224b29aa9 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/bc_s.png differ diff --git a/Space-Invaders/sfml/doc/html/bc_sd.png b/Space-Invaders/sfml/doc/html/bc_sd.png new file mode 100644 index 000000000..31ca888dc Binary files /dev/null and b/Space-Invaders/sfml/doc/html/bc_sd.png differ diff --git a/Space-Invaders/sfml/doc/html/bdwn.png b/Space-Invaders/sfml/doc/html/bdwn.png new file mode 100644 index 000000000..940a0b950 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/bdwn.png differ diff --git a/Space-Invaders/sfml/doc/html/classes.html b/Space-Invaders/sfml/doc/html/classes.html new file mode 100644 index 000000000..cbe62cea0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classes.html @@ -0,0 +1,170 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Class Index
+
+
+
A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | R | S | T | U | V | W
+
+
+
A
+
AlResource (sf)
+
+
B
+
BlendMode (sf)
+
+
C
+
SoundStream::Chunk (sf)
CircleShape (sf)
Clipboard (sf)
Clock (sf)
Color (sf)
Context (sf)
ContextSettings (sf)
ConvexShape (sf)
Shader::CurrentTextureType (sf)
Cursor (sf)
+
+
D
+
Ftp::DirectoryResponse (sf)
Drawable (sf)
+
+
E
+
Event (sf)
+
+
F
+
FileInputStream (sf)
Font (sf)
Ftp (sf)
+
+
G
+
GlResource (sf)
Glyph (sf)
+
+
H
+
Http (sf)
+
+
I
+
Joystick::Identification (sf)
Image (sf)
Font::Info (sf)
SoundFileReader::Info (sf)
InputSoundFile (sf)
InputStream (sf)
IpAddress (sf)
+
+
J
+
Joystick (sf)
Event::JoystickButtonEvent (sf)
Event::JoystickConnectEvent (sf)
Event::JoystickMoveEvent (sf)
+
+
K
+
Keyboard (sf)
Event::KeyEvent (sf)
+
+
L
+
Listener (sf)
Ftp::ListingResponse (sf)
Lock (sf)
+
+
M
+
MemoryInputStream (sf)
Mouse (sf)
Event::MouseButtonEvent (sf)
Event::MouseMoveEvent (sf)
Event::MouseWheelEvent (sf)
Event::MouseWheelScrollEvent (sf)
Music (sf)
Mutex (sf)
+
+
N
+
NonCopyable (sf)
+
+
O
+
OutputSoundFile (sf)
+
+
P
+
Packet (sf)
+
+
R
+
Rect (sf)
RectangleShape (sf)
RenderStates (sf)
RenderTarget (sf)
RenderTexture (sf)
RenderWindow (sf)
Http::Request (sf)
Ftp::Response (sf)
Http::Response (sf)
+
+
S
+
Keyboard::Scan (sf)
Sensor (sf)
Event::SensorEvent (sf)
Shader (sf)
Shape (sf)
Event::SizeEvent (sf)
Socket (sf)
SocketSelector (sf)
Sound (sf)
SoundBuffer (sf)
SoundBufferRecorder (sf)
SoundFileFactory (sf)
SoundFileReader (sf)
SoundFileWriter (sf)
SoundRecorder (sf)
SoundSource (sf)
SoundStream (sf)
Music::Span (sf)
Sprite (sf)
String (sf)
+
+
T
+
TcpListener (sf)
TcpSocket (sf)
Text (sf)
Event::TextEvent (sf)
Texture (sf)
Thread (sf)
ThreadLocal (sf)
ThreadLocalPtr (sf)
Time (sf)
Touch (sf)
Event::TouchEvent (sf)
Transform (sf)
Transformable (sf)
GlResource::TransientContextLock (sf)
+
+
U
+
UdpSocket (sf)
Utf (sf)
Utf< 16 > (sf)
Utf< 32 > (sf)
Utf< 8 > (sf)
+
+
V
+
Vector2 (sf)
Vector3 (sf)
Vertex (sf)
VertexArray (sf)
VertexBuffer (sf)
VideoMode (sf)
View (sf)
Vulkan (sf)
+
+
W
+
Window (sf)
WindowBase (sf)
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1AlResource-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1AlResource-members.html new file mode 100644 index 000000000..f2ba9c4b4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1AlResource-members.html @@ -0,0 +1,110 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::AlResource Member List
+
+
+ +

This is the complete list of members for sf::AlResource, including all inherited members.

+ + + +
AlResource()sf::AlResourceprotected
~AlResource()sf::AlResourceprotected
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1AlResource.html b/Space-Invaders/sfml/doc/html/classsf_1_1AlResource.html new file mode 100644 index 000000000..eba571b52 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1AlResource.html @@ -0,0 +1,201 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Protected Member Functions | +List of all members
+
sf::AlResource Class Reference
Audio module
+
+
+ +

Base class for classes that require an OpenAL context. + More...

+ +

#include <SFML/Audio/AlResource.hpp>

+
+Inheritance diagram for sf::AlResource:
+
+
+ + +sf::SoundBuffer +sf::SoundRecorder +sf::SoundSource +sf::SoundBufferRecorder +sf::Sound +sf::SoundStream +sf::Music + +
+ + + + + + + + +

+Protected Member Functions

 AlResource ()
 Default constructor.
 
 ~AlResource ()
 Destructor.
 
+

Detailed Description

+

Base class for classes that require an OpenAL context.

+

This class is for internal use only, it must be the base of every class that requires a valid OpenAL context in order to work.

+ +

Definition at line 40 of file AlResource.hpp.

+

Constructor & Destructor Documentation

+ +

◆ AlResource()

+ +
+
+ + + + + +
+ + + + + + + +
sf::AlResource::AlResource ()
+ 		+protected
+
+ +

Default constructor.

+ +
+
+ +

◆ ~AlResource()

+ +
+
+ + + + + +
+ + + + + + + +
sf::AlResource::~AlResource ()
+ 		+protected
+
+ +

Destructor.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1AlResource.png b/Space-Invaders/sfml/doc/html/classsf_1_1AlResource.png new file mode 100644 index 000000000..6b9d1a7b5 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1AlResource.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1CircleShape-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1CircleShape-members.html new file mode 100644 index 000000000..533a74c59 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1CircleShape-members.html @@ -0,0 +1,150 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::CircleShape Member List
+
+
+ +

This is the complete list of members for sf::CircleShape, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CircleShape(float radius=0, std::size_t pointCount=30)sf::CircleShapeexplicit
getFillColor() constsf::Shape
getGlobalBounds() constsf::Shape
getInverseTransform() constsf::Transformable
getLocalBounds() constsf::Shape
getOrigin() constsf::Transformable
getOutlineColor() constsf::Shape
getOutlineThickness() constsf::Shape
getPoint(std::size_t index) constsf::CircleShapevirtual
getPointCount() constsf::CircleShapevirtual
getPosition() constsf::Transformable
getRadius() constsf::CircleShape
getRotation() constsf::Transformable
getScale() constsf::Transformable
getTexture() constsf::Shape
getTextureRect() constsf::Shape
getTransform() constsf::Transformable
move(float offsetX, float offsetY)sf::Transformable
move(const Vector2f &offset)sf::Transformable
rotate(float angle)sf::Transformable
scale(float factorX, float factorY)sf::Transformable
scale(const Vector2f &factor)sf::Transformable
setFillColor(const Color &color)sf::Shape
setOrigin(float x, float y)sf::Transformable
setOrigin(const Vector2f &origin)sf::Transformable
setOutlineColor(const Color &color)sf::Shape
setOutlineThickness(float thickness)sf::Shape
setPointCount(std::size_t count)sf::CircleShape
setPosition(float x, float y)sf::Transformable
setPosition(const Vector2f &position)sf::Transformable
setRadius(float radius)sf::CircleShape
setRotation(float angle)sf::Transformable
setScale(float factorX, float factorY)sf::Transformable
setScale(const Vector2f &factors)sf::Transformable
setTexture(const Texture *texture, bool resetRect=false)sf::Shape
setTextureRect(const IntRect &rect)sf::Shape
Shape()sf::Shapeprotected
Transformable()sf::Transformable
update()sf::Shapeprotected
~Drawable()sf::Drawableinlinevirtual
~Shape()sf::Shapevirtual
~Transformable()sf::Transformablevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1CircleShape.html b/Space-Invaders/sfml/doc/html/classsf_1_1CircleShape.html new file mode 100644 index 000000000..f52326f15 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1CircleShape.html @@ -0,0 +1,1552 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Protected Member Functions | +List of all members
+
sf::CircleShape Class Reference
Graphics module
+
+
+ +

Specialized shape representing a circle. + More...

+ +

#include <SFML/Graphics/CircleShape.hpp>

+
+Inheritance diagram for sf::CircleShape:
+
+
+ + +sf::Shape +sf::Drawable +sf::Transformable + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 CircleShape (float radius=0, std::size_t pointCount=30)
 Default constructor.
 
void setRadius (float radius)
 Set the radius of the circle.
 
float getRadius () const
 Get the radius of the circle.
 
void setPointCount (std::size_t count)
 Set the number of points of the circle.
 
virtual std::size_t getPointCount () const
 Get the number of points of the circle.
 
virtual Vector2f getPoint (std::size_t index) const
 Get a point of the circle.
 
void setTexture (const Texture *texture, bool resetRect=false)
 Change the source texture of the shape.
 
void setTextureRect (const IntRect &rect)
 Set the sub-rectangle of the texture that the shape will display.
 
void setFillColor (const Color &color)
 Set the fill color of the shape.
 
void setOutlineColor (const Color &color)
 Set the outline color of the shape.
 
void setOutlineThickness (float thickness)
 Set the thickness of the shape's outline.
 
const Texture * getTexture () const
 Get the source texture of the shape.
 
const IntRect & getTextureRect () const
 Get the sub-rectangle of the texture displayed by the shape.
 
const Color & getFillColor () const
 Get the fill color of the shape.
 
const Color & getOutlineColor () const
 Get the outline color of the shape.
 
float getOutlineThickness () const
 Get the outline thickness of the shape.
 
FloatRect getLocalBounds () const
 Get the local bounding rectangle of the entity.
 
FloatRect getGlobalBounds () const
 Get the global (non-minimal) bounding rectangle of the entity.
 
void setPosition (float x, float y)
 set the position of the object
 
void setPosition (const Vector2f &position)
 set the position of the object
 
void setRotation (float angle)
 set the orientation of the object
 
void setScale (float factorX, float factorY)
 set the scale factors of the object
 
void setScale (const Vector2f &factors)
 set the scale factors of the object
 
void setOrigin (float x, float y)
 set the local origin of the object
 
void setOrigin (const Vector2f &origin)
 set the local origin of the object
 
const Vector2f & getPosition () const
 get the position of the object
 
float getRotation () const
 get the orientation of the object
 
const Vector2f & getScale () const
 get the current scale of the object
 
const Vector2f & getOrigin () const
 get the local origin of the object
 
void move (float offsetX, float offsetY)
 Move the object by a given offset.
 
void move (const Vector2f &offset)
 Move the object by a given offset.
 
void rotate (float angle)
 Rotate the object.
 
void scale (float factorX, float factorY)
 Scale the object.
 
void scale (const Vector2f &factor)
 Scale the object.
 
const Transform & getTransform () const
 get the combined transform of the object
 
const Transform & getInverseTransform () const
 get the inverse of the combined transform of the object
 
+ + + + +

+Protected Member Functions

void update ()
 Recompute the internal geometry of the shape.
 
+

Detailed Description

+

Specialized shape representing a circle.

+

This class inherits all the functions of sf::Transformable (position, rotation, scale, bounds, ...) as well as the functions of sf::Shape (outline, color, texture, ...).

+

Usage example:

sf::CircleShape circle;
+
circle.setRadius(150);
+
circle.setOutlineColor(sf::Color::Red);
+
circle.setOutlineThickness(5);
+
circle.setPosition(10, 20);
+
...
+
window.draw(circle);
+
sf::CircleShape
Specialized shape representing a circle.
Definition: CircleShape.hpp:42
+
sf::CircleShape::setRadius
void setRadius(float radius)
Set the radius of the circle.
+
sf::Color::Red
static const Color Red
Red predefined color.
Definition: Color.hpp:85
+
sf::Shape::setOutlineColor
void setOutlineColor(const Color &color)
Set the outline color of the shape.
+
sf::Shape::setOutlineThickness
void setOutlineThickness(float thickness)
Set the thickness of the shape's outline.
+
sf::Transformable::setPosition
void setPosition(float x, float y)
set the position of the object
+

Since the graphics card can't draw perfect circles, we have to fake them with multiple triangles connected to each other. The "points count" property of sf::CircleShape defines how many of these triangles to use, and therefore defines the quality of the circle.

+

The number of points can also be used for another purpose; with small numbers you can create any regular polygon shape: equilateral triangle, square, pentagon, hexagon, ...

+
See also
sf::Shape, sf::RectangleShape, sf::ConvexShape
+ +

Definition at line 41 of file CircleShape.hpp.

+

Constructor & Destructor Documentation

+ +

◆ CircleShape()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
sf::CircleShape::CircleShape (float radius = 0,
std::size_t pointCount = 30 
)
+ 		+explicit
+
+ +

Default constructor.

+
Parameters
+ + + +
radiusRadius of the circle
pointCountNumber of points composing the circle
+
+
+ +
+
+

Member Function Documentation

+ +

◆ getFillColor()

+ +
+
+ + + + + +
+ + + + + + + +
const Color & sf::Shape::getFillColor () const
+ 		+inherited
+
+ +

Get the fill color of the shape.

+
Returns
Fill color of the shape
+
See also
setFillColor
+ +
+
+ +

◆ getGlobalBounds()

+ +
+
+ + + + + +
+ + + + + + + +
FloatRect sf::Shape::getGlobalBounds () const
+ 		+inherited
+
+ +

Get the global (non-minimal) bounding rectangle of the entity.

+

The returned rectangle is in global coordinates, which means that it takes into account the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the shape in the global 2D world's coordinate system.

+

This function does not necessarily return the minimal bounding rectangle. It merely ensures that the returned rectangle covers all the vertices (but possibly more). This allows for a fast approximation of the bounds as a first check; you may want to use more precise checks on top of that.

+
Returns
Global bounding rectangle of the entity
+ +
+
+ +

◆ getInverseTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getInverseTransform () const
+ 		+inherited
+
+ +

get the inverse of the combined transform of the object

+
Returns
Inverse of the combined transformations applied to the object
+
See also
getTransform
+ +
+
+ +

◆ getLocalBounds()

+ +
+
+ + + + + +
+ + + + + + + +
FloatRect sf::Shape::getLocalBounds () const
+ 		+inherited
+
+ +

Get the local bounding rectangle of the entity.

+

The returned rectangle is in local coordinates, which means that it ignores the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the entity in the entity's coordinate system.

+
Returns
Local bounding rectangle of the entity
+ +
+
+ +

◆ getOrigin()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getOrigin () const
+ 		+inherited
+
+ +

get the local origin of the object

+
Returns
Current origin
+
See also
setOrigin
+ +
+
+ +

◆ getOutlineColor()

+ +
+
+ + + + + +
+ + + + + + + +
const Color & sf::Shape::getOutlineColor () const
+ 		+inherited
+
+ +

Get the outline color of the shape.

+
Returns
Outline color of the shape
+
See also
setOutlineColor
+ +
+
+ +

◆ getOutlineThickness()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::Shape::getOutlineThickness () const
+ 		+inherited
+
+ +

Get the outline thickness of the shape.

+
Returns
Outline thickness of the shape
+
See also
setOutlineThickness
+ +
+
+ +

◆ getPoint()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual Vector2f sf::CircleShape::getPoint (std::size_t index) const
+ 		+virtual
+
+ +

Get a point of the circle.

+

The returned point is in local coordinates, that is, the shape's transforms (position, rotation, scale) are not taken into account. The result is undefined if index is out of the valid range.

+
Parameters
+ + +
indexIndex of the point to get, in range [0 .. getPointCount() - 1]
+
+
+
Returns
index-th point of the shape
+ +

Implements sf::Shape.

+ +
+
+ +

◆ getPointCount()

+ +
+
+ + + + + +
+ + + + + + + +
virtual std::size_t sf::CircleShape::getPointCount () const
+ 		+virtual
+
+ +

Get the number of points of the circle.

+
Returns
Number of points of the circle
+
See also
setPointCount
+ +

Implements sf::Shape.

+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getPosition () const
+ 		+inherited
+
+ +

get the position of the object

+
Returns
Current position
+
See also
setPosition
+ +
+
+ +

◆ getRadius()

+ +
+
+ + + + + + + +
float sf::CircleShape::getRadius () const
+
+ +

Get the radius of the circle.

+
Returns
Radius of the circle
+
See also
setRadius
+ +
+
+ +

◆ getRotation()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::Transformable::getRotation () const
+ 		+inherited
+
+ +

get the orientation of the object

+

The rotation is always in the range [0, 360].

+
Returns
Current rotation, in degrees
+
See also
setRotation
+ +
+
+ +

◆ getScale()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getScale () const
+ 		+inherited
+
+ +

get the current scale of the object

+
Returns
Current scale factors
+
See also
setScale
+ +
+
+ +

◆ getTexture()

+ +
+
+ + + + + +
+ + + + + + + +
const Texture * sf::Shape::getTexture () const
+ 		+inherited
+
+ +

Get the source texture of the shape.

+

If the shape has no source texture, a NULL pointer is returned. The returned pointer is const, which means that you can't modify the texture when you retrieve it with this function.

+
Returns
Pointer to the shape's texture
+
See also
setTexture
+ +
+
+ +

◆ getTextureRect()

+ +
+
+ + + + + +
+ + + + + + + +
const IntRect & sf::Shape::getTextureRect () const
+ 		+inherited
+
+ +

Get the sub-rectangle of the texture displayed by the shape.

+
Returns
Texture rectangle of the shape
+
See also
setTextureRect
+ +
+
+ +

◆ getTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getTransform () const
+ 		+inherited
+
+ +

get the combined transform of the object

+
Returns
Transform combining the position/rotation/scale/origin of the object
+
See also
getInverseTransform
+ +
+
+ +

◆ move() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::move (const Vector2f & offset)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

object.setPosition(object.getPosition() + offset);
+
sf::Transformable::getPosition
const Vector2f & getPosition() const
get the position of the object
+
Parameters
+ + +
offsetOffset
+
+
+
See also
setPosition
+ +
+
+ +

◆ move() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::move (float offsetX,
float offsetY 
)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f pos = object.getPosition();
+
object.setPosition(pos.x + offsetX, pos.y + offsetY);
+ +
sf::Vector2::x
T x
X coordinate of the vector.
Definition: Vector2.hpp:75
+
sf::Vector2::y
T y
Y coordinate of the vector.
Definition: Vector2.hpp:76
+
Parameters
+ + + +
offsetXX offset
offsetYY offset
+
+
+
See also
setPosition
+ +
+
+ +

◆ rotate()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::rotate (float angle)
+ 		+inherited
+
+ +

Rotate the object.

+

This function adds to the current rotation of the object, unlike setRotation which overwrites it. Thus, it is equivalent to the following code:

object.setRotation(object.getRotation() + angle);
+
sf::Transformable::getRotation
float getRotation() const
get the orientation of the object
+
Parameters
+ + +
angleAngle of rotation, in degrees
+
+
+ +
+
+ +

◆ scale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::scale (const Vector2f & factor)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factor.x, scale.y * factor.y);
+
sf::Transformable::scale
void scale(float factorX, float factorY)
Scale the object.
+
Parameters
+ + +
factorScale factors
+
+
+
See also
setScale
+ +
+
+ +

◆ scale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::scale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factorX, scale.y * factorY);
+
Parameters
+ + + +
factorXHorizontal scale factor
factorYVertical scale factor
+
+
+
See also
setScale
+ +
+
+ +

◆ setFillColor()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setFillColor (const Color & color)
+ 		+inherited
+
+ +

Set the fill color of the shape.

+

This color is modulated (multiplied) with the shape's texture if any. It can be used to colorize the shape, or change its global opacity. You can use sf::Color::Transparent to make the inside of the shape transparent, and have the outline alone. By default, the shape's fill color is opaque white.

+
Parameters
+ + +
colorNew color of the shape
+
+
+
See also
getFillColor, setOutlineColor
+ +
+
+ +

◆ setOrigin() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setOrigin (const Vector2f & origin)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + +
originNew origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOrigin() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setOrigin (float x,
float y 
)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new origin
yY coordinate of the new origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOutlineColor()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setOutlineColor (const Color & color)
+ 		+inherited
+
+ +

Set the outline color of the shape.

+

By default, the shape's outline color is opaque white.

+
Parameters
+ + +
colorNew outline color of the shape
+
+
+
See also
getOutlineColor, setFillColor
+ +
+
+ +

◆ setOutlineThickness()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setOutlineThickness (float thickness)
+ 		+inherited
+
+ +

Set the thickness of the shape's outline.

+

Note that negative values are allowed (so that the outline expands towards the center of the shape), and using zero disables the outline. By default, the outline thickness is 0.

+
Parameters
+ + +
thicknessNew outline thickness
+
+
+
See also
getOutlineThickness
+ +
+
+ +

◆ setPointCount()

+ +
+
+ + + + + + + + +
void sf::CircleShape::setPointCount (std::size_t count)
+
+ +

Set the number of points of the circle.

+
Parameters
+ + +
countNew number of points of the circle
+
+
+
See also
getPointCount
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setPosition (const Vector2f & position)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + +
positionNew position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setPosition (float x,
float y 
)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new position
yY coordinate of the new position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setRadius()

+ +
+
+ + + + + + + + +
void sf::CircleShape::setRadius (float radius)
+
+ +

Set the radius of the circle.

+
Parameters
+ + +
radiusNew radius of the circle
+
+
+
See also
getRadius
+ +
+
+ +

◆ setRotation()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setRotation (float angle)
+ 		+inherited
+
+ +

set the orientation of the object

+

This function completely overwrites the previous rotation. See the rotate function to add an angle based on the previous rotation instead. The default rotation of a transformable object is 0.

+
Parameters
+ + +
angleNew rotation, in degrees
+
+
+
See also
rotate, getRotation
+ +
+
+ +

◆ setScale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setScale (const Vector2f & factors)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + +
factorsNew scale factors
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setScale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setScale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + + +
factorXNew horizontal scale factor
factorYNew vertical scale factor
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setTexture()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Shape::setTexture (const Texture * texture,
bool resetRect = false 
)
+ 		+inherited
+
+ +

Change the source texture of the shape.

+

The texture argument refers to a texture that must exist as long as the shape uses it. Indeed, the shape doesn't store its own copy of the texture, but rather keeps a pointer to the one that you passed to this function. If the source texture is destroyed and the shape tries to use it, the behavior is undefined. texture can be NULL to disable texturing. If resetRect is true, the TextureRect property of the shape is automatically adjusted to the size of the new texture. If it is false, the texture rect is left unchanged.

+
Parameters
+ + + +
textureNew texture
resetRectShould the texture rect be reset to the size of the new texture?
+
+
+
See also
getTexture, setTextureRect
+ +
+
+ +

◆ setTextureRect()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setTextureRect (const IntRect & rect)
+ 		+inherited
+
+ +

Set the sub-rectangle of the texture that the shape will display.

+

The texture rect is useful when you don't want to display the whole texture, but rather a part of it. By default, the texture rect covers the entire texture.

+
Parameters
+ + +
rectRectangle defining the region of the texture to display
+
+
+
See also
getTextureRect, setTexture
+ +
+
+ +

◆ update()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Shape::update ()
+ 		+protectedinherited
+
+ +

Recompute the internal geometry of the shape.

+

This function must be called by the derived class everytime the shape's points change (i.e. the result of either getPointCount or getPoint is different).

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1CircleShape.png b/Space-Invaders/sfml/doc/html/classsf_1_1CircleShape.png new file mode 100644 index 000000000..e1ff5367e Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1CircleShape.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Clipboard-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Clipboard-members.html new file mode 100644 index 000000000..950399e2a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Clipboard-members.html @@ -0,0 +1,110 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Clipboard Member List
+
+
+ +

This is the complete list of members for sf::Clipboard, including all inherited members.

+ + + +
getString()sf::Clipboardstatic
setString(const String &text)sf::Clipboardstatic
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Clipboard.html b/Space-Invaders/sfml/doc/html/classsf_1_1Clipboard.html new file mode 100644 index 000000000..ab4a86c9b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Clipboard.html @@ -0,0 +1,231 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +List of all members
+
sf::Clipboard Class Reference
Window module
+
+
+ +

Give access to the system clipboard. + More...

+ +

#include <SFML/Window/Clipboard.hpp>

+ + + + + + + + +

+Static Public Member Functions

static String getString ()
 Get the content of the clipboard as string data.
 
static void setString (const String &text)
 Set the content of the clipboard as string data.
 
+

Detailed Description

+

Give access to the system clipboard.

+

sf::Clipboard provides an interface for getting and setting the contents of the system clipboard.

+

It is important to note that due to limitations on some operating systems, setting the clipboard contents is only guaranteed to work if there is currently an open window for which events are being handled.

+

Usage example:

// get the clipboard content as a string
+
sf::String string = sf::Clipboard::getString();
+
+
// or use it in the event loop
+
sf::Event event;
+
while(window.pollEvent(event))
+
{
+
if(event.type == sf::Event::Closed)
+
window.close();
+
if(event.type == sf::Event::KeyPressed)
+
{
+
// Using Ctrl + V to paste a string into SFML
+
if(event.key.control && event.key.code == sf::Keyboard::V)
+
string = sf::Clipboard::getString();
+
+
// Using Ctrl + C to copy a string out of SFML
+
if(event.key.control && event.key.code == sf::Keyboard::C)
+
sf::Clipboard::setString("Hello World!");
+
}
+
}
+
sf::Clipboard::setString
static void setString(const String &text)
Set the content of the clipboard as string data.
+
sf::Clipboard::getString
static String getString()
Get the content of the clipboard as string data.
+
sf::Event
Defines a system event and its parameters.
Definition: Event.hpp:45
+
sf::Event::key
KeyEvent key
Key event parameters (Event::KeyPressed, Event::KeyReleased)
Definition: Event.hpp:225
+
sf::Event::type
EventType type
Type of the event.
Definition: Event.hpp:220
+
sf::Event::Closed
@ Closed
The window requested to be closed (no data)
Definition: Event.hpp:190
+
sf::Event::KeyPressed
@ KeyPressed
A key was pressed (data in event.key)
Definition: Event.hpp:195
+
sf::Keyboard::C
@ C
The C key.
Definition: Keyboard.hpp:59
+
sf::Keyboard::V
@ V
The V key.
Definition: Keyboard.hpp:78
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+
sf::Event::KeyEvent::code
Keyboard::Key code
Code of the key that has been pressed.
Definition: Event.hpp:64
+
sf::Event::KeyEvent::control
bool control
Is the Control key pressed?
Definition: Event.hpp:67
+
See also
sf::String, sf::Event
+ +

Definition at line 41 of file Clipboard.hpp.

+

Member Function Documentation

+ +

◆ getString()

+ +
+
+ + + + + +
+ + + + + + + +
static String sf::Clipboard::getString ()
+ 		+static
+
+ +

Get the content of the clipboard as string data.

+

This function returns the content of the clipboard as a string. If the clipboard does not contain string it returns an empty sf::String object.

+
Returns
Clipboard contents as sf::String object
+ +
+
+ +

◆ setString()

+ +
+
+ + + + + +
+ + + + + + + + +
static void sf::Clipboard::setString (const String & text)
+ 		+static
+
+ +

Set the content of the clipboard as string data.

+

This function sets the content of the clipboard as a string.

+
Warning
Due to limitations on some operating systems, setting the clipboard contents is only guaranteed to work if there is currently an open window for which events are being handled.
+
Parameters
+ + +
textsf::String containing the data to be sent to the clipboard
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Clock-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Clock-members.html new file mode 100644 index 000000000..a3511e318 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Clock-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Clock Member List
+
+
+ +

This is the complete list of members for sf::Clock, including all inherited members.

+ + + + +
Clock()sf::Clock
getElapsedTime() constsf::Clock
restart()sf::Clock
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Clock.html b/Space-Invaders/sfml/doc/html/classsf_1_1Clock.html new file mode 100644 index 000000000..3c554ccda --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Clock.html @@ -0,0 +1,210 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::Clock Class Reference
System module
+
+
+ +

Utility class that measures the elapsed time. + More...

+ +

#include <SFML/System/Clock.hpp>

+ + + + + + + + + + + +

+Public Member Functions

 Clock ()
 Default constructor.
 
Time getElapsedTime () const
 Get the elapsed time.
 
Time restart ()
 Restart the clock.
 
+

Detailed Description

+

Utility class that measures the elapsed time.

+

sf::Clock is a lightweight class for measuring time.

+

Its provides the most precise time that the underlying OS can achieve (generally microseconds or nanoseconds). It also ensures monotonicity, which means that the returned time can never go backward, even if the system time is changed.

+

Usage example:

sf::Clock clock;
+
...
+
Time time1 = clock.getElapsedTime();
+
...
+
Time time2 = clock.restart();
+
sf::Clock
Utility class that measures the elapsed time.
Definition: Clock.hpp:42
+
sf::Clock::restart
Time restart()
Restart the clock.
+
sf::Clock::getElapsedTime
Time getElapsedTime() const
Get the elapsed time.
+
sf::Time::Time
Time()
Default constructor.
+

The sf::Time value returned by the clock can then be converted to a number of seconds, milliseconds or even microseconds.

+
See also
sf::Time
+ +

Definition at line 41 of file Clock.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Clock()

+ +
+
+ + + + + + + +
sf::Clock::Clock ()
+
+ +

Default constructor.

+

The clock starts automatically after being constructed.

+ +
+
+

Member Function Documentation

+ +

◆ getElapsedTime()

+ +
+
+ + + + + + + +
Time sf::Clock::getElapsedTime () const
+
+ +

Get the elapsed time.

+

This function returns the time elapsed since the last call to restart() (or the construction of the instance if restart() has not been called).

+
Returns
Time elapsed
+ +
+
+ +

◆ restart()

+ +
+
+ + + + + + + +
Time sf::Clock::restart ()
+
+ +

Restart the clock.

+

This function puts the time counter back to zero. It also returns the time elapsed since the clock was started.

+
Returns
Time elapsed
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Color-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Color-members.html new file mode 100644 index 000000000..561747adc --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Color-members.html @@ -0,0 +1,133 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Color Member List
+
+
+ +

This is the complete list of members for sf::Color, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
asf::Color
bsf::Color
Blacksf::Colorstatic
Bluesf::Colorstatic
Color()sf::Color
Color(Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha=255)sf::Color
Color(Uint32 color)sf::Colorexplicit
Cyansf::Colorstatic
gsf::Color
Greensf::Colorstatic
Magentasf::Colorstatic
operator!=(const Color &left, const Color &right)sf::Colorrelated
operator*(const Color &left, const Color &right)sf::Colorrelated
operator*=(Color &left, const Color &right)sf::Colorrelated
operator+(const Color &left, const Color &right)sf::Colorrelated
operator+=(Color &left, const Color &right)sf::Colorrelated
operator-(const Color &left, const Color &right)sf::Colorrelated
operator-=(Color &left, const Color &right)sf::Colorrelated
operator==(const Color &left, const Color &right)sf::Colorrelated
rsf::Color
Redsf::Colorstatic
toInteger() constsf::Color
Transparentsf::Colorstatic
Whitesf::Colorstatic
Yellowsf::Colorstatic
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Color.html b/Space-Invaders/sfml/doc/html/classsf_1_1Color.html new file mode 100644 index 000000000..551dce245 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Color.html @@ -0,0 +1,1056 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Public Attributes | +Static Public Attributes | +Related Functions | +List of all members
+
sf::Color Class Reference
Graphics module
+
+
+ +

Utility class for manipulating RGBA colors. + More...

+ +

#include <SFML/Graphics/Color.hpp>

+ + + + + + + + + + + + + + +

+Public Member Functions

 Color ()
 Default constructor.
 
 Color (Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha=255)
 Construct the color from its 4 RGBA components.
 
 Color (Uint32 color)
 Construct the color from 32-bit unsigned integer.
 
Uint32 toInteger () const
 Retrieve the color as a 32-bit unsigned integer.
 
+ + + + + + + + + + + + + +

+Public Attributes

Uint8 r
 Red component.
 
Uint8 g
 Green component.
 
Uint8 b
 Blue component.
 
Uint8 a
 Alpha (opacity) component.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Attributes

static const Color Black
 Black predefined color.
 
static const Color White
 White predefined color.
 
static const Color Red
 Red predefined color.
 
static const Color Green
 Green predefined color.
 
static const Color Blue
 Blue predefined color.
 
static const Color Yellow
 Yellow predefined color.
 
static const Color Magenta
 Magenta predefined color.
 
static const Color Cyan
 Cyan predefined color.
 
static const Color Transparent
 Transparent (black) predefined color.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Related Functions

(Note that these are not member functions.)

+
bool operator== (const Color &left, const Color &right)
 Overload of the == operator.
 
bool operator!= (const Color &left, const Color &right)
 Overload of the != operator.
 
Color operator+ (const Color &left, const Color &right)
 Overload of the binary + operator.
 
Color operator- (const Color &left, const Color &right)
 Overload of the binary - operator.
 
Color operator* (const Color &left, const Color &right)
 Overload of the binary * operator.
 
Color & operator+= (Color &left, const Color &right)
 Overload of the binary += operator.
 
Color & operator-= (Color &left, const Color &right)
 Overload of the binary -= operator.
 
Color & operator*= (Color &left, const Color &right)
 Overload of the binary *= operator.
 
+

Detailed Description

+

Utility class for manipulating RGBA colors.

+

sf::Color is a simple color class composed of 4 components:

+
    +
  • Red
    • +
  • Green
    • +
  • Blue
    • +
  • Alpha (opacity)
    • +
+

Each component is a public member, an unsigned integer in the range [0, 255]. Thus, colors can be constructed and manipulated very easily:

+
sf::Color color(255, 0, 0); // red
+
color.r = 0; // make it black
+
color.b = 128; // make it dark blue
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+

The fourth component of colors, named "alpha", represents the opacity of the color. A color with an alpha value of 255 will be fully opaque, while an alpha value of 0 will make a color fully transparent, whatever the value of the other components is.

+

The most common colors are already defined as static variables:

sf::Color black = sf::Color::Black;
+
sf::Color white = sf::Color::White;
+
sf::Color red = sf::Color::Red;
+
sf::Color green = sf::Color::Green;
+
sf::Color blue = sf::Color::Blue;
+
sf::Color yellow = sf::Color::Yellow;
+
sf::Color magenta = sf::Color::Magenta;
+
sf::Color cyan = sf::Color::Cyan;
+
sf::Color transparent = sf::Color::Transparent;
+
sf::Color::Red
static const Color Red
Red predefined color.
Definition: Color.hpp:85
+
sf::Color::White
static const Color White
White predefined color.
Definition: Color.hpp:84
+
sf::Color::Transparent
static const Color Transparent
Transparent (black) predefined color.
Definition: Color.hpp:91
+
sf::Color::Cyan
static const Color Cyan
Cyan predefined color.
Definition: Color.hpp:90
+
sf::Color::Magenta
static const Color Magenta
Magenta predefined color.
Definition: Color.hpp:89
+
sf::Color::Black
static const Color Black
Black predefined color.
Definition: Color.hpp:83
+
sf::Color::Green
static const Color Green
Green predefined color.
Definition: Color.hpp:86
+
sf::Color::Blue
static const Color Blue
Blue predefined color.
Definition: Color.hpp:87
+
sf::Color::Yellow
static const Color Yellow
Yellow predefined color.
Definition: Color.hpp:88
+

Colors can also be added and modulated (multiplied) using the overloaded operators + and *.

+ +

Definition at line 40 of file Color.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Color() [1/3]

+ +
+
+ + + + + + + +
sf::Color::Color ()
+
+ +

Default constructor.

+

Constructs an opaque black color. It is equivalent to sf::Color(0, 0, 0, 255).

+ +
+
+ +

◆ Color() [2/3]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sf::Color::Color (Uint8 red,
Uint8 green,
Uint8 blue,
Uint8 alpha = 255 
)
+
+ +

Construct the color from its 4 RGBA components.

+
Parameters
+ + + + + +
redRed component (in the range [0, 255])
greenGreen component (in the range [0, 255])
blueBlue component (in the range [0, 255])
alphaAlpha (opacity) component (in the range [0, 255])
+
+
+ +
+
+ +

◆ Color() [3/3]

+ +
+
+ + + + + +
+ + + + + + + + +
sf::Color::Color (Uint32 color)
+ 		+explicit
+
+ +

Construct the color from 32-bit unsigned integer.

+
Parameters
+ + +
colorNumber containing the RGBA components (in that order)
+
+
+ +
+
+

Member Function Documentation

+ +

◆ toInteger()

+ +
+
+ + + + + + + +
Uint32 sf::Color::toInteger () const
+
+ +

Retrieve the color as a 32-bit unsigned integer.

+
Returns
Color represented as a 32-bit unsigned integer
+ +
+
+

Friends And Related Function Documentation

+ +

◆ operator!=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (const Color & left,
const Color & right 
)
+ 		+related
+
+ +

Overload of the != operator.

+

This operator compares two colors and check if they are different.

+
Parameters
+ + + +
leftLeft operand
rightRight operand
+
+
+
Returns
True if colors are different, false if they are equal
+ +
+
+ +

◆ operator*()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Color operator* (const Color & left,
const Color & right 
)
+ 		+related
+
+ +

Overload of the binary * operator.

+

This operator returns the component-wise multiplication (also called "modulation") of two colors. Components are then divided by 255 so that the result is still in the range [0, 255].

+
Parameters
+ + + +
leftLeft operand
rightRight operand
+
+
+
Returns
Result of left * right
+ +
+
+ +

◆ operator*=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Color & operator*= (Color & left,
const Color & right 
)
+ 		+related
+
+ +

Overload of the binary *= operator.

+

This operator returns the component-wise multiplication (also called "modulation") of two colors, and assigns the result to the left operand. Components are then divided by 255 so that the result is still in the range [0, 255].

+
Parameters
+ + + +
leftLeft operand
rightRight operand
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator+()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Color operator+ (const Color & left,
const Color & right 
)
+ 		+related
+
+ +

Overload of the binary + operator.

+

This operator returns the component-wise sum of two colors. Components that exceed 255 are clamped to 255.

+
Parameters
+ + + +
leftLeft operand
rightRight operand
+
+
+
Returns
Result of left + right
+ +
+
+ +

◆ operator+=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Color & operator+= (Color & left,
const Color & right 
)
+ 		+related
+
+ +

Overload of the binary += operator.

+

This operator computes the component-wise sum of two colors, and assigns the result to the left operand. Components that exceed 255 are clamped to 255.

+
Parameters
+ + + +
leftLeft operand
rightRight operand
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator-()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Color operator- (const Color & left,
const Color & right 
)
+ 		+related
+
+ +

Overload of the binary - operator.

+

This operator returns the component-wise subtraction of two colors. Components below 0 are clamped to 0.

+
Parameters
+ + + +
leftLeft operand
rightRight operand
+
+
+
Returns
Result of left - right
+ +
+
+ +

◆ operator-=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Color & operator-= (Color & left,
const Color & right 
)
+ 		+related
+
+ +

Overload of the binary -= operator.

+

This operator computes the component-wise subtraction of two colors, and assigns the result to the left operand. Components below 0 are clamped to 0.

+
Parameters
+ + + +
leftLeft operand
rightRight operand
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (const Color & left,
const Color & right 
)
+ 		+related
+
+ +

Overload of the == operator.

+

This operator compares two colors and check if they are equal.

+
Parameters
+ + + +
leftLeft operand
rightRight operand
+
+
+
Returns
True if colors are equal, false if they are different
+ +
+
+

Member Data Documentation

+ +

◆ a

+ +
+
+ + + + +
Uint8 sf::Color::a
+
+ +

Alpha (opacity) component.

+ +

Definition at line 99 of file Color.hpp.

+ +
+
+ +

◆ b

+ +
+
+ + + + +
Uint8 sf::Color::b
+
+ +

Blue component.

+ +

Definition at line 98 of file Color.hpp.

+ +
+
+ +

◆ Black

+ +
+
+ + + + + +
+ + + + +
const Color sf::Color::Black
+ 		+static
+
+ +

Black predefined color.

+ +

Definition at line 83 of file Color.hpp.

+ +
+
+ +

◆ Blue

+ +
+
+ + + + + +
+ + + + +
const Color sf::Color::Blue
+ 		+static
+
+ +

Blue predefined color.

+ +

Definition at line 87 of file Color.hpp.

+ +
+
+ +

◆ Cyan

+ +
+
+ + + + + +
+ + + + +
const Color sf::Color::Cyan
+ 		+static
+
+ +

Cyan predefined color.

+ +

Definition at line 90 of file Color.hpp.

+ +
+
+ +

◆ g

+ +
+
+ + + + +
Uint8 sf::Color::g
+
+ +

Green component.

+ +

Definition at line 97 of file Color.hpp.

+ +
+
+ +

◆ Green

+ +
+
+ + + + + +
+ + + + +
const Color sf::Color::Green
+ 		+static
+
+ +

Green predefined color.

+ +

Definition at line 86 of file Color.hpp.

+ +
+
+ +

◆ Magenta

+ +
+
+ + + + + +
+ + + + +
const Color sf::Color::Magenta
+ 		+static
+
+ +

Magenta predefined color.

+ +

Definition at line 89 of file Color.hpp.

+ +
+
+ +

◆ r

+ +
+
+ + + + +
Uint8 sf::Color::r
+
+ +

Red component.

+ +

Definition at line 96 of file Color.hpp.

+ +
+
+ +

◆ Red

+ +
+
+ + + + + +
+ + + + +
const Color sf::Color::Red
+ 		+static
+
+ +

Red predefined color.

+ +

Definition at line 85 of file Color.hpp.

+ +
+
+ +

◆ Transparent

+ +
+
+ + + + + +
+ + + + +
const Color sf::Color::Transparent
+ 		+static
+
+ +

Transparent (black) predefined color.

+ +

Definition at line 91 of file Color.hpp.

+ +
+
+ +

◆ White

+ +
+
+ + + + + +
+ + + + +
const Color sf::Color::White
+ 		+static
+
+ +

White predefined color.

+ +

Definition at line 84 of file Color.hpp.

+ +
+
+ +

◆ Yellow

+ +
+
+ + + + + +
+ + + + +
const Color sf::Color::Yellow
+ 		+static
+
+ +

Yellow predefined color.

+ +

Definition at line 88 of file Color.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Context-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Context-members.html new file mode 100644 index 000000000..b719f354c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Context-members.html @@ -0,0 +1,117 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Context Member List
+
+
+ +

This is the complete list of members for sf::Context, including all inherited members.

+ + + + + + + + + + +
Context()sf::Context
Context(const ContextSettings &settings, unsigned int width, unsigned int height)sf::Context
getActiveContext()sf::Contextstatic
getActiveContextId()sf::Contextstatic
getFunction(const char *name)sf::Contextstatic
getSettings() constsf::Context
isExtensionAvailable(const char *name)sf::Contextstatic
setActive(bool active)sf::Context
~Context()sf::Context
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Context.html b/Space-Invaders/sfml/doc/html/classsf_1_1Context.html new file mode 100644 index 000000000..b32bbf60f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Context.html @@ -0,0 +1,443 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Static Public Member Functions | +List of all members
+
sf::Context Class Reference
Window module
+
+
+ +

Class holding a valid drawing context. + More...

+ +

#include <SFML/Window/Context.hpp>

+
+Inheritance diagram for sf::Context:
+
+
+ + +sf::GlResource +sf::NonCopyable + +
+ + + + + + + + + + + + + + + + + +

+Public Member Functions

 Context ()
 Default constructor.
 
 ~Context ()
 Destructor.
 
bool setActive (bool active)
 Activate or deactivate explicitly the context.
 
const ContextSettings & getSettings () const
 Get the settings of the context.
 
 Context (const ContextSettings &settings, unsigned int width, unsigned int height)
 Construct a in-memory context.
 
+ + + + + + + + + + + + + +

+Static Public Member Functions

static bool isExtensionAvailable (const char *name)
 Check whether a given OpenGL extension is available.
 
static GlFunctionPointer getFunction (const char *name)
 Get the address of an OpenGL function.
 
static const Context * getActiveContext ()
 Get the currently active context.
 
static Uint64 getActiveContextId ()
 Get the currently active context's ID.
 
+

Detailed Description

+

Class holding a valid drawing context.

+

If you need to make OpenGL calls without having an active window (like in a thread), you can use an instance of this class to get a valid context.

+

Having a valid context is necessary for every OpenGL call.

+

Note that a context is only active in its current thread, if you create a new thread it will have no valid context by default.

+

To use a sf::Context instance, just construct it and let it live as long as you need a valid context. No explicit activation is needed, all it has to do is to exist. Its destructor will take care of deactivating and freeing all the attached resources.

+

Usage example:

void threadFunction(void*)
+
{
+
sf::Context context;
+
// from now on, you have a valid context
+
+
// you can make OpenGL calls
+
glClear(GL_DEPTH_BUFFER_BIT);
+
}
+
// the context is automatically deactivated and destroyed
+
// by the sf::Context destructor
+
sf::Context
Class holding a valid drawing context.
Definition: Context.hpp:51
+
+

Definition at line 50 of file Context.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Context() [1/2]

+ +
+
+ + + + + + + +
sf::Context::Context ()
+
+ +

Default constructor.

+

The constructor creates and activates the context

+ +
+
+ +

◆ ~Context()

+ +
+
+ + + + + + + +
sf::Context::~Context ()
+
+ +

Destructor.

+

The destructor deactivates and destroys the context

+ +
+
+ +

◆ Context() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
sf::Context::Context (const ContextSettings & settings,
unsigned int width,
unsigned int height 
)
+
+ +

Construct a in-memory context.

+

This constructor is for internal use, you don't need to bother with it.

+
Parameters
+ + + + +
settingsCreation parameters
widthBack buffer width
heightBack buffer height
+
+
+ +
+
+

Member Function Documentation

+ +

◆ getActiveContext()

+ +
+
+ + + + + +
+ + + + + + + +
static const Context * sf::Context::getActiveContext ()
+ 		+static
+
+ +

Get the currently active context.

+

This function will only return sf::Context objects. Contexts created e.g. by RenderTargets or for internal use will not be returned by this function.

+
Returns
The currently active context or NULL if none is active
+ +
+
+ +

◆ getActiveContextId()

+ +
+
+ + + + + +
+ + + + + + + +
static Uint64 sf::Context::getActiveContextId ()
+ 		+static
+
+ +

Get the currently active context's ID.

+

The context ID is used to identify contexts when managing unshareable OpenGL resources.

+
Returns
The active context's ID or 0 if no context is currently active
+ +
+
+ +

◆ getFunction()

+ +
+
+ + + + + +
+ + + + + + + + +
static GlFunctionPointer sf::Context::getFunction (const char * name)
+ 		+static
+
+ +

Get the address of an OpenGL function.

+
Parameters
+ + +
nameName of the function to get the address of
+
+
+
Returns
Address of the OpenGL function, 0 on failure
+ +
+
+ +

◆ getSettings()

+ +
+
+ + + + + + + +
const ContextSettings & sf::Context::getSettings () const
+
+ +

Get the settings of the context.

+

Note that these settings may be different than the ones passed to the constructor; they are indeed adjusted if the original settings are not directly supported by the system.

+
Returns
Structure containing the settings
+ +
+
+ +

◆ isExtensionAvailable()

+ +
+
+ + + + + +
+ + + + + + + + +
static bool sf::Context::isExtensionAvailable (const char * name)
+ 		+static
+
+ +

Check whether a given OpenGL extension is available.

+
Parameters
+ + +
nameName of the extension to check for
+
+
+
Returns
True if available, false if unavailable
+ +
+
+ +

◆ setActive()

+ +
+
+ + + + + + + + +
bool sf::Context::setActive (bool active)
+
+ +

Activate or deactivate explicitly the context.

+
Parameters
+ + +
activeTrue to activate, false to deactivate
+
+
+
Returns
True on success, false on failure
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Context.png b/Space-Invaders/sfml/doc/html/classsf_1_1Context.png new file mode 100644 index 000000000..fb0bdc261 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Context.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1ConvexShape-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1ConvexShape-members.html new file mode 100644 index 000000000..c200e1af2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1ConvexShape-members.html @@ -0,0 +1,149 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::ConvexShape Member List
+
+
+ +

This is the complete list of members for sf::ConvexShape, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ConvexShape(std::size_t pointCount=0)sf::ConvexShapeexplicit
getFillColor() constsf::Shape
getGlobalBounds() constsf::Shape
getInverseTransform() constsf::Transformable
getLocalBounds() constsf::Shape
getOrigin() constsf::Transformable
getOutlineColor() constsf::Shape
getOutlineThickness() constsf::Shape
getPoint(std::size_t index) constsf::ConvexShapevirtual
getPointCount() constsf::ConvexShapevirtual
getPosition() constsf::Transformable
getRotation() constsf::Transformable
getScale() constsf::Transformable
getTexture() constsf::Shape
getTextureRect() constsf::Shape
getTransform() constsf::Transformable
move(float offsetX, float offsetY)sf::Transformable
move(const Vector2f &offset)sf::Transformable
rotate(float angle)sf::Transformable
scale(float factorX, float factorY)sf::Transformable
scale(const Vector2f &factor)sf::Transformable
setFillColor(const Color &color)sf::Shape
setOrigin(float x, float y)sf::Transformable
setOrigin(const Vector2f &origin)sf::Transformable
setOutlineColor(const Color &color)sf::Shape
setOutlineThickness(float thickness)sf::Shape
setPoint(std::size_t index, const Vector2f &point)sf::ConvexShape
setPointCount(std::size_t count)sf::ConvexShape
setPosition(float x, float y)sf::Transformable
setPosition(const Vector2f &position)sf::Transformable
setRotation(float angle)sf::Transformable
setScale(float factorX, float factorY)sf::Transformable
setScale(const Vector2f &factors)sf::Transformable
setTexture(const Texture *texture, bool resetRect=false)sf::Shape
setTextureRect(const IntRect &rect)sf::Shape
Shape()sf::Shapeprotected
Transformable()sf::Transformable
update()sf::Shapeprotected
~Drawable()sf::Drawableinlinevirtual
~Shape()sf::Shapevirtual
~Transformable()sf::Transformablevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1ConvexShape.html b/Space-Invaders/sfml/doc/html/classsf_1_1ConvexShape.html new file mode 100644 index 000000000..90fb12da4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1ConvexShape.html @@ -0,0 +1,1534 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Protected Member Functions | +List of all members
+
sf::ConvexShape Class Reference
Graphics module
+
+
+ +

Specialized shape representing a convex polygon. + More...

+ +

#include <SFML/Graphics/ConvexShape.hpp>

+
+Inheritance diagram for sf::ConvexShape:
+
+
+ + +sf::Shape +sf::Drawable +sf::Transformable + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 ConvexShape (std::size_t pointCount=0)
 Default constructor.
 
void setPointCount (std::size_t count)
 Set the number of points of the polygon.
 
virtual std::size_t getPointCount () const
 Get the number of points of the polygon.
 
void setPoint (std::size_t index, const Vector2f &point)
 Set the position of a point.
 
virtual Vector2f getPoint (std::size_t index) const
 Get the position of a point.
 
void setTexture (const Texture *texture, bool resetRect=false)
 Change the source texture of the shape.
 
void setTextureRect (const IntRect &rect)
 Set the sub-rectangle of the texture that the shape will display.
 
void setFillColor (const Color &color)
 Set the fill color of the shape.
 
void setOutlineColor (const Color &color)
 Set the outline color of the shape.
 
void setOutlineThickness (float thickness)
 Set the thickness of the shape's outline.
 
const Texture * getTexture () const
 Get the source texture of the shape.
 
const IntRect & getTextureRect () const
 Get the sub-rectangle of the texture displayed by the shape.
 
const Color & getFillColor () const
 Get the fill color of the shape.
 
const Color & getOutlineColor () const
 Get the outline color of the shape.
 
float getOutlineThickness () const
 Get the outline thickness of the shape.
 
FloatRect getLocalBounds () const
 Get the local bounding rectangle of the entity.
 
FloatRect getGlobalBounds () const
 Get the global (non-minimal) bounding rectangle of the entity.
 
void setPosition (float x, float y)
 set the position of the object
 
void setPosition (const Vector2f &position)
 set the position of the object
 
void setRotation (float angle)
 set the orientation of the object
 
void setScale (float factorX, float factorY)
 set the scale factors of the object
 
void setScale (const Vector2f &factors)
 set the scale factors of the object
 
void setOrigin (float x, float y)
 set the local origin of the object
 
void setOrigin (const Vector2f &origin)
 set the local origin of the object
 
const Vector2f & getPosition () const
 get the position of the object
 
float getRotation () const
 get the orientation of the object
 
const Vector2f & getScale () const
 get the current scale of the object
 
const Vector2f & getOrigin () const
 get the local origin of the object
 
void move (float offsetX, float offsetY)
 Move the object by a given offset.
 
void move (const Vector2f &offset)
 Move the object by a given offset.
 
void rotate (float angle)
 Rotate the object.
 
void scale (float factorX, float factorY)
 Scale the object.
 
void scale (const Vector2f &factor)
 Scale the object.
 
const Transform & getTransform () const
 get the combined transform of the object
 
const Transform & getInverseTransform () const
 get the inverse of the combined transform of the object
 
+ + + + +

+Protected Member Functions

void update ()
 Recompute the internal geometry of the shape.
 
+

Detailed Description

+

Specialized shape representing a convex polygon.

+

This class inherits all the functions of sf::Transformable (position, rotation, scale, bounds, ...) as well as the functions of sf::Shape (outline, color, texture, ...).

+

It is important to keep in mind that a convex shape must always be... convex, otherwise it may not be drawn correctly. Moreover, the points must be defined in order; using a random order would result in an incorrect shape.

+

Usage example:

sf::ConvexShape polygon;
+
polygon.setPointCount(3);
+
polygon.setPoint(0, sf::Vector2f(0, 0));
+
polygon.setPoint(1, sf::Vector2f(0, 10));
+
polygon.setPoint(2, sf::Vector2f(25, 5));
+
polygon.setOutlineColor(sf::Color::Red);
+
polygon.setOutlineThickness(5);
+
polygon.setPosition(10, 20);
+
...
+
window.draw(polygon);
+
sf::Color::Red
static const Color Red
Red predefined color.
Definition: Color.hpp:85
+
sf::ConvexShape
Specialized shape representing a convex polygon.
Definition: ConvexShape.hpp:43
+
sf::ConvexShape::setPointCount
void setPointCount(std::size_t count)
Set the number of points of the polygon.
+
sf::ConvexShape::setPoint
void setPoint(std::size_t index, const Vector2f &point)
Set the position of a point.
+
sf::Shape::setOutlineColor
void setOutlineColor(const Color &color)
Set the outline color of the shape.
+
sf::Shape::setOutlineThickness
void setOutlineThickness(float thickness)
Set the thickness of the shape's outline.
+
sf::Transformable::setPosition
void setPosition(float x, float y)
set the position of the object
+ +
See also
sf::Shape, sf::RectangleShape, sf::CircleShape
+ +

Definition at line 42 of file ConvexShape.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ConvexShape()

+ +
+
+ + + + + +
+ + + + + + + + +
sf::ConvexShape::ConvexShape (std::size_t pointCount = 0)
+ 		+explicit
+
+ +

Default constructor.

+
Parameters
+ + +
pointCountNumber of points of the polygon
+
+
+ +
+
+

Member Function Documentation

+ +

◆ getFillColor()

+ +
+
+ + + + + +
+ + + + + + + +
const Color & sf::Shape::getFillColor () const
+ 		+inherited
+
+ +

Get the fill color of the shape.

+
Returns
Fill color of the shape
+
See also
setFillColor
+ +
+
+ +

◆ getGlobalBounds()

+ +
+
+ + + + + +
+ + + + + + + +
FloatRect sf::Shape::getGlobalBounds () const
+ 		+inherited
+
+ +

Get the global (non-minimal) bounding rectangle of the entity.

+

The returned rectangle is in global coordinates, which means that it takes into account the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the shape in the global 2D world's coordinate system.

+

This function does not necessarily return the minimal bounding rectangle. It merely ensures that the returned rectangle covers all the vertices (but possibly more). This allows for a fast approximation of the bounds as a first check; you may want to use more precise checks on top of that.

+
Returns
Global bounding rectangle of the entity
+ +
+
+ +

◆ getInverseTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getInverseTransform () const
+ 		+inherited
+
+ +

get the inverse of the combined transform of the object

+
Returns
Inverse of the combined transformations applied to the object
+
See also
getTransform
+ +
+
+ +

◆ getLocalBounds()

+ +
+
+ + + + + +
+ + + + + + + +
FloatRect sf::Shape::getLocalBounds () const
+ 		+inherited
+
+ +

Get the local bounding rectangle of the entity.

+

The returned rectangle is in local coordinates, which means that it ignores the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the entity in the entity's coordinate system.

+
Returns
Local bounding rectangle of the entity
+ +
+
+ +

◆ getOrigin()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getOrigin () const
+ 		+inherited
+
+ +

get the local origin of the object

+
Returns
Current origin
+
See also
setOrigin
+ +
+
+ +

◆ getOutlineColor()

+ +
+
+ + + + + +
+ + + + + + + +
const Color & sf::Shape::getOutlineColor () const
+ 		+inherited
+
+ +

Get the outline color of the shape.

+
Returns
Outline color of the shape
+
See also
setOutlineColor
+ +
+
+ +

◆ getOutlineThickness()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::Shape::getOutlineThickness () const
+ 		+inherited
+
+ +

Get the outline thickness of the shape.

+
Returns
Outline thickness of the shape
+
See also
setOutlineThickness
+ +
+
+ +

◆ getPoint()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual Vector2f sf::ConvexShape::getPoint (std::size_t index) const
+ 		+virtual
+
+ +

Get the position of a point.

+

The returned point is in local coordinates, that is, the shape's transforms (position, rotation, scale) are not taken into account. The result is undefined if index is out of the valid range.

+
Parameters
+ + +
indexIndex of the point to get, in range [0 .. getPointCount() - 1]
+
+
+
Returns
Position of the index-th point of the polygon
+
See also
setPoint
+ +

Implements sf::Shape.

+ +
+
+ +

◆ getPointCount()

+ +
+
+ + + + + +
+ + + + + + + +
virtual std::size_t sf::ConvexShape::getPointCount () const
+ 		+virtual
+
+ +

Get the number of points of the polygon.

+
Returns
Number of points of the polygon
+
See also
setPointCount
+ +

Implements sf::Shape.

+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getPosition () const
+ 		+inherited
+
+ +

get the position of the object

+
Returns
Current position
+
See also
setPosition
+ +
+
+ +

◆ getRotation()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::Transformable::getRotation () const
+ 		+inherited
+
+ +

get the orientation of the object

+

The rotation is always in the range [0, 360].

+
Returns
Current rotation, in degrees
+
See also
setRotation
+ +
+
+ +

◆ getScale()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getScale () const
+ 		+inherited
+
+ +

get the current scale of the object

+
Returns
Current scale factors
+
See also
setScale
+ +
+
+ +

◆ getTexture()

+ +
+
+ + + + + +
+ + + + + + + +
const Texture * sf::Shape::getTexture () const
+ 		+inherited
+
+ +

Get the source texture of the shape.

+

If the shape has no source texture, a NULL pointer is returned. The returned pointer is const, which means that you can't modify the texture when you retrieve it with this function.

+
Returns
Pointer to the shape's texture
+
See also
setTexture
+ +
+
+ +

◆ getTextureRect()

+ +
+
+ + + + + +
+ + + + + + + +
const IntRect & sf::Shape::getTextureRect () const
+ 		+inherited
+
+ +

Get the sub-rectangle of the texture displayed by the shape.

+
Returns
Texture rectangle of the shape
+
See also
setTextureRect
+ +
+
+ +

◆ getTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getTransform () const
+ 		+inherited
+
+ +

get the combined transform of the object

+
Returns
Transform combining the position/rotation/scale/origin of the object
+
See also
getInverseTransform
+ +
+
+ +

◆ move() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::move (const Vector2f & offset)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

object.setPosition(object.getPosition() + offset);
+
sf::Transformable::getPosition
const Vector2f & getPosition() const
get the position of the object
+
Parameters
+ + +
offsetOffset
+
+
+
See also
setPosition
+ +
+
+ +

◆ move() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::move (float offsetX,
float offsetY 
)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f pos = object.getPosition();
+
object.setPosition(pos.x + offsetX, pos.y + offsetY);
+
sf::Vector2::x
T x
X coordinate of the vector.
Definition: Vector2.hpp:75
+
sf::Vector2::y
T y
Y coordinate of the vector.
Definition: Vector2.hpp:76
+
Parameters
+ + + +
offsetXX offset
offsetYY offset
+
+
+
See also
setPosition
+ +
+
+ +

◆ rotate()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::rotate (float angle)
+ 		+inherited
+
+ +

Rotate the object.

+

This function adds to the current rotation of the object, unlike setRotation which overwrites it. Thus, it is equivalent to the following code:

object.setRotation(object.getRotation() + angle);
+
sf::Transformable::getRotation
float getRotation() const
get the orientation of the object
+
Parameters
+ + +
angleAngle of rotation, in degrees
+
+
+ +
+
+ +

◆ scale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::scale (const Vector2f & factor)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factor.x, scale.y * factor.y);
+
sf::Transformable::scale
void scale(float factorX, float factorY)
Scale the object.
+
Parameters
+ + +
factorScale factors
+
+
+
See also
setScale
+ +
+
+ +

◆ scale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::scale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factorX, scale.y * factorY);
+
Parameters
+ + + +
factorXHorizontal scale factor
factorYVertical scale factor
+
+
+
See also
setScale
+ +
+
+ +

◆ setFillColor()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setFillColor (const Color & color)
+ 		+inherited
+
+ +

Set the fill color of the shape.

+

This color is modulated (multiplied) with the shape's texture if any. It can be used to colorize the shape, or change its global opacity. You can use sf::Color::Transparent to make the inside of the shape transparent, and have the outline alone. By default, the shape's fill color is opaque white.

+
Parameters
+ + +
colorNew color of the shape
+
+
+
See also
getFillColor, setOutlineColor
+ +
+
+ +

◆ setOrigin() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setOrigin (const Vector2f & origin)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + +
originNew origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOrigin() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setOrigin (float x,
float y 
)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new origin
yY coordinate of the new origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOutlineColor()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setOutlineColor (const Color & color)
+ 		+inherited
+
+ +

Set the outline color of the shape.

+

By default, the shape's outline color is opaque white.

+
Parameters
+ + +
colorNew outline color of the shape
+
+
+
See also
getOutlineColor, setFillColor
+ +
+
+ +

◆ setOutlineThickness()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setOutlineThickness (float thickness)
+ 		+inherited
+
+ +

Set the thickness of the shape's outline.

+

Note that negative values are allowed (so that the outline expands towards the center of the shape), and using zero disables the outline. By default, the outline thickness is 0.

+
Parameters
+ + +
thicknessNew outline thickness
+
+
+
See also
getOutlineThickness
+ +
+
+ +

◆ setPoint()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::ConvexShape::setPoint (std::size_t index,
const Vector2f & point 
)
+
+ +

Set the position of a point.

+

Don't forget that the polygon must remain convex, and the points need to stay ordered! setPointCount must be called first in order to set the total number of points. The result is undefined if index is out of the valid range.

+
Parameters
+ + + +
indexIndex of the point to change, in range [0 .. getPointCount() - 1]
pointNew position of the point
+
+
+
See also
getPoint
+ +
+
+ +

◆ setPointCount()

+ +
+
+ + + + + + + + +
void sf::ConvexShape::setPointCount (std::size_t count)
+
+ +

Set the number of points of the polygon.

+

count must be greater than 2 to define a valid shape.

+
Parameters
+ + +
countNew number of points of the polygon
+
+
+
See also
getPointCount
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setPosition (const Vector2f & position)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + +
positionNew position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setPosition (float x,
float y 
)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new position
yY coordinate of the new position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setRotation()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setRotation (float angle)
+ 		+inherited
+
+ +

set the orientation of the object

+

This function completely overwrites the previous rotation. See the rotate function to add an angle based on the previous rotation instead. The default rotation of a transformable object is 0.

+
Parameters
+ + +
angleNew rotation, in degrees
+
+
+
See also
rotate, getRotation
+ +
+
+ +

◆ setScale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setScale (const Vector2f & factors)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + +
factorsNew scale factors
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setScale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setScale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + + +
factorXNew horizontal scale factor
factorYNew vertical scale factor
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setTexture()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Shape::setTexture (const Texture * texture,
bool resetRect = false 
)
+ 		+inherited
+
+ +

Change the source texture of the shape.

+

The texture argument refers to a texture that must exist as long as the shape uses it. Indeed, the shape doesn't store its own copy of the texture, but rather keeps a pointer to the one that you passed to this function. If the source texture is destroyed and the shape tries to use it, the behavior is undefined. texture can be NULL to disable texturing. If resetRect is true, the TextureRect property of the shape is automatically adjusted to the size of the new texture. If it is false, the texture rect is left unchanged.

+
Parameters
+ + + +
textureNew texture
resetRectShould the texture rect be reset to the size of the new texture?
+
+
+
See also
getTexture, setTextureRect
+ +
+
+ +

◆ setTextureRect()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setTextureRect (const IntRect & rect)
+ 		+inherited
+
+ +

Set the sub-rectangle of the texture that the shape will display.

+

The texture rect is useful when you don't want to display the whole texture, but rather a part of it. By default, the texture rect covers the entire texture.

+
Parameters
+ + +
rectRectangle defining the region of the texture to display
+
+
+
See also
getTextureRect, setTexture
+ +
+
+ +

◆ update()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Shape::update ()
+ 		+protectedinherited
+
+ +

Recompute the internal geometry of the shape.

+

This function must be called by the derived class everytime the shape's points change (i.e. the result of either getPointCount or getPoint is different).

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1ConvexShape.png b/Space-Invaders/sfml/doc/html/classsf_1_1ConvexShape.png new file mode 100644 index 000000000..c7298729f Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1ConvexShape.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Cursor-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Cursor-members.html new file mode 100644 index 000000000..693f3b9f6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Cursor-members.html @@ -0,0 +1,135 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Cursor Member List
+
+
+ +

This is the complete list of members for sf::Cursor, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Arrow enum valuesf::Cursor
ArrowWait enum valuesf::Cursor
Cross enum valuesf::Cursor
Cursor()sf::Cursor
Hand enum valuesf::Cursor
Help enum valuesf::Cursor
loadFromPixels(const Uint8 *pixels, Vector2u size, Vector2u hotspot)sf::Cursor
loadFromSystem(Type type)sf::Cursor
NotAllowed enum valuesf::Cursor
SizeAll enum valuesf::Cursor
SizeBottom enum valuesf::Cursor
SizeBottomLeft enum valuesf::Cursor
SizeBottomLeftTopRight enum valuesf::Cursor
SizeBottomRight enum valuesf::Cursor
SizeHorizontal enum valuesf::Cursor
SizeLeft enum valuesf::Cursor
SizeRight enum valuesf::Cursor
SizeTop enum valuesf::Cursor
SizeTopLeft enum valuesf::Cursor
SizeTopLeftBottomRight enum valuesf::Cursor
SizeTopRight enum valuesf::Cursor
SizeVertical enum valuesf::Cursor
Text enum valuesf::Cursor
Type enum namesf::Cursor
Wait enum valuesf::Cursor
WindowBase (defined in sf::Cursor)sf::Cursorfriend
~Cursor()sf::Cursor
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Cursor.html b/Space-Invaders/sfml/doc/html/classsf_1_1Cursor.html new file mode 100644 index 000000000..109db5cd3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Cursor.html @@ -0,0 +1,461 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
sf::Cursor Class Reference
Window module
+
+
+ +

Cursor defines the appearance of a system cursor. + More...

+ +

#include <SFML/Window/Cursor.hpp>

+
+Inheritance diagram for sf::Cursor:
+
+
+ + +sf::NonCopyable + +
+ + + + + +

+Public Types

enum  Type {
+  Arrow +, ArrowWait +, Wait +, Text +,
+  Hand +, SizeHorizontal +, SizeVertical +, SizeTopLeftBottomRight +,
+  SizeBottomLeftTopRight +, SizeLeft +, SizeRight +, SizeTop +,
+  SizeBottom +, SizeTopLeft +, SizeBottomRight +, SizeBottomLeft +,
+  SizeTopRight +, SizeAll +, Cross +, Help +,
+  NotAllowed +
+ }
 Enumeration of the native system cursor types. More...
 
+ + + + + + + + + + + + + +

+Public Member Functions

 Cursor ()
 Default constructor.
 
 ~Cursor ()
 Destructor.
 
bool loadFromPixels (const Uint8 *pixels, Vector2u size, Vector2u hotspot)
 Create a cursor with the provided image.
 
bool loadFromSystem (Type type)
 Create a native system cursor.
 
+ + + +

+Friends

class WindowBase
 
+

Detailed Description

+

Cursor defines the appearance of a system cursor.

+
Warning
Features related to Cursor are not supported on iOS and Android.
+

This class abstracts the operating system resources associated with either a native system cursor or a custom cursor.

+

After loading the cursor the graphical appearance with either loadFromPixels() or loadFromSystem(), the cursor can be changed with sf::Window::setMouseCursor().

+

The behaviour is undefined if the cursor is destroyed while in use by the window.

+

Usage example:

sf::Window window;
+
+
// ... create window as usual ...
+
+
sf::Cursor cursor;
+
if (cursor.loadFromSystem(sf::Cursor::Hand))
+
window.setMouseCursor(cursor);
+
sf::Cursor
Cursor defines the appearance of a system cursor.
Definition: Cursor.hpp:47
+
sf::Cursor::Hand
@ Hand
Pointing hand cursor.
Definition: Cursor.hpp:92
+
sf::Cursor::loadFromSystem
bool loadFromSystem(Type type)
Create a native system cursor.
+
sf::WindowBase::setMouseCursor
void setMouseCursor(const Cursor &cursor)
Set the displayed cursor to a native system cursor.
+
sf::Window
Window that serves as a target for OpenGL rendering.
Definition: Window/Window.hpp:50
+
See also
sf::Window::setMouseCursor
+ +

Definition at line 46 of file Cursor.hpp.

+

Member Enumeration Documentation

+ +

◆ Type

+ +
+
+ + + + +
enum sf::Cursor::Type
+
+ +

Enumeration of the native system cursor types.

+

Refer to the following table to determine which cursor is available on which platform.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Type Linux Mac OS X Windows
sf::Cursor::Arrow yes yes yes
sf::Cursor::ArrowWait no no yes
sf::Cursor::Wait yes no yes
sf::Cursor::Text yes yes yes
sf::Cursor::Hand yes yes yes
sf::Cursor::SizeHorizontal yes yes yes
sf::Cursor::SizeVertical yes yes yes
sf::Cursor::SizeTopLeftBottomRight no yes* yes
sf::Cursor::SizeBottomLeftTopRight no yes* yes
sf::Cursor::SizeLeft yes yes** yes**
sf::Cursor::SizeRight yes yes** yes**
sf::Cursor::SizeTop yes yes** yes**
sf::Cursor::SizeBottom yes yes** yes**
sf::Cursor::SizeTopLeft yes yes** yes**
sf::Cursor::SizeTopRight yes yes** yes**
sf::Cursor::SizeBottomLeft yes yes** yes**
sf::Cursor::SizeBottomRight yes yes** yes**
sf::Cursor::SizeAll yes no yes
sf::Cursor::Cross yes yes yes
sf::Cursor::Help yes yes* yes
sf::Cursor::NotAllowed yes yes yes
+
    +
  • These cursor types are undocumented so may not be available on all versions, but have been tested on 10.13
    • +
+

** On Windows and macOS, double-headed arrows are used

+ + + + + + + + + + + + + + + + + + + + + + +
Enumerator
Arrow 

Arrow cursor (default)

+
ArrowWait 

Busy arrow cursor.

+
Wait 

Busy cursor.

+
Text 

I-beam, cursor when hovering over a field allowing text entry.

+
Hand 

Pointing hand cursor.

+
SizeHorizontal 

Horizontal double arrow cursor.

+
SizeVertical 

Vertical double arrow cursor.

+
SizeTopLeftBottomRight 

Double arrow cursor going from top-left to bottom-right.

+
SizeBottomLeftTopRight 

Double arrow cursor going from bottom-left to top-right.

+
SizeLeft 

Left arrow cursor on Linux, same as SizeHorizontal on other platforms.

+
SizeRight 

Right arrow cursor on Linux, same as SizeHorizontal on other platforms.

+
SizeTop 

Up arrow cursor on Linux, same as SizeVertical on other platforms.

+
SizeBottom 

Down arrow cursor on Linux, same as SizeVertical on other platforms.

+
SizeTopLeft 

Top-left arrow cursor on Linux, same as SizeTopLeftBottomRight on other platforms.

+
SizeBottomRight 

Bottom-right arrow cursor on Linux, same as SizeTopLeftBottomRight on other platforms.

+
SizeBottomLeft 

Bottom-left arrow cursor on Linux, same as SizeBottomLeftTopRight on other platforms.

+
SizeTopRight 

Top-right arrow cursor on Linux, same as SizeBottomLeftTopRight on other platforms.

+
SizeAll 

Combination of SizeHorizontal and SizeVertical.

+
Cross 

Crosshair cursor.

+
Help 

Help cursor.

+
NotAllowed 

Action not allowed cursor.

+
+ +

Definition at line 86 of file Cursor.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Cursor()

+ +
+
+ + + + + + + +
sf::Cursor::Cursor ()
+
+ +

Default constructor.

+

This constructor doesn't actually create the cursor; initially the new instance is invalid and must not be used until either loadFromPixels() or loadFromSystem() is called and successfully created a cursor.

+ +
+
+ +

◆ ~Cursor()

+ +
+
+ + + + + + + +
sf::Cursor::~Cursor ()
+
+ +

Destructor.

+

This destructor releases the system resources associated with this cursor, if any.

+ +
+
+

Member Function Documentation

+ +

◆ loadFromPixels()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::Cursor::loadFromPixels (const Uint8 * pixels,
Vector2u size,
Vector2u hotspot 
)
+
+ +

Create a cursor with the provided image.

+

pixels must be an array of width by height pixels in 32-bit RGBA format. If not, this will cause undefined behavior.

+

If pixels is null or either width or height are 0, the current cursor is left unchanged and the function will return false.

+

In addition to specifying the pixel data, you can also specify the location of the hotspot of the cursor. The hotspot is the pixel coordinate within the cursor image which will be located exactly where the mouse pointer position is. Any mouse actions that are performed will return the window/screen location of the hotspot.

+
Warning
On Unix platforms which do not support colored cursors, the pixels are mapped into a monochrome bitmap: pixels with an alpha channel to 0 are transparent, black if the RGB channel are close to zero, and white otherwise.
+
Parameters
+ + + + +
pixelsArray of pixels of the image
sizeWidth and height of the image
hotspot(x,y) location of the hotspot
+
+
+
Returns
true if the cursor was successfully loaded; false otherwise
+ +
+
+ +

◆ loadFromSystem()

+ +
+
+ + + + + + + + +
bool sf::Cursor::loadFromSystem (Type type)
+
+ +

Create a native system cursor.

+

Refer to the list of cursor available on each system (see sf::Cursor::Type) to know whether a given cursor is expected to load successfully or is not supported by the operating system.

+
Parameters
+ + +
typeNative system cursor type
+
+
+
Returns
true if and only if the corresponding cursor is natively supported by the operating system; false otherwise
+ +
+
+

Friends And Related Function Documentation

+ +

◆ WindowBase

+ +
+
+ + + + + +
+ + + + +
friend class WindowBase
+ 		+friend
+
+ +

Definition at line 183 of file Cursor.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Cursor.png b/Space-Invaders/sfml/doc/html/classsf_1_1Cursor.png new file mode 100644 index 000000000..01d16877c Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Cursor.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Drawable-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Drawable-members.html new file mode 100644 index 000000000..ca4029812 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Drawable-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Drawable Member List
+
+
+ +

This is the complete list of members for sf::Drawable, including all inherited members.

+ + + + +
draw(RenderTarget &target, RenderStates states) const =0sf::Drawableprotectedpure virtual
RenderTarget (defined in sf::Drawable)sf::Drawablefriend
~Drawable()sf::Drawableinlinevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Drawable.html b/Space-Invaders/sfml/doc/html/classsf_1_1Drawable.html new file mode 100644 index 000000000..923021b73 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Drawable.html @@ -0,0 +1,297 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Protected Member Functions | +Friends | +List of all members
+
sf::Drawable Class Referenceabstract
Graphics module
+
+
+ +

Abstract base class for objects that can be drawn to a render target. + More...

+ +

#include <SFML/Graphics/Drawable.hpp>

+
+Inheritance diagram for sf::Drawable:
+
+
+ + +sf::Shape +sf::Sprite +sf::Text +sf::VertexArray +sf::VertexBuffer +sf::CircleShape +sf::ConvexShape +sf::RectangleShape + +
+ + + + + +

+Public Member Functions

virtual ~Drawable ()
 Virtual destructor.
 
+ + + + +

+Protected Member Functions

virtual void draw (RenderTarget &target, RenderStates states) const =0
 Draw the object to a render target.
 
+ + + +

+Friends

class RenderTarget
 
+

Detailed Description

+

Abstract base class for objects that can be drawn to a render target.

+

sf::Drawable is a very simple base class that allows objects of derived classes to be drawn to a sf::RenderTarget.

+

All you have to do in your derived class is to override the draw virtual function.

+

Note that inheriting from sf::Drawable is not mandatory, but it allows this nice syntax "window.draw(object)" rather than "object.draw(window)", which is more consistent with other SFML classes.

+

Example:

class MyDrawable : public sf::Drawable
+
{
+
public:
+
+
...
+
+
private:
+
+
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
+
{
+
// You can draw other high-level objects
+
target.draw(m_sprite, states);
+
+
// ... or use the low-level API
+
states.texture = &m_texture;
+
target.draw(m_vertices, states);
+
+
// ... or draw with OpenGL directly
+
glBegin(GL_QUADS);
+
...
+
glEnd();
+
}
+
+
sf::Sprite m_sprite;
+
sf::Texture m_texture;
+
sf::VertexArray m_vertices;
+
};
+
sf::Drawable
Abstract base class for objects that can be drawn to a render target.
Definition: Drawable.hpp:45
+
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderStates::texture
const Texture * texture
Texture.
Definition: RenderStates.hpp:117
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::RenderTarget::draw
void draw(const Drawable &drawable, const RenderStates &states=RenderStates::Default)
Draw a drawable object to the render target.
+
sf::Sprite
Drawable representation of a texture, with its own transformations, color, etc.
Definition: Sprite.hpp:48
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::VertexArray
Define a set of one or more 2D primitives.
Definition: VertexArray.hpp:46
+
See also
sf::RenderTarget
+ +

Definition at line 44 of file Drawable.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ~Drawable()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::Drawable::~Drawable ()
+ 		+inlinevirtual
+
+ +

Virtual destructor.

+ +

Definition at line 52 of file Drawable.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ draw()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual void sf::Drawable::draw (RenderTarget & target,
RenderStates states 
) const
+ 		+protectedpure virtual
+
+ +

Draw the object to a render target.

+

This is a pure virtual function that has to be implemented by the derived class to define how the drawable should be drawn.

+
Parameters
+ + + +
targetRender target to draw to
statesCurrent render states
+
+
+ +
+
+

Friends And Related Function Documentation

+ +

◆ RenderTarget

+ +
+
+ + + + + +
+ + + + +
friend class RenderTarget
+ 		+friend
+
+ +

Definition at line 56 of file Drawable.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Drawable.png b/Space-Invaders/sfml/doc/html/classsf_1_1Drawable.png new file mode 100644 index 000000000..497b9f253 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Drawable.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Event-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Event-members.html new file mode 100644 index 000000000..1d34c37bd --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Event-members.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Event Member List
+
+
+ +

This is the complete list of members for sf::Event, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Closed enum valuesf::Event
Count enum valuesf::Event
EventType enum namesf::Event
GainedFocus enum valuesf::Event
joystickButtonsf::Event
JoystickButtonPressed enum valuesf::Event
JoystickButtonReleased enum valuesf::Event
joystickConnectsf::Event
JoystickConnected enum valuesf::Event
JoystickDisconnected enum valuesf::Event
joystickMovesf::Event
JoystickMoved enum valuesf::Event
keysf::Event
KeyPressed enum valuesf::Event
KeyReleased enum valuesf::Event
LostFocus enum valuesf::Event
mouseButtonsf::Event
MouseButtonPressed enum valuesf::Event
MouseButtonReleased enum valuesf::Event
MouseEntered enum valuesf::Event
MouseLeft enum valuesf::Event
mouseMovesf::Event
MouseMoved enum valuesf::Event
mouseWheelsf::Event
MouseWheelMoved enum valuesf::Event
mouseWheelScrollsf::Event
MouseWheelScrolled enum valuesf::Event
Resized enum valuesf::Event
sensorsf::Event
SensorChanged enum valuesf::Event
sizesf::Event
textsf::Event
TextEntered enum valuesf::Event
touchsf::Event
TouchBegan enum valuesf::Event
TouchEnded enum valuesf::Event
TouchMoved enum valuesf::Event
typesf::Event
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Event.html b/Space-Invaders/sfml/doc/html/classsf_1_1Event.html new file mode 100644 index 000000000..669783bf6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Event.html @@ -0,0 +1,580 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Public Attributes | +List of all members
+
sf::Event Class Reference
Window module
+
+
+ +

Defines a system event and its parameters. + More...

+ +

#include <SFML/Window/Event.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Classes

struct  JoystickButtonEvent
 Joystick buttons events parameters (JoystickButtonPressed, JoystickButtonReleased) More...
 
struct  JoystickConnectEvent
 Joystick connection events parameters (JoystickConnected, JoystickDisconnected) More...
 
struct  JoystickMoveEvent
 Joystick axis move event parameters (JoystickMoved) More...
 
struct  KeyEvent
 Keyboard event parameters (KeyPressed, KeyReleased) More...
 
struct  MouseButtonEvent
 Mouse buttons events parameters (MouseButtonPressed, MouseButtonReleased) More...
 
struct  MouseMoveEvent
 Mouse move event parameters (MouseMoved) More...
 
struct  MouseWheelEvent
 Mouse wheel events parameters (MouseWheelMoved) More...
 
struct  MouseWheelScrollEvent
 Mouse wheel events parameters (MouseWheelScrolled) More...
 
struct  SensorEvent
 Sensor event parameters (SensorChanged) More...
 
struct  SizeEvent
 Size events parameters (Resized) More...
 
struct  TextEvent
 Text event parameters (TextEntered) More...
 
struct  TouchEvent
 Touch events parameters (TouchBegan, TouchMoved, TouchEnded) More...
 
+ + + + +

+Public Types

enum  EventType {
+  Closed +, Resized +, LostFocus +, GainedFocus +,
+  TextEntered +, KeyPressed +, KeyReleased +, MouseWheelMoved +,
+  MouseWheelScrolled +, MouseButtonPressed +, MouseButtonReleased +, MouseMoved +,
+  MouseEntered +, MouseLeft +, JoystickButtonPressed +, JoystickButtonReleased +,
+  JoystickMoved +, JoystickConnected +, JoystickDisconnected +, TouchBegan +,
+  TouchMoved +, TouchEnded +, SensorChanged +, Count +
+ }
 Enumeration of the different types of events. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Attributes

EventType type
 Type of the event.
 
+union {
   SizeEvent   size
 Size event parameters (Event::Resized) More...
 
   KeyEvent   key
 Key event parameters (Event::KeyPressed, Event::KeyReleased) More...
 
   TextEvent   text
 Text event parameters (Event::TextEntered) More...
 
   MouseMoveEvent   mouseMove
 Mouse move event parameters (Event::MouseMoved) More...
 
   MouseButtonEvent   mouseButton
 Mouse button event parameters (Event::MouseButtonPressed, Event::MouseButtonReleased) More...
 
   MouseWheelEvent   mouseWheel
 Mouse wheel event parameters (Event::MouseWheelMoved) (deprecated) More...
 
   MouseWheelScrollEvent   mouseWheelScroll
 Mouse wheel event parameters (Event::MouseWheelScrolled) More...
 
   JoystickMoveEvent   joystickMove
 Joystick move event parameters (Event::JoystickMoved) More...
 
   JoystickButtonEvent   joystickButton
 Joystick button event parameters (Event::JoystickButtonPressed, Event::JoystickButtonReleased) More...
 
   JoystickConnectEvent   joystickConnect
 Joystick (dis)connect event parameters (Event::JoystickConnected, Event::JoystickDisconnected) More...
 
   TouchEvent   touch
 Touch events parameters (Event::TouchBegan, Event::TouchMoved, Event::TouchEnded) More...
 
   SensorEvent   sensor
 Sensor event parameters (Event::SensorChanged) More...
 
}; 
 
+

Detailed Description

+

Defines a system event and its parameters.

+

sf::Event holds all the informations about a system event that just happened.

+

Events are retrieved using the sf::Window::pollEvent and sf::Window::waitEvent functions.

+

A sf::Event instance contains the type of the event (mouse moved, key pressed, window closed, ...) as well as the details about this particular event. Please note that the event parameters are defined in a union, which means that only the member matching the type of the event will be properly filled; all other members will have undefined values and must not be read if the type of the event doesn't match. For example, if you received a KeyPressed event, then you must read the event.key member, all other members such as event.mouseMove or event.text will have undefined values.

+

Usage example:

sf::Event event;
+
while (window.pollEvent(event))
+
{
+
// Request for closing the window
+
if (event.type == sf::Event::Closed)
+
window.close();
+
+
// The escape key was pressed
+
if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))
+
window.close();
+
+
// The window was resized
+
if (event.type == sf::Event::Resized)
+
doSomethingWithTheNewSize(event.size.width, event.size.height);
+
+
// etc ...
+
}
+
sf::Event
Defines a system event and its parameters.
Definition: Event.hpp:45
+
sf::Event::key
KeyEvent key
Key event parameters (Event::KeyPressed, Event::KeyReleased)
Definition: Event.hpp:225
+
sf::Event::size
SizeEvent size
Size event parameters (Event::Resized)
Definition: Event.hpp:224
+
sf::Event::type
EventType type
Type of the event.
Definition: Event.hpp:220
+
sf::Event::Closed
@ Closed
The window requested to be closed (no data)
Definition: Event.hpp:190
+
sf::Event::Resized
@ Resized
The window was resized (data in event.size)
Definition: Event.hpp:191
+
sf::Event::KeyPressed
@ KeyPressed
A key was pressed (data in event.key)
Definition: Event.hpp:195
+
sf::Keyboard::Escape
@ Escape
The Escape key.
Definition: Keyboard.hpp:93
+
sf::Event::KeyEvent::code
Keyboard::Key code
Code of the key that has been pressed.
Definition: Event.hpp:64
+
sf::Event::SizeEvent::width
unsigned int width
New width, in pixels.
Definition: Event.hpp:54
+
sf::Event::SizeEvent::height
unsigned int height
New height, in pixels.
Definition: Event.hpp:55
+
+

Definition at line 44 of file Event.hpp.

+

Member Enumeration Documentation

+ +

◆ EventType

+ +
+
+ + + + +
enum sf::Event::EventType
+
+ +

Enumeration of the different types of events.

+ + + + + + + + + + + + + + + + + + + + + + + + + +
Enumerator
Closed 

The window requested to be closed (no data)

+
Resized 

The window was resized (data in event.size)

+
LostFocus 

The window lost the focus (no data)

+
GainedFocus 

The window gained the focus (no data)

+
TextEntered 

A character was entered (data in event.text)

+
KeyPressed 

A key was pressed (data in event.key)

+
KeyReleased 

A key was released (data in event.key)

+
MouseWheelMoved 

The mouse wheel was scrolled (data in event.mouseWheel) (deprecated)

+
MouseWheelScrolled 

The mouse wheel was scrolled (data in event.mouseWheelScroll)

+
MouseButtonPressed 

A mouse button was pressed (data in event.mouseButton)

+
MouseButtonReleased 

A mouse button was released (data in event.mouseButton)

+
MouseMoved 

The mouse cursor moved (data in event.mouseMove)

+
MouseEntered 

The mouse cursor entered the area of the window (no data)

+
MouseLeft 

The mouse cursor left the area of the window (no data)

+
JoystickButtonPressed 

A joystick button was pressed (data in event.joystickButton)

+
JoystickButtonReleased 

A joystick button was released (data in event.joystickButton)

+
JoystickMoved 

The joystick moved along an axis (data in event.joystickMove)

+
JoystickConnected 

A joystick was connected (data in event.joystickConnect)

+
JoystickDisconnected 

A joystick was disconnected (data in event.joystickConnect)

+
TouchBegan 

A touch event began (data in event.touch)

+
TouchMoved 

A touch moved (data in event.touch)

+
TouchEnded 

A touch event ended (data in event.touch)

+
SensorChanged 

A sensor value changed (data in event.sensor)

+
Count 

Keep last – the total number of event types.

+
+ +

Definition at line 188 of file Event.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ joystickButton

+ +
+
+ + + + +
JoystickButtonEvent sf::Event::joystickButton
+
+ +

Joystick button event parameters (Event::JoystickButtonPressed, Event::JoystickButtonReleased)

+ +

Definition at line 232 of file Event.hpp.

+ +
+
+ +

◆ joystickConnect

+ +
+
+ + + + +
JoystickConnectEvent sf::Event::joystickConnect
+
+ +

Joystick (dis)connect event parameters (Event::JoystickConnected, Event::JoystickDisconnected)

+ +

Definition at line 233 of file Event.hpp.

+ +
+
+ +

◆ joystickMove

+ +
+
+ + + + +
JoystickMoveEvent sf::Event::joystickMove
+
+ +

Joystick move event parameters (Event::JoystickMoved)

+ +

Definition at line 231 of file Event.hpp.

+ +
+
+ +

◆ key

+ +
+
+ + + + +
KeyEvent sf::Event::key
+
+ +

Key event parameters (Event::KeyPressed, Event::KeyReleased)

+ +

Definition at line 225 of file Event.hpp.

+ +
+
+ +

◆ mouseButton

+ +
+
+ + + + +
MouseButtonEvent sf::Event::mouseButton
+
+ +

Mouse button event parameters (Event::MouseButtonPressed, Event::MouseButtonReleased)

+ +

Definition at line 228 of file Event.hpp.

+ +
+
+ +

◆ mouseMove

+ +
+
+ + + + +
MouseMoveEvent sf::Event::mouseMove
+
+ +

Mouse move event parameters (Event::MouseMoved)

+ +

Definition at line 227 of file Event.hpp.

+ +
+
+ +

◆ mouseWheel

+ +
+
+ + + + +
MouseWheelEvent sf::Event::mouseWheel
+
+ +

Mouse wheel event parameters (Event::MouseWheelMoved) (deprecated)

+ +

Definition at line 229 of file Event.hpp.

+ +
+
+ +

◆ mouseWheelScroll

+ +
+
+ + + + +
MouseWheelScrollEvent sf::Event::mouseWheelScroll
+
+ +

Mouse wheel event parameters (Event::MouseWheelScrolled)

+ +

Definition at line 230 of file Event.hpp.

+ +
+
+ +

◆ sensor

+ +
+
+ + + + +
SensorEvent sf::Event::sensor
+
+ +

Sensor event parameters (Event::SensorChanged)

+ +

Definition at line 235 of file Event.hpp.

+ +
+
+ +

◆ size

+ +
+
+ + + + +
SizeEvent sf::Event::size
+
+ +

Size event parameters (Event::Resized)

+ +

Definition at line 224 of file Event.hpp.

+ +
+
+ +

◆ text

+ +
+
+ + + + +
TextEvent sf::Event::text
+
+ +

Text event parameters (Event::TextEntered)

+ +

Definition at line 226 of file Event.hpp.

+ +
+
+ +

◆ touch

+ +
+
+ + + + +
TouchEvent sf::Event::touch
+
+ +

Touch events parameters (Event::TouchBegan, Event::TouchMoved, Event::TouchEnded)

+ +

Definition at line 234 of file Event.hpp.

+ +
+
+ +

◆ type

+ +
+
+ + + + +
EventType sf::Event::type
+
+ +

Type of the event.

+ +

Definition at line 220 of file Event.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1FileInputStream-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1FileInputStream-members.html new file mode 100644 index 000000000..21b117fdc --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1FileInputStream-members.html @@ -0,0 +1,116 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::FileInputStream Member List
+
+
+ +

This is the complete list of members for sf::FileInputStream, including all inherited members.

+ + + + + + + + + +
FileInputStream()sf::FileInputStream
getSize()sf::FileInputStreamvirtual
open(const std::string &filename)sf::FileInputStream
read(void *data, Int64 size)sf::FileInputStreamvirtual
seek(Int64 position)sf::FileInputStreamvirtual
tell()sf::FileInputStreamvirtual
~FileInputStream()sf::FileInputStreamvirtual
~InputStream()sf::InputStreaminlinevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1FileInputStream.html b/Space-Invaders/sfml/doc/html/classsf_1_1FileInputStream.html new file mode 100644 index 000000000..01146048e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1FileInputStream.html @@ -0,0 +1,389 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::FileInputStream Class Reference
System module
+
+
+ +

Implementation of input stream based on a file. + More...

+ +

#include <SFML/System/FileInputStream.hpp>

+
+Inheritance diagram for sf::FileInputStream:
+
+
+ + +sf::InputStream +sf::NonCopyable + +
+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 FileInputStream ()
 Default constructor.
 
virtual ~FileInputStream ()
 Default destructor.
 
bool open (const std::string &filename)
 Open the stream from a file path.
 
virtual Int64 read (void *data, Int64 size)
 Read data from the stream.
 
virtual Int64 seek (Int64 position)
 Change the current reading position.
 
virtual Int64 tell ()
 Get the current reading position in the stream.
 
virtual Int64 getSize ()
 Return the size of the stream.
 
+

Detailed Description

+

Implementation of input stream based on a file.

+

This class is a specialization of InputStream that reads from a file on disk.

+

It wraps a file in the common InputStream interface and therefore allows to use generic classes or functions that accept such a stream, with a file on disk as the data source.

+

In addition to the virtual functions inherited from InputStream, FileInputStream adds a function to specify the file to open.

+

SFML resource classes can usually be loaded directly from a filename, so this class shouldn't be useful to you unless you create your own algorithms that operate on an InputStream.

+

Usage example:

void process(InputStream& stream);
+
+
FileInputStream stream;
+
if (stream.open("some_file.dat"))
+
process(stream);
+
sf::FileInputStream
Implementation of input stream based on a file.
Definition: FileInputStream.hpp:56
+
sf::FileInputStream::open
bool open(const std::string &filename)
Open the stream from a file path.
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+

InputStream, MemoryInputStream

+ +

Definition at line 55 of file FileInputStream.hpp.

+

Constructor & Destructor Documentation

+ +

◆ FileInputStream()

+ +
+
+ + + + + + + +
sf::FileInputStream::FileInputStream ()
+
+ +

Default constructor.

+ +
+
+ +

◆ ~FileInputStream()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::FileInputStream::~FileInputStream ()
+ 		+virtual
+
+ +

Default destructor.

+ +
+
+

Member Function Documentation

+ +

◆ getSize()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Int64 sf::FileInputStream::getSize ()
+ 		+virtual
+
+ +

Return the size of the stream.

+
Returns
The total number of bytes available in the stream, or -1 on error
+ +

Implements sf::InputStream.

+ +
+
+ +

◆ open()

+ +
+
+ + + + + + + + +
bool sf::FileInputStream::open (const std::string & filename)
+
+ +

Open the stream from a file path.

+
Parameters
+ + +
filenameName of the file to open
+
+
+
Returns
True on success, false on error
+ +
+
+ +

◆ read()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual Int64 sf::FileInputStream::read (void * data,
Int64 size 
)
+ 		+virtual
+
+ +

Read data from the stream.

+

After reading, the stream's reading position must be advanced by the amount of bytes read.

+
Parameters
+ + + +
dataBuffer where to copy the read data
sizeDesired number of bytes to read
+
+
+
Returns
The number of bytes actually read, or -1 on error
+ +

Implements sf::InputStream.

+ +
+
+ +

◆ seek()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual Int64 sf::FileInputStream::seek (Int64 position)
+ 		+virtual
+
+ +

Change the current reading position.

+
Parameters
+ + +
positionThe position to seek to, from the beginning
+
+
+
Returns
The position actually sought to, or -1 on error
+ +

Implements sf::InputStream.

+ +
+
+ +

◆ tell()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Int64 sf::FileInputStream::tell ()
+ 		+virtual
+
+ +

Get the current reading position in the stream.

+
Returns
The current position, or -1 on error.
+ +

Implements sf::InputStream.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1FileInputStream.png b/Space-Invaders/sfml/doc/html/classsf_1_1FileInputStream.png new file mode 100644 index 000000000..ddfc2e0af Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1FileInputStream.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Font-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Font-members.html new file mode 100644 index 000000000..885e0a1bd --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Font-members.html @@ -0,0 +1,125 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Font Member List
+
+
+ +

This is the complete list of members for sf::Font, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
Font()sf::Font
Font(const Font &copy)sf::Font
getGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness=0) constsf::Font
getInfo() constsf::Font
getKerning(Uint32 first, Uint32 second, unsigned int characterSize, bool bold=false) constsf::Font
getLineSpacing(unsigned int characterSize) constsf::Font
getTexture(unsigned int characterSize) constsf::Font
getUnderlinePosition(unsigned int characterSize) constsf::Font
getUnderlineThickness(unsigned int characterSize) constsf::Font
hasGlyph(Uint32 codePoint) constsf::Font
isSmooth() constsf::Font
loadFromFile(const std::string &filename)sf::Font
loadFromMemory(const void *data, std::size_t sizeInBytes)sf::Font
loadFromStream(InputStream &stream)sf::Font
operator=(const Font &right)sf::Font
setSmooth(bool smooth)sf::Font
~Font()sf::Font
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Font.html b/Space-Invaders/sfml/doc/html/classsf_1_1Font.html new file mode 100644 index 000000000..ce949cb48 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Font.html @@ -0,0 +1,737 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Member Functions | +List of all members
+
sf::Font Class Reference
Graphics module
+
+
+ +

Class for loading and manipulating character fonts. + More...

+ +

#include <SFML/Graphics/Font.hpp>

+ + + + + +

+Classes

struct  Info
 Holds various information about a font. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Font ()
 Default constructor.
 
 Font (const Font &copy)
 Copy constructor.
 
 ~Font ()
 Destructor.
 
bool loadFromFile (const std::string &filename)
 Load the font from a file.
 
bool loadFromMemory (const void *data, std::size_t sizeInBytes)
 Load the font from a file in memory.
 
bool loadFromStream (InputStream &stream)
 Load the font from a custom stream.
 
const Info & getInfo () const
 Get the font information.
 
const Glyph & getGlyph (Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness=0) const
 Retrieve a glyph of the font.
 
bool hasGlyph (Uint32 codePoint) const
 Determine if this font has a glyph representing the requested code point.
 
float getKerning (Uint32 first, Uint32 second, unsigned int characterSize, bool bold=false) const
 Get the kerning offset of two glyphs.
 
float getLineSpacing (unsigned int characterSize) const
 Get the line spacing.
 
float getUnderlinePosition (unsigned int characterSize) const
 Get the position of the underline.
 
float getUnderlineThickness (unsigned int characterSize) const
 Get the thickness of the underline.
 
const Texture & getTexture (unsigned int characterSize) const
 Retrieve the texture containing the loaded glyphs of a certain size.
 
void setSmooth (bool smooth)
 Enable or disable the smooth filter.
 
bool isSmooth () const
 Tell whether the smooth filter is enabled or not.
 
Font & operator= (const Font &right)
 Overload of assignment operator.
 
+

Detailed Description

+

Class for loading and manipulating character fonts.

+

Fonts can be loaded from a file, from memory or from a custom stream, and supports the most common types of fonts.

+

See the loadFromFile function for the complete list of supported formats.

+

Once it is loaded, a sf::Font instance provides three types of information about the font:

    +
  • Global metrics, such as the line spacing
    • +
  • Per-glyph metrics, such as bounding box or kerning
    • +
  • Pixel representation of glyphs
    • +
+

Fonts alone are not very useful: they hold the font data but cannot make anything useful of it. To do so you need to use the sf::Text class, which is able to properly output text with several options such as character size, style, color, position, rotation, etc. This separation allows more flexibility and better performances: indeed a sf::Font is a heavy resource, and any operation on it is slow (often too slow for real-time applications). On the other side, a sf::Text is a lightweight object which can combine the glyphs data and metrics of a sf::Font to display any text on a render target. Note that it is also possible to bind several sf::Text instances to the same sf::Font.

+

It is important to note that the sf::Text instance doesn't copy the font that it uses, it only keeps a reference to it. Thus, a sf::Font must not be destructed while it is used by a sf::Text (i.e. never write a function that uses a local sf::Font instance for creating a text).

+

Usage example:

// Declare a new font
+
sf::Font font;
+
+
// Load it from a file
+
if (!font.loadFromFile("arial.ttf"))
+
{
+
// error...
+
}
+
+
// Create a text which uses our font
+
sf::Text text1;
+
text1.setFont(font);
+
text1.setCharacterSize(30);
+
text1.setStyle(sf::Text::Regular);
+
+
// Create another text using the same font, but with different parameters
+
sf::Text text2;
+
text2.setFont(font);
+
text2.setCharacterSize(50);
+
text2.setStyle(sf::Text::Italic);
+
sf::Font
Class for loading and manipulating character fonts.
Definition: Font.hpp:49
+
sf::Font::loadFromFile
bool loadFromFile(const std::string &filename)
Load the font from a file.
+
sf::Text
Graphical text that can be drawn to a render target.
Definition: Text.hpp:49
+
sf::Text::setFont
void setFont(const Font &font)
Set the text's font.
+
sf::Text::Regular
@ Regular
Regular characters, no style.
Definition: Text.hpp:58
+
sf::Text::Italic
@ Italic
Italic characters.
Definition: Text.hpp:60
+
sf::Text::setStyle
void setStyle(Uint32 style)
Set the text's style.
+
sf::Text::setCharacterSize
void setCharacterSize(unsigned int size)
Set the character size.
+

Apart from loading font files, and passing them to instances of sf::Text, you should normally not have to deal directly with this class. However, it may be useful to access the font metrics or rasterized glyphs for advanced usage.

+

Note that if the font is a bitmap font, it is not scalable, thus not all requested sizes will be available to use. This needs to be taken into consideration when using sf::Text. If you need to display text of a certain size, make sure the corresponding bitmap font that supports that size is used.

+
See also
sf::Text
+ +

Definition at line 48 of file Font.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Font() [1/2]

+ +
+
+ + + + + + + +
sf::Font::Font ()
+
+ +

Default constructor.

+

This constructor defines an empty font

+ +
+
+ +

◆ Font() [2/2]

+ +
+
+ + + + + + + + +
sf::Font::Font (const Font & copy)
+
+ +

Copy constructor.

+
Parameters
+ + +
copyInstance to copy
+
+
+ +
+
+ +

◆ ~Font()

+ +
+
+ + + + + + + +
sf::Font::~Font ()
+
+ +

Destructor.

+

Cleans up all the internal resources used by the font

+ +
+
+

Member Function Documentation

+ +

◆ getGlyph()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
const Glyph & sf::Font::getGlyph (Uint32 codePoint,
unsigned int characterSize,
bool bold,
float outlineThickness = 0 
) const
+
+ +

Retrieve a glyph of the font.

+

If the font is a bitmap font, not all character sizes might be available. If the glyph is not available at the requested size, an empty glyph is returned.

+

You may want to use hasGlyph to determine if the glyph exists before requesting it. If the glyph does not exist, a font specific default is returned.

+

Be aware that using a negative value for the outline thickness will cause distorted rendering.

+
Parameters
+ + + + + +
codePointUnicode code point of the character to get
characterSizeReference character size
boldRetrieve the bold version or the regular one?
outlineThicknessThickness of outline (when != 0 the glyph will not be filled)
+
+
+
Returns
The glyph corresponding to codePoint and characterSize
+ +
+
+ +

◆ getInfo()

+ +
+
+ + + + + + + +
const Info & sf::Font::getInfo () const
+
+ +

Get the font information.

+
Returns
A structure that holds the font information
+ +
+
+ +

◆ getKerning()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
float sf::Font::getKerning (Uint32 first,
Uint32 second,
unsigned int characterSize,
bool bold = false 
) const
+
+ +

Get the kerning offset of two glyphs.

+

The kerning is an extra offset (negative) to apply between two glyphs when rendering them, to make the pair look more "natural". For example, the pair "AV" have a special kerning to make them closer than other characters. Most of the glyphs pairs have a kerning offset of zero, though.

+
Parameters
+ + + + +
firstUnicode code point of the first character
secondUnicode code point of the second character
characterSizeReference character size
+
+
+
Returns
Kerning value for first and second, in pixels
+ +
+
+ +

◆ getLineSpacing()

+ +
+
+ + + + + + + + +
float sf::Font::getLineSpacing (unsigned int characterSize) const
+
+ +

Get the line spacing.

+

Line spacing is the vertical offset to apply between two consecutive lines of text.

+
Parameters
+ + +
characterSizeReference character size
+
+
+
Returns
Line spacing, in pixels
+ +
+
+ +

◆ getTexture()

+ +
+
+ + + + + + + + +
const Texture & sf::Font::getTexture (unsigned int characterSize) const
+
+ +

Retrieve the texture containing the loaded glyphs of a certain size.

+

The contents of the returned texture changes as more glyphs are requested, thus it is not very relevant. It is mainly used internally by sf::Text.

+
Parameters
+ + +
characterSizeReference character size
+
+
+
Returns
Texture containing the glyphs of the requested size
+ +
+
+ +

◆ getUnderlinePosition()

+ +
+
+ + + + + + + + +
float sf::Font::getUnderlinePosition (unsigned int characterSize) const
+
+ +

Get the position of the underline.

+

Underline position is the vertical offset to apply between the baseline and the underline.

+
Parameters
+ + +
characterSizeReference character size
+
+
+
Returns
Underline position, in pixels
+
See also
getUnderlineThickness
+ +
+
+ +

◆ getUnderlineThickness()

+ +
+
+ + + + + + + + +
float sf::Font::getUnderlineThickness (unsigned int characterSize) const
+
+ +

Get the thickness of the underline.

+

Underline thickness is the vertical size of the underline.

+
Parameters
+ + +
characterSizeReference character size
+
+
+
Returns
Underline thickness, in pixels
+
See also
getUnderlinePosition
+ +
+
+ +

◆ hasGlyph()

+ +
+
+ + + + + + + + +
bool sf::Font::hasGlyph (Uint32 codePoint) const
+
+ +

Determine if this font has a glyph representing the requested code point.

+

Most fonts only include a very limited selection of glyphs from specific Unicode subsets, like Latin, Cyrillic, or Asian characters.

+

While code points without representation will return a font specific default character, it might be useful to verify whether specific code points are included to determine whether a font is suited to display text in a specific language.

+
Parameters
+ + +
codePointUnicode code point to check
+
+
+
Returns
True if the codepoint has a glyph representation, false otherwise
+ +
+
+ +

◆ isSmooth()

+ +
+
+ + + + + + + +
bool sf::Font::isSmooth () const
+
+ +

Tell whether the smooth filter is enabled or not.

+
Returns
True if smoothing is enabled, false if it is disabled
+
See also
setSmooth
+ +
+
+ +

◆ loadFromFile()

+ +
+
+ + + + + + + + +
bool sf::Font::loadFromFile (const std::string & filename)
+
+ +

Load the font from a file.

+

The supported font formats are: TrueType, Type 1, CFF, OpenType, SFNT, X11 PCF, Windows FNT, BDF, PFR and Type 42. Note that this function knows nothing about the standard fonts installed on the user's system, thus you can't load them directly.

+
Warning
SFML cannot preload all the font data in this function, so the file has to remain accessible until the sf::Font object loads a new font or is destroyed.
+
Parameters
+ + +
filenamePath of the font file to load
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromMemory, loadFromStream
+ +
+
+ +

◆ loadFromMemory()

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Font::loadFromMemory (const void * data,
std::size_t sizeInBytes 
)
+
+ +

Load the font from a file in memory.

+

The supported font formats are: TrueType, Type 1, CFF, OpenType, SFNT, X11 PCF, Windows FNT, BDF, PFR and Type 42.

+
Warning
SFML cannot preload all the font data in this function, so the buffer pointed by data has to remain valid until the sf::Font object loads a new font or is destroyed.
+
Parameters
+ + + +
dataPointer to the file data in memory
sizeInBytesSize of the data to load, in bytes
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromStream
+ +
+
+ +

◆ loadFromStream()

+ +
+
+ + + + + + + + +
bool sf::Font::loadFromStream (InputStream & stream)
+
+ +

Load the font from a custom stream.

+

The supported font formats are: TrueType, Type 1, CFF, OpenType, SFNT, X11 PCF, Windows FNT, BDF, PFR and Type 42. Warning: SFML cannot preload all the font data in this function, so the contents of stream have to remain valid as long as the font is used.

+
Warning
SFML cannot preload all the font data in this function, so the stream has to remain accessible until the sf::Font object loads a new font or is destroyed.
+
Parameters
+ + +
streamSource stream to read from
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromMemory
+ +
+
+ +

◆ operator=()

+ +
+
+ + + + + + + + +
Font & sf::Font::operator= (const Font & right)
+
+ +

Overload of assignment operator.

+
Parameters
+ + +
rightInstance to assign
+
+
+
Returns
Reference to self
+ +
+
+ +

◆ setSmooth()

+ +
+
+ + + + + + + + +
void sf::Font::setSmooth (bool smooth)
+
+ +

Enable or disable the smooth filter.

+

When the filter is activated, the font appears smoother so that pixels are less noticeable. However if you want the font to look exactly the same as its source file, you should disable it. The smooth filter is enabled by default.

+
Parameters
+ + +
smoothTrue to enable smoothing, false to disable it
+
+
+
See also
isSmooth
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp-members.html new file mode 100644 index 000000000..0e569a590 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp-members.html @@ -0,0 +1,130 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Ftp Member List
+
+
+ +

This is the complete list of members for sf::Ftp, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + +
Ascii enum valuesf::Ftp
Binary enum valuesf::Ftp
changeDirectory(const std::string &directory)sf::Ftp
connect(const IpAddress &server, unsigned short port=21, Time timeout=Time::Zero)sf::Ftp
createDirectory(const std::string &name)sf::Ftp
DataChannel (defined in sf::Ftp)sf::Ftpfriend
deleteDirectory(const std::string &name)sf::Ftp
deleteFile(const std::string &name)sf::Ftp
disconnect()sf::Ftp
download(const std::string &remoteFile, const std::string &localPath, TransferMode mode=Binary)sf::Ftp
Ebcdic enum valuesf::Ftp
getDirectoryListing(const std::string &directory="")sf::Ftp
getWorkingDirectory()sf::Ftp
keepAlive()sf::Ftp
login()sf::Ftp
login(const std::string &name, const std::string &password)sf::Ftp
parentDirectory()sf::Ftp
renameFile(const std::string &file, const std::string &newName)sf::Ftp
sendCommand(const std::string &command, const std::string &parameter="")sf::Ftp
TransferMode enum namesf::Ftp
upload(const std::string &localFile, const std::string &remotePath, TransferMode mode=Binary, bool append=false)sf::Ftp
~Ftp()sf::Ftp
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp.html b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp.html new file mode 100644 index 000000000..139dc94f1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp.html @@ -0,0 +1,865 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +Friends | +List of all members
+
sf::Ftp Class Reference
Network module
+
+
+ +

A FTP client. + More...

+ +

#include <SFML/Network/Ftp.hpp>

+
+Inheritance diagram for sf::Ftp:
+
+
+ + +sf::NonCopyable + +
+ + + + + + + + + + + +

+Classes

class  DirectoryResponse
 Specialization of FTP response returning a directory. More...
 
class  ListingResponse
 Specialization of FTP response returning a filename listing. More...
 
class  Response
 Define a FTP response. More...
 
+ + + + +

+Public Types

enum  TransferMode { Binary +, Ascii +, Ebcdic + }
 Enumeration of transfer modes. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 ~Ftp ()
 Destructor.
 
Response connect (const IpAddress &server, unsigned short port=21, Time timeout=Time::Zero)
 Connect to the specified FTP server.
 
Response disconnect ()
 Close the connection with the server.
 
Response login ()
 Log in using an anonymous account.
 
Response login (const std::string &name, const std::string &password)
 Log in using a username and a password.
 
Response keepAlive ()
 Send a null command to keep the connection alive.
 
DirectoryResponse getWorkingDirectory ()
 Get the current working directory.
 
ListingResponse getDirectoryListing (const std::string &directory="")
 Get the contents of the given directory.
 
Response changeDirectory (const std::string &directory)
 Change the current working directory.
 
Response parentDirectory ()
 Go to the parent directory of the current one.
 
Response createDirectory (const std::string &name)
 Create a new directory.
 
Response deleteDirectory (const std::string &name)
 Remove an existing directory.
 
Response renameFile (const std::string &file, const std::string &newName)
 Rename an existing file.
 
Response deleteFile (const std::string &name)
 Remove an existing file.
 
Response download (const std::string &remoteFile, const std::string &localPath, TransferMode mode=Binary)
 Download a file from the server.
 
Response upload (const std::string &localFile, const std::string &remotePath, TransferMode mode=Binary, bool append=false)
 Upload a file to the server.
 
Response sendCommand (const std::string &command, const std::string &parameter="")
 Send a command to the FTP server.
 
+ + + +

+Friends

class DataChannel
 
+

Detailed Description

+

A FTP client.

+

sf::Ftp is a very simple FTP client that allows you to communicate with a FTP server.

+

The FTP protocol allows you to manipulate a remote file system (list files, upload, download, create, remove, ...).

+

Using the FTP client consists of 4 parts:

    +
  • Connecting to the FTP server
    • +
  • Logging in (either as a registered user or anonymously)
    • +
  • Sending commands to the server
    • +
  • Disconnecting (this part can be done implicitly by the destructor)
    • +
+

Every command returns a FTP response, which contains the status code as well as a message from the server. Some commands such as getWorkingDirectory() and getDirectoryListing() return additional data, and use a class derived from sf::Ftp::Response to provide this data. The most often used commands are directly provided as member functions, but it is also possible to use specific commands with the sendCommand() function.

+

Note that response statuses >= 1000 are not part of the FTP standard, they are generated by SFML when an internal error occurs.

+

All commands, especially upload and download, may take some time to complete. This is important to know if you don't want to block your application while the server is completing the task.

+

Usage example:

// Create a new FTP client
+
sf::Ftp ftp;
+
+
// Connect to the server
+
sf::Ftp::Response response = ftp.connect("ftp://ftp.myserver.com");
+
if (response.isOk())
+
std::cout << "Connected" << std::endl;
+
+
// Log in
+
response = ftp.login("laurent", "dF6Zm89D");
+
if (response.isOk())
+
std::cout << "Logged in" << std::endl;
+
+
// Print the working directory
+
sf::Ftp::DirectoryResponse directory = ftp.getWorkingDirectory();
+
if (directory.isOk())
+
std::cout << "Working directory: " << directory.getDirectory() << std::endl;
+
+
// Create a new directory
+
response = ftp.createDirectory("files");
+
if (response.isOk())
+
std::cout << "Created new directory" << std::endl;
+
+
// Upload a file to this new directory
+
response = ftp.upload("local-path/file.txt", "files", sf::Ftp::Ascii);
+
if (response.isOk())
+
std::cout << "File uploaded" << std::endl;
+
+
// Send specific commands (here: FEAT to list supported FTP features)
+
response = ftp.sendCommand("FEAT");
+
if (response.isOk())
+
std::cout << "Feature list:\n" << response.getMessage() << std::endl;
+
+
// Disconnect from the server (optional)
+
ftp.disconnect();
+
sf::Ftp::DirectoryResponse
Specialization of FTP response returning a directory.
Definition: Ftp.hpp:189
+
sf::Ftp::DirectoryResponse::getDirectory
const std::string & getDirectory() const
Get the directory returned in the response.
+
sf::Ftp::Response
Define a FTP response.
Definition: Ftp.hpp:67
+
sf::Ftp::Response::isOk
bool isOk() const
Check if the status code means a success.
+
sf::Ftp::Response::getMessage
const std::string & getMessage() const
Get the full message contained in the response.
+
sf::Ftp
A FTP client.
Definition: Ftp.hpp:48
+
sf::Ftp::upload
Response upload(const std::string &localFile, const std::string &remotePath, TransferMode mode=Binary, bool append=false)
Upload a file to the server.
+
sf::Ftp::Ascii
@ Ascii
Text mode using ASCII encoding.
Definition: Ftp.hpp:58
+
sf::Ftp::createDirectory
Response createDirectory(const std::string &name)
Create a new directory.
+
sf::Ftp::sendCommand
Response sendCommand(const std::string &command, const std::string &parameter="")
Send a command to the FTP server.
+
sf::Ftp::login
Response login()
Log in using an anonymous account.
+
sf::Ftp::getWorkingDirectory
DirectoryResponse getWorkingDirectory()
Get the current working directory.
+
sf::Ftp::disconnect
Response disconnect()
Close the connection with the server.
+
sf::Ftp::connect
Response connect(const IpAddress &server, unsigned short port=21, Time timeout=Time::Zero)
Connect to the specified FTP server.
+
+

Definition at line 47 of file Ftp.hpp.

+

Member Enumeration Documentation

+ +

◆ TransferMode

+ +
+
+ + + + +
enum sf::Ftp::TransferMode
+
+ +

Enumeration of transfer modes.

+ + + + +
Enumerator
Binary 

Binary mode (file is transfered as a sequence of bytes)

+
Ascii 

Text mode using ASCII encoding.

+
Ebcdic 

Text mode using EBCDIC encoding.

+
+ +

Definition at line 55 of file Ftp.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ ~Ftp()

+ +
+
+ + + + + + + +
sf::Ftp::~Ftp ()
+
+ +

Destructor.

+

Automatically closes the connection with the server if it is still opened.

+ +
+
+

Member Function Documentation

+ +

◆ changeDirectory()

+ +
+
+ + + + + + + + +
Response sf::Ftp::changeDirectory (const std::string & directory)
+
+ +

Change the current working directory.

+

The new directory must be relative to the current one.

+
Parameters
+ + +
directoryNew working directory
+
+
+
Returns
Server response to the request
+
See also
getWorkingDirectory, getDirectoryListing, parentDirectory
+ +
+
+ +

◆ connect()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
Response sf::Ftp::connect (const IpAddress & server,
unsigned short port = 21,
Time timeout = Time::Zero 
)
+
+ +

Connect to the specified FTP server.

+

The port has a default value of 21, which is the standard port used by the FTP protocol. You shouldn't use a different value, unless you really know what you do. This function tries to connect to the server so it may take a while to complete, especially if the server is not reachable. To avoid blocking your application for too long, you can use a timeout. The default value, Time::Zero, means that the system timeout will be used (which is usually pretty long).

+
Parameters
+ + + + +
serverName or address of the FTP server to connect to
portPort used for the connection
timeoutMaximum time to wait
+
+
+
Returns
Server response to the request
+
See also
disconnect
+ +
+
+ +

◆ createDirectory()

+ +
+
+ + + + + + + + +
Response sf::Ftp::createDirectory (const std::string & name)
+
+ +

Create a new directory.

+

The new directory is created as a child of the current working directory.

+
Parameters
+ + +
nameName of the directory to create
+
+
+
Returns
Server response to the request
+
See also
deleteDirectory
+ +
+
+ +

◆ deleteDirectory()

+ +
+
+ + + + + + + + +
Response sf::Ftp::deleteDirectory (const std::string & name)
+
+ +

Remove an existing directory.

+

The directory to remove must be relative to the current working directory. Use this function with caution, the directory will be removed permanently!

+
Parameters
+ + +
nameName of the directory to remove
+
+
+
Returns
Server response to the request
+
See also
createDirectory
+ +
+
+ +

◆ deleteFile()

+ +
+
+ + + + + + + + +
Response sf::Ftp::deleteFile (const std::string & name)
+
+ +

Remove an existing file.

+

The file name must be relative to the current working directory. Use this function with caution, the file will be removed permanently!

+
Parameters
+ + +
nameFile to remove
+
+
+
Returns
Server response to the request
+
See also
renameFile
+ +
+
+ +

◆ disconnect()

+ +
+
+ + + + + + + +
Response sf::Ftp::disconnect ()
+
+ +

Close the connection with the server.

+
Returns
Server response to the request
+
See also
connect
+ +
+
+ +

◆ download()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
Response sf::Ftp::download (const std::string & remoteFile,
const std::string & localPath,
TransferMode mode = Binary 
)
+
+ +

Download a file from the server.

+

The filename of the distant file is relative to the current working directory of the server, and the local destination path is relative to the current directory of your application. If a file with the same filename as the distant file already exists in the local destination path, it will be overwritten.

+
Parameters
+ + + + +
remoteFileFilename of the distant file to download
localPathThe directory in which to put the file on the local computer
modeTransfer mode
+
+
+
Returns
Server response to the request
+
See also
upload
+ +
+
+ +

◆ getDirectoryListing()

+ +
+
+ + + + + + + + +
ListingResponse sf::Ftp::getDirectoryListing (const std::string & directory = "")
+
+ +

Get the contents of the given directory.

+

This function retrieves the sub-directories and files contained in the given directory. It is not recursive. The directory parameter is relative to the current working directory.

+
Parameters
+ + +
directoryDirectory to list
+
+
+
Returns
Server response to the request
+
See also
getWorkingDirectory, changeDirectory, parentDirectory
+ +
+
+ +

◆ getWorkingDirectory()

+ +
+
+ + + + + + + +
DirectoryResponse sf::Ftp::getWorkingDirectory ()
+
+ +

Get the current working directory.

+

The working directory is the root path for subsequent operations involving directories and/or filenames.

+
Returns
Server response to the request
+
See also
getDirectoryListing, changeDirectory, parentDirectory
+ +
+
+ +

◆ keepAlive()

+ +
+
+ + + + + + + +
Response sf::Ftp::keepAlive ()
+
+ +

Send a null command to keep the connection alive.

+

This command is useful because the server may close the connection automatically if no command is sent.

+
Returns
Server response to the request
+ +
+
+ +

◆ login() [1/2]

+ +
+
+ + + + + + + +
Response sf::Ftp::login ()
+
+ +

Log in using an anonymous account.

+

Logging in is mandatory after connecting to the server. Users that are not logged in cannot perform any operation.

+
Returns
Server response to the request
+ +
+
+ +

◆ login() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
Response sf::Ftp::login (const std::string & name,
const std::string & password 
)
+
+ +

Log in using a username and a password.

+

Logging in is mandatory after connecting to the server. Users that are not logged in cannot perform any operation.

+
Parameters
+ + + +
nameUser name
passwordPassword
+
+
+
Returns
Server response to the request
+ +
+
+ +

◆ parentDirectory()

+ +
+
+ + + + + + + +
Response sf::Ftp::parentDirectory ()
+
+ +

Go to the parent directory of the current one.

+
Returns
Server response to the request
+
See also
getWorkingDirectory, getDirectoryListing, changeDirectory
+ +
+
+ +

◆ renameFile()

+ +
+
+ + + + + + + + + + + + + + + + + + +
Response sf::Ftp::renameFile (const std::string & file,
const std::string & newName 
)
+
+ +

Rename an existing file.

+

The filenames must be relative to the current working directory.

+
Parameters
+ + + +
fileFile to rename
newNameNew name of the file
+
+
+
Returns
Server response to the request
+
See also
deleteFile
+ +
+
+ +

◆ sendCommand()

+ +
+
+ + + + + + + + + + + + + + + + + + +
Response sf::Ftp::sendCommand (const std::string & command,
const std::string & parameter = "" 
)
+
+ +

Send a command to the FTP server.

+

While the most often used commands are provided as member functions in the sf::Ftp class, this method can be used to send any FTP command to the server. If the command requires one or more parameters, they can be specified in parameter. If the server returns information, you can extract it from the response using Response::getMessage().

+
Parameters
+ + + +
commandCommand to send
parameterCommand parameter
+
+
+
Returns
Server response to the request
+ +
+
+ +

◆ upload()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Response sf::Ftp::upload (const std::string & localFile,
const std::string & remotePath,
TransferMode mode = Binary,
bool append = false 
)
+
+ +

Upload a file to the server.

+

The name of the local file is relative to the current working directory of your application, and the remote path is relative to the current directory of the FTP server.

+

The append parameter controls whether the remote file is appended to or overwritten if it already exists.

+
Parameters
+ + + + + +
localFilePath of the local file to upload
remotePathThe directory in which to put the file on the server
modeTransfer mode
appendPass true to append to or false to overwrite the remote file if it already exists
+
+
+
Returns
Server response to the request
+
See also
download
+ +
+
+

Friends And Related Function Documentation

+ +

◆ DataChannel

+ +
+
+ + + + + +
+ + + + +
friend class DataChannel
+ 		+friend
+
+ +

Definition at line 531 of file Ftp.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp.png b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp.png new file mode 100644 index 000000000..6aad3083b Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1DirectoryResponse-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1DirectoryResponse-members.html new file mode 100644 index 000000000..c1dd05775 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1DirectoryResponse-members.html @@ -0,0 +1,158 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Ftp::DirectoryResponse Member List
+
+
+ +

This is the complete list of members for sf::Ftp::DirectoryResponse, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
BadCommandSequence enum valuesf::Ftp::Response
ClosingConnection enum valuesf::Ftp::Response
ClosingDataConnection enum valuesf::Ftp::Response
CommandNotImplemented enum valuesf::Ftp::Response
CommandUnknown enum valuesf::Ftp::Response
ConnectionClosed enum valuesf::Ftp::Response
ConnectionFailed enum valuesf::Ftp::Response
DataConnectionAlreadyOpened enum valuesf::Ftp::Response
DataConnectionOpened enum valuesf::Ftp::Response
DataConnectionUnavailable enum valuesf::Ftp::Response
DirectoryOk enum valuesf::Ftp::Response
DirectoryResponse(const Response &response)sf::Ftp::DirectoryResponse
DirectoryStatus enum valuesf::Ftp::Response
EnteringPassiveMode enum valuesf::Ftp::Response
FileActionAborted enum valuesf::Ftp::Response
FileActionOk enum valuesf::Ftp::Response
FilenameNotAllowed enum valuesf::Ftp::Response
FileStatus enum valuesf::Ftp::Response
FileUnavailable enum valuesf::Ftp::Response
getDirectory() constsf::Ftp::DirectoryResponse
getMessage() constsf::Ftp::Response
getStatus() constsf::Ftp::Response
HelpMessage enum valuesf::Ftp::Response
InsufficientStorageSpace enum valuesf::Ftp::Response
InvalidFile enum valuesf::Ftp::Response
InvalidResponse enum valuesf::Ftp::Response
isOk() constsf::Ftp::Response
LocalError enum valuesf::Ftp::Response
LoggedIn enum valuesf::Ftp::Response
NeedAccountToLogIn enum valuesf::Ftp::Response
NeedAccountToStore enum valuesf::Ftp::Response
NeedInformation enum valuesf::Ftp::Response
NeedPassword enum valuesf::Ftp::Response
NotEnoughMemory enum valuesf::Ftp::Response
NotLoggedIn enum valuesf::Ftp::Response
Ok enum valuesf::Ftp::Response
OpeningDataConnection enum valuesf::Ftp::Response
PageTypeUnknown enum valuesf::Ftp::Response
ParameterNotImplemented enum valuesf::Ftp::Response
ParametersUnknown enum valuesf::Ftp::Response
PointlessCommand enum valuesf::Ftp::Response
Response(Status code=InvalidResponse, const std::string &message="")sf::Ftp::Responseexplicit
RestartMarkerReply enum valuesf::Ftp::Response
ServiceReady enum valuesf::Ftp::Response
ServiceReadySoon enum valuesf::Ftp::Response
ServiceUnavailable enum valuesf::Ftp::Response
Status enum namesf::Ftp::Response
SystemStatus enum valuesf::Ftp::Response
SystemType enum valuesf::Ftp::Response
TransferAborted enum valuesf::Ftp::Response
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1DirectoryResponse.html b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1DirectoryResponse.html new file mode 100644 index 000000000..4a8517c0d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1DirectoryResponse.html @@ -0,0 +1,458 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +List of all members
+
sf::Ftp::DirectoryResponse Class Reference
+
+
+ +

Specialization of FTP response returning a directory. + More...

+ +

#include <SFML/Network/Ftp.hpp>

+
+Inheritance diagram for sf::Ftp::DirectoryResponse:
+
+
+ + +sf::Ftp::Response + +
+ + + + + +

+Public Types

enum  Status {
+  RestartMarkerReply = 110 +, ServiceReadySoon = 120 +, DataConnectionAlreadyOpened = 125 +, OpeningDataConnection = 150 +,
+  Ok = 200 +, PointlessCommand = 202 +, SystemStatus = 211 +, DirectoryStatus = 212 +,
+  FileStatus = 213 +, HelpMessage = 214 +, SystemType = 215 +, ServiceReady = 220 +,
+  ClosingConnection = 221 +, DataConnectionOpened = 225 +, ClosingDataConnection = 226 +, EnteringPassiveMode = 227 +,
+  LoggedIn = 230 +, FileActionOk = 250 +, DirectoryOk = 257 +, NeedPassword = 331 +,
+  NeedAccountToLogIn = 332 +, NeedInformation = 350 +, ServiceUnavailable = 421 +, DataConnectionUnavailable = 425 +,
+  TransferAborted = 426 +, FileActionAborted = 450 +, LocalError = 451 +, InsufficientStorageSpace = 452 +,
+  CommandUnknown = 500 +, ParametersUnknown = 501 +, CommandNotImplemented = 502 +, BadCommandSequence = 503 +,
+  ParameterNotImplemented = 504 +, NotLoggedIn = 530 +, NeedAccountToStore = 532 +, FileUnavailable = 550 +,
+  PageTypeUnknown = 551 +, NotEnoughMemory = 552 +, FilenameNotAllowed = 553 +, InvalidResponse = 1000 +,
+  ConnectionFailed = 1001 +, ConnectionClosed = 1002 +, InvalidFile = 1003 +
+ }
 Status codes possibly returned by a FTP response. More...
 
+ + + + + + + + + + + + + + + + +

+Public Member Functions

 DirectoryResponse (const Response &response)
 Default constructor.
 
const std::string & getDirectory () const
 Get the directory returned in the response.
 
bool isOk () const
 Check if the status code means a success.
 
Status getStatus () const
 Get the status code of the response.
 
const std::string & getMessage () const
 Get the full message contained in the response.
 
+

Detailed Description

+

Specialization of FTP response returning a directory.

+ +

Definition at line 188 of file Ftp.hpp.

+

Member Enumeration Documentation

+ +

◆ Status

+ +
+
+ + + + + +
+ + + + +
enum sf::Ftp::Response::Status
+ 		+inherited
+
+ +

Status codes possibly returned by a FTP response.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Enumerator
RestartMarkerReply 

Restart marker reply.

+
ServiceReadySoon 

Service ready in N minutes.

+
DataConnectionAlreadyOpened 

Data connection already opened, transfer starting.

+
OpeningDataConnection 

File status ok, about to open data connection.

+
Ok 

Command ok.

+
PointlessCommand 

Command not implemented.

+
SystemStatus 

System status, or system help reply.

+
DirectoryStatus 

Directory status.

+
FileStatus 

File status.

+
HelpMessage 

Help message.

+
SystemType 

NAME system type, where NAME is an official system name from the list in the Assigned Numbers document.

+
ServiceReady 

Service ready for new user.

+
ClosingConnection 

Service closing control connection.

+
DataConnectionOpened 

Data connection open, no transfer in progress.

+
ClosingDataConnection 

Closing data connection, requested file action successful.

+
EnteringPassiveMode 

Entering passive mode.

+
LoggedIn 

User logged in, proceed. Logged out if appropriate.

+
FileActionOk 

Requested file action ok.

+
DirectoryOk 

PATHNAME created.

+
NeedPassword 

User name ok, need password.

+
NeedAccountToLogIn 

Need account for login.

+
NeedInformation 

Requested file action pending further information.

+
ServiceUnavailable 

Service not available, closing control connection.

+
DataConnectionUnavailable 

Can't open data connection.

+
TransferAborted 

Connection closed, transfer aborted.

+
FileActionAborted 

Requested file action not taken.

+
LocalError 

Requested action aborted, local error in processing.

+
InsufficientStorageSpace 

Requested action not taken; insufficient storage space in system, file unavailable.

+
CommandUnknown 

Syntax error, command unrecognized.

+
ParametersUnknown 

Syntax error in parameters or arguments.

+
CommandNotImplemented 

Command not implemented.

+
BadCommandSequence 

Bad sequence of commands.

+
ParameterNotImplemented 

Command not implemented for that parameter.

+
NotLoggedIn 

Not logged in.

+
NeedAccountToStore 

Need account for storing files.

+
FileUnavailable 

Requested action not taken, file unavailable.

+
PageTypeUnknown 

Requested action aborted, page type unknown.

+
NotEnoughMemory 

Requested file action aborted, exceeded storage allocation.

+
FilenameNotAllowed 

Requested action not taken, file name not allowed.

+
InvalidResponse 

Not part of the FTP standard, generated by SFML when a received response cannot be parsed.

+
ConnectionFailed 

Not part of the FTP standard, generated by SFML when the low-level socket connection with the server fails.

+
ConnectionClosed 

Not part of the FTP standard, generated by SFML when the low-level socket connection is unexpectedly closed.

+
InvalidFile 

Not part of the FTP standard, generated by SFML when a local file cannot be read or written.

+
+ +

Definition at line 74 of file Ftp.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ DirectoryResponse()

+ +
+
+ + + + + + + + +
sf::Ftp::DirectoryResponse::DirectoryResponse (const Response & response)
+
+ +

Default constructor.

+
Parameters
+ + +
responseSource response
+
+
+ +
+
+

Member Function Documentation

+ +

◆ getDirectory()

+ +
+
+ + + + + + + +
const std::string & sf::Ftp::DirectoryResponse::getDirectory () const
+
+ +

Get the directory returned in the response.

+
Returns
Directory name
+ +
+
+ +

◆ getMessage()

+ +
+
+ + + + + +
+ + + + + + + +
const std::string & sf::Ftp::Response::getMessage () const
+ 		+inherited
+
+ +

Get the full message contained in the response.

+
Returns
The response message
+ +
+
+ +

◆ getStatus()

+ +
+
+ + + + + +
+ + + + + + + +
Status sf::Ftp::Response::getStatus () const
+ 		+inherited
+
+ +

Get the status code of the response.

+
Returns
Status code
+ +
+
+ +

◆ isOk()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::Ftp::Response::isOk () const
+ 		+inherited
+
+ +

Check if the status code means a success.

+

This function is defined for convenience, it is equivalent to testing if the status code is < 400.

+
Returns
True if the status is a success, false if it is a failure
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1DirectoryResponse.png b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1DirectoryResponse.png new file mode 100644 index 000000000..27159a44d Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1DirectoryResponse.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1ListingResponse-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1ListingResponse-members.html new file mode 100644 index 000000000..41e42c0ba --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1ListingResponse-members.html @@ -0,0 +1,158 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Ftp::ListingResponse Member List
+
+
+ +

This is the complete list of members for sf::Ftp::ListingResponse, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
BadCommandSequence enum valuesf::Ftp::Response
ClosingConnection enum valuesf::Ftp::Response
ClosingDataConnection enum valuesf::Ftp::Response
CommandNotImplemented enum valuesf::Ftp::Response
CommandUnknown enum valuesf::Ftp::Response
ConnectionClosed enum valuesf::Ftp::Response
ConnectionFailed enum valuesf::Ftp::Response
DataConnectionAlreadyOpened enum valuesf::Ftp::Response
DataConnectionOpened enum valuesf::Ftp::Response
DataConnectionUnavailable enum valuesf::Ftp::Response
DirectoryOk enum valuesf::Ftp::Response
DirectoryStatus enum valuesf::Ftp::Response
EnteringPassiveMode enum valuesf::Ftp::Response
FileActionAborted enum valuesf::Ftp::Response
FileActionOk enum valuesf::Ftp::Response
FilenameNotAllowed enum valuesf::Ftp::Response
FileStatus enum valuesf::Ftp::Response
FileUnavailable enum valuesf::Ftp::Response
getListing() constsf::Ftp::ListingResponse
getMessage() constsf::Ftp::Response
getStatus() constsf::Ftp::Response
HelpMessage enum valuesf::Ftp::Response
InsufficientStorageSpace enum valuesf::Ftp::Response
InvalidFile enum valuesf::Ftp::Response
InvalidResponse enum valuesf::Ftp::Response
isOk() constsf::Ftp::Response
ListingResponse(const Response &response, const std::string &data)sf::Ftp::ListingResponse
LocalError enum valuesf::Ftp::Response
LoggedIn enum valuesf::Ftp::Response
NeedAccountToLogIn enum valuesf::Ftp::Response
NeedAccountToStore enum valuesf::Ftp::Response
NeedInformation enum valuesf::Ftp::Response
NeedPassword enum valuesf::Ftp::Response
NotEnoughMemory enum valuesf::Ftp::Response
NotLoggedIn enum valuesf::Ftp::Response
Ok enum valuesf::Ftp::Response
OpeningDataConnection enum valuesf::Ftp::Response
PageTypeUnknown enum valuesf::Ftp::Response
ParameterNotImplemented enum valuesf::Ftp::Response
ParametersUnknown enum valuesf::Ftp::Response
PointlessCommand enum valuesf::Ftp::Response
Response(Status code=InvalidResponse, const std::string &message="")sf::Ftp::Responseexplicit
RestartMarkerReply enum valuesf::Ftp::Response
ServiceReady enum valuesf::Ftp::Response
ServiceReadySoon enum valuesf::Ftp::Response
ServiceUnavailable enum valuesf::Ftp::Response
Status enum namesf::Ftp::Response
SystemStatus enum valuesf::Ftp::Response
SystemType enum valuesf::Ftp::Response
TransferAborted enum valuesf::Ftp::Response
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1ListingResponse.html b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1ListingResponse.html new file mode 100644 index 000000000..b2b1bb6d3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1ListingResponse.html @@ -0,0 +1,469 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +List of all members
+
sf::Ftp::ListingResponse Class Reference
+
+
+ +

Specialization of FTP response returning a filename listing. + More...

+ +

#include <SFML/Network/Ftp.hpp>

+
+Inheritance diagram for sf::Ftp::ListingResponse:
+
+
+ + +sf::Ftp::Response + +
+ + + + + +

+Public Types

enum  Status {
+  RestartMarkerReply = 110 +, ServiceReadySoon = 120 +, DataConnectionAlreadyOpened = 125 +, OpeningDataConnection = 150 +,
+  Ok = 200 +, PointlessCommand = 202 +, SystemStatus = 211 +, DirectoryStatus = 212 +,
+  FileStatus = 213 +, HelpMessage = 214 +, SystemType = 215 +, ServiceReady = 220 +,
+  ClosingConnection = 221 +, DataConnectionOpened = 225 +, ClosingDataConnection = 226 +, EnteringPassiveMode = 227 +,
+  LoggedIn = 230 +, FileActionOk = 250 +, DirectoryOk = 257 +, NeedPassword = 331 +,
+  NeedAccountToLogIn = 332 +, NeedInformation = 350 +, ServiceUnavailable = 421 +, DataConnectionUnavailable = 425 +,
+  TransferAborted = 426 +, FileActionAborted = 450 +, LocalError = 451 +, InsufficientStorageSpace = 452 +,
+  CommandUnknown = 500 +, ParametersUnknown = 501 +, CommandNotImplemented = 502 +, BadCommandSequence = 503 +,
+  ParameterNotImplemented = 504 +, NotLoggedIn = 530 +, NeedAccountToStore = 532 +, FileUnavailable = 550 +,
+  PageTypeUnknown = 551 +, NotEnoughMemory = 552 +, FilenameNotAllowed = 553 +, InvalidResponse = 1000 +,
+  ConnectionFailed = 1001 +, ConnectionClosed = 1002 +, InvalidFile = 1003 +
+ }
 Status codes possibly returned by a FTP response. More...
 
+ + + + + + + + + + + + + + + + +

+Public Member Functions

 ListingResponse (const Response &response, const std::string &data)
 Default constructor.
 
const std::vector< std::string > & getListing () const
 Return the array of directory/file names.
 
bool isOk () const
 Check if the status code means a success.
 
Status getStatus () const
 Get the status code of the response.
 
const std::string & getMessage () const
 Get the full message contained in the response.
 
+

Detailed Description

+

Specialization of FTP response returning a filename listing.

+ +

Definition at line 221 of file Ftp.hpp.

+

Member Enumeration Documentation

+ +

◆ Status

+ +
+
+ + + + + +
+ + + + +
enum sf::Ftp::Response::Status
+ 		+inherited
+
+ +

Status codes possibly returned by a FTP response.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Enumerator
RestartMarkerReply 

Restart marker reply.

+
ServiceReadySoon 

Service ready in N minutes.

+
DataConnectionAlreadyOpened 

Data connection already opened, transfer starting.

+
OpeningDataConnection 

File status ok, about to open data connection.

+
Ok 

Command ok.

+
PointlessCommand 

Command not implemented.

+
SystemStatus 

System status, or system help reply.

+
DirectoryStatus 

Directory status.

+
FileStatus 

File status.

+
HelpMessage 

Help message.

+
SystemType 

NAME system type, where NAME is an official system name from the list in the Assigned Numbers document.

+
ServiceReady 

Service ready for new user.

+
ClosingConnection 

Service closing control connection.

+
DataConnectionOpened 

Data connection open, no transfer in progress.

+
ClosingDataConnection 

Closing data connection, requested file action successful.

+
EnteringPassiveMode 

Entering passive mode.

+
LoggedIn 

User logged in, proceed. Logged out if appropriate.

+
FileActionOk 

Requested file action ok.

+
DirectoryOk 

PATHNAME created.

+
NeedPassword 

User name ok, need password.

+
NeedAccountToLogIn 

Need account for login.

+
NeedInformation 

Requested file action pending further information.

+
ServiceUnavailable 

Service not available, closing control connection.

+
DataConnectionUnavailable 

Can't open data connection.

+
TransferAborted 

Connection closed, transfer aborted.

+
FileActionAborted 

Requested file action not taken.

+
LocalError 

Requested action aborted, local error in processing.

+
InsufficientStorageSpace 

Requested action not taken; insufficient storage space in system, file unavailable.

+
CommandUnknown 

Syntax error, command unrecognized.

+
ParametersUnknown 

Syntax error in parameters or arguments.

+
CommandNotImplemented 

Command not implemented.

+
BadCommandSequence 

Bad sequence of commands.

+
ParameterNotImplemented 

Command not implemented for that parameter.

+
NotLoggedIn 

Not logged in.

+
NeedAccountToStore 

Need account for storing files.

+
FileUnavailable 

Requested action not taken, file unavailable.

+
PageTypeUnknown 

Requested action aborted, page type unknown.

+
NotEnoughMemory 

Requested file action aborted, exceeded storage allocation.

+
FilenameNotAllowed 

Requested action not taken, file name not allowed.

+
InvalidResponse 

Not part of the FTP standard, generated by SFML when a received response cannot be parsed.

+
ConnectionFailed 

Not part of the FTP standard, generated by SFML when the low-level socket connection with the server fails.

+
ConnectionClosed 

Not part of the FTP standard, generated by SFML when the low-level socket connection is unexpectedly closed.

+
InvalidFile 

Not part of the FTP standard, generated by SFML when a local file cannot be read or written.

+
+ +

Definition at line 74 of file Ftp.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ ListingResponse()

+ +
+
+ + + + + + + + + + + + + + + + + + +
sf::Ftp::ListingResponse::ListingResponse (const Response & response,
const std::string & data 
)
+
+ +

Default constructor.

+
Parameters
+ + + +
responseSource response
dataData containing the raw listing
+
+
+ +
+
+

Member Function Documentation

+ +

◆ getListing()

+ +
+
+ + + + + + + +
const std::vector< std::string > & sf::Ftp::ListingResponse::getListing () const
+
+ +

Return the array of directory/file names.

+
Returns
Array containing the requested listing
+ +
+
+ +

◆ getMessage()

+ +
+
+ + + + + +
+ + + + + + + +
const std::string & sf::Ftp::Response::getMessage () const
+ 		+inherited
+
+ +

Get the full message contained in the response.

+
Returns
The response message
+ +
+
+ +

◆ getStatus()

+ +
+
+ + + + + +
+ + + + + + + +
Status sf::Ftp::Response::getStatus () const
+ 		+inherited
+
+ +

Get the status code of the response.

+
Returns
Status code
+ +
+
+ +

◆ isOk()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::Ftp::Response::isOk () const
+ 		+inherited
+
+ +

Check if the status code means a success.

+

This function is defined for convenience, it is equivalent to testing if the status code is < 400.

+
Returns
True if the status is a success, false if it is a failure
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1ListingResponse.png b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1ListingResponse.png new file mode 100644 index 000000000..2465a5b20 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1ListingResponse.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1Response-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1Response-members.html new file mode 100644 index 000000000..734bf3fe1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1Response-members.html @@ -0,0 +1,156 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Ftp::Response Member List
+
+
+ +

This is the complete list of members for sf::Ftp::Response, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
BadCommandSequence enum valuesf::Ftp::Response
ClosingConnection enum valuesf::Ftp::Response
ClosingDataConnection enum valuesf::Ftp::Response
CommandNotImplemented enum valuesf::Ftp::Response
CommandUnknown enum valuesf::Ftp::Response
ConnectionClosed enum valuesf::Ftp::Response
ConnectionFailed enum valuesf::Ftp::Response
DataConnectionAlreadyOpened enum valuesf::Ftp::Response
DataConnectionOpened enum valuesf::Ftp::Response
DataConnectionUnavailable enum valuesf::Ftp::Response
DirectoryOk enum valuesf::Ftp::Response
DirectoryStatus enum valuesf::Ftp::Response
EnteringPassiveMode enum valuesf::Ftp::Response
FileActionAborted enum valuesf::Ftp::Response
FileActionOk enum valuesf::Ftp::Response
FilenameNotAllowed enum valuesf::Ftp::Response
FileStatus enum valuesf::Ftp::Response
FileUnavailable enum valuesf::Ftp::Response
getMessage() constsf::Ftp::Response
getStatus() constsf::Ftp::Response
HelpMessage enum valuesf::Ftp::Response
InsufficientStorageSpace enum valuesf::Ftp::Response
InvalidFile enum valuesf::Ftp::Response
InvalidResponse enum valuesf::Ftp::Response
isOk() constsf::Ftp::Response
LocalError enum valuesf::Ftp::Response
LoggedIn enum valuesf::Ftp::Response
NeedAccountToLogIn enum valuesf::Ftp::Response
NeedAccountToStore enum valuesf::Ftp::Response
NeedInformation enum valuesf::Ftp::Response
NeedPassword enum valuesf::Ftp::Response
NotEnoughMemory enum valuesf::Ftp::Response
NotLoggedIn enum valuesf::Ftp::Response
Ok enum valuesf::Ftp::Response
OpeningDataConnection enum valuesf::Ftp::Response
PageTypeUnknown enum valuesf::Ftp::Response
ParameterNotImplemented enum valuesf::Ftp::Response
ParametersUnknown enum valuesf::Ftp::Response
PointlessCommand enum valuesf::Ftp::Response
Response(Status code=InvalidResponse, const std::string &message="")sf::Ftp::Responseexplicit
RestartMarkerReply enum valuesf::Ftp::Response
ServiceReady enum valuesf::Ftp::Response
ServiceReadySoon enum valuesf::Ftp::Response
ServiceUnavailable enum valuesf::Ftp::Response
Status enum namesf::Ftp::Response
SystemStatus enum valuesf::Ftp::Response
SystemType enum valuesf::Ftp::Response
TransferAborted enum valuesf::Ftp::Response
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1Response.html b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1Response.html new file mode 100644 index 000000000..094ad152c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1Response.html @@ -0,0 +1,424 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +List of all members
+
sf::Ftp::Response Class Reference
+
+
+ +

Define a FTP response. + More...

+ +

#include <SFML/Network/Ftp.hpp>

+
+Inheritance diagram for sf::Ftp::Response:
+
+
+ + +sf::Ftp::DirectoryResponse +sf::Ftp::ListingResponse + +
+ + + + + +

+Public Types

enum  Status {
+  RestartMarkerReply = 110 +, ServiceReadySoon = 120 +, DataConnectionAlreadyOpened = 125 +, OpeningDataConnection = 150 +,
+  Ok = 200 +, PointlessCommand = 202 +, SystemStatus = 211 +, DirectoryStatus = 212 +,
+  FileStatus = 213 +, HelpMessage = 214 +, SystemType = 215 +, ServiceReady = 220 +,
+  ClosingConnection = 221 +, DataConnectionOpened = 225 +, ClosingDataConnection = 226 +, EnteringPassiveMode = 227 +,
+  LoggedIn = 230 +, FileActionOk = 250 +, DirectoryOk = 257 +, NeedPassword = 331 +,
+  NeedAccountToLogIn = 332 +, NeedInformation = 350 +, ServiceUnavailable = 421 +, DataConnectionUnavailable = 425 +,
+  TransferAborted = 426 +, FileActionAborted = 450 +, LocalError = 451 +, InsufficientStorageSpace = 452 +,
+  CommandUnknown = 500 +, ParametersUnknown = 501 +, CommandNotImplemented = 502 +, BadCommandSequence = 503 +,
+  ParameterNotImplemented = 504 +, NotLoggedIn = 530 +, NeedAccountToStore = 532 +, FileUnavailable = 550 +,
+  PageTypeUnknown = 551 +, NotEnoughMemory = 552 +, FilenameNotAllowed = 553 +, InvalidResponse = 1000 +,
+  ConnectionFailed = 1001 +, ConnectionClosed = 1002 +, InvalidFile = 1003 +
+ }
 Status codes possibly returned by a FTP response. More...
 
+ + + + + + + + + + + + + +

+Public Member Functions

 Response (Status code=InvalidResponse, const std::string &message="")
 Default constructor.
 
bool isOk () const
 Check if the status code means a success.
 
Status getStatus () const
 Get the status code of the response.
 
const std::string & getMessage () const
 Get the full message contained in the response.
 
+

Detailed Description

+

Define a FTP response.

+ +

Definition at line 66 of file Ftp.hpp.

+

Member Enumeration Documentation

+ +

◆ Status

+ +
+
+ + + + +
enum sf::Ftp::Response::Status
+
+ +

Status codes possibly returned by a FTP response.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Enumerator
RestartMarkerReply 

Restart marker reply.

+
ServiceReadySoon 

Service ready in N minutes.

+
DataConnectionAlreadyOpened 

Data connection already opened, transfer starting.

+
OpeningDataConnection 

File status ok, about to open data connection.

+
Ok 

Command ok.

+
PointlessCommand 

Command not implemented.

+
SystemStatus 

System status, or system help reply.

+
DirectoryStatus 

Directory status.

+
FileStatus 

File status.

+
HelpMessage 

Help message.

+
SystemType 

NAME system type, where NAME is an official system name from the list in the Assigned Numbers document.

+
ServiceReady 

Service ready for new user.

+
ClosingConnection 

Service closing control connection.

+
DataConnectionOpened 

Data connection open, no transfer in progress.

+
ClosingDataConnection 

Closing data connection, requested file action successful.

+
EnteringPassiveMode 

Entering passive mode.

+
LoggedIn 

User logged in, proceed. Logged out if appropriate.

+
FileActionOk 

Requested file action ok.

+
DirectoryOk 

PATHNAME created.

+
NeedPassword 

User name ok, need password.

+
NeedAccountToLogIn 

Need account for login.

+
NeedInformation 

Requested file action pending further information.

+
ServiceUnavailable 

Service not available, closing control connection.

+
DataConnectionUnavailable 

Can't open data connection.

+
TransferAborted 

Connection closed, transfer aborted.

+
FileActionAborted 

Requested file action not taken.

+
LocalError 

Requested action aborted, local error in processing.

+
InsufficientStorageSpace 

Requested action not taken; insufficient storage space in system, file unavailable.

+
CommandUnknown 

Syntax error, command unrecognized.

+
ParametersUnknown 

Syntax error in parameters or arguments.

+
CommandNotImplemented 

Command not implemented.

+
BadCommandSequence 

Bad sequence of commands.

+
ParameterNotImplemented 

Command not implemented for that parameter.

+
NotLoggedIn 

Not logged in.

+
NeedAccountToStore 

Need account for storing files.

+
FileUnavailable 

Requested action not taken, file unavailable.

+
PageTypeUnknown 

Requested action aborted, page type unknown.

+
NotEnoughMemory 

Requested file action aborted, exceeded storage allocation.

+
FilenameNotAllowed 

Requested action not taken, file name not allowed.

+
InvalidResponse 

Not part of the FTP standard, generated by SFML when a received response cannot be parsed.

+
ConnectionFailed 

Not part of the FTP standard, generated by SFML when the low-level socket connection with the server fails.

+
ConnectionClosed 

Not part of the FTP standard, generated by SFML when the low-level socket connection is unexpectedly closed.

+
InvalidFile 

Not part of the FTP standard, generated by SFML when a local file cannot be read or written.

+
+ +

Definition at line 74 of file Ftp.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Response()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
sf::Ftp::Response::Response (Status code = InvalidResponse,
const std::string & message = "" 
)
+ 		+explicit
+
+ +

Default constructor.

+

This constructor is used by the FTP client to build the response.

+
Parameters
+ + + +
codeResponse status code
messageResponse message
+
+
+ +
+
+

Member Function Documentation

+ +

◆ getMessage()

+ +
+
+ + + + + + + +
const std::string & sf::Ftp::Response::getMessage () const
+
+ +

Get the full message contained in the response.

+
Returns
The response message
+ +
+
+ +

◆ getStatus()

+ +
+
+ + + + + + + +
Status sf::Ftp::Response::getStatus () const
+
+ +

Get the status code of the response.

+
Returns
Status code
+ +
+
+ +

◆ isOk()

+ +
+
+ + + + + + + +
bool sf::Ftp::Response::isOk () const
+
+ +

Check if the status code means a success.

+

This function is defined for convenience, it is equivalent to testing if the status code is < 400.

+
Returns
True if the status is a success, false if it is a failure
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1Response.png b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1Response.png new file mode 100644 index 000000000..a86704643 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Ftp_1_1Response.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1GlResource-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource-members.html new file mode 100644 index 000000000..7dc346228 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::GlResource Member List
+
+
+ +

This is the complete list of members for sf::GlResource, including all inherited members.

+ + + + +
GlResource()sf::GlResourceprotected
registerContextDestroyCallback(ContextDestroyCallback callback, void *arg)sf::GlResourceprotectedstatic
~GlResource()sf::GlResourceprotected
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1GlResource.html b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource.html new file mode 100644 index 000000000..18a027431 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource.html @@ -0,0 +1,261 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Protected Member Functions | +Static Protected Member Functions | +List of all members
+
sf::GlResource Class Reference
Window module
+
+
+ +

Base class for classes that require an OpenGL context. + More...

+ +

#include <SFML/Window/GlResource.hpp>

+
+Inheritance diagram for sf::GlResource:
+
+
+ + +sf::Context +sf::Shader +sf::Texture +sf::VertexBuffer +sf::Window +sf::RenderWindow + +
+ + + + + +

+Classes

class  TransientContextLock
 RAII helper class to temporarily lock an available context for use. More...
 
+ + + + + + + +

+Protected Member Functions

 GlResource ()
 Default constructor.
 
 ~GlResource ()
 Destructor.
 
+ + + + +

+Static Protected Member Functions

static void registerContextDestroyCallback (ContextDestroyCallback callback, void *arg)
 Register a function to be called when a context is destroyed.
 
+

Detailed Description

+

Base class for classes that require an OpenGL context.

+

This class is for internal use only, it must be the base of every class that requires a valid OpenGL context in order to work.

+ +

Definition at line 46 of file GlResource.hpp.

+

Constructor & Destructor Documentation

+ +

◆ GlResource()

+ +
+
+ + + + + +
+ + + + + + + +
sf::GlResource::GlResource ()
+ 		+protected
+
+ +

Default constructor.

+ +
+
+ +

◆ ~GlResource()

+ +
+
+ + + + + +
+ + + + + + + +
sf::GlResource::~GlResource ()
+ 		+protected
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ registerContextDestroyCallback()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void sf::GlResource::registerContextDestroyCallback (ContextDestroyCallback callback,
void * arg 
)
+ 		+staticprotected
+
+ +

Register a function to be called when a context is destroyed.

+

This is used for internal purposes in order to properly clean up OpenGL resources that cannot be shared between contexts.

+
Parameters
+ + + +
callbackFunction to be called when a context is destroyed
argArgument to pass when calling the function
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1GlResource.png b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource.png new file mode 100644 index 000000000..d034c344b Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1GlResource_1_1TransientContextLock-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource_1_1TransientContextLock-members.html new file mode 100644 index 000000000..b47611e10 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource_1_1TransientContextLock-members.html @@ -0,0 +1,110 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::GlResource::TransientContextLock Member List
+
+
+ +

This is the complete list of members for sf::GlResource::TransientContextLock, including all inherited members.

+ + + +
TransientContextLock()sf::GlResource::TransientContextLock
~TransientContextLock()sf::GlResource::TransientContextLock
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1GlResource_1_1TransientContextLock.html b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource_1_1TransientContextLock.html new file mode 100644 index 000000000..6c7dfdad7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource_1_1TransientContextLock.html @@ -0,0 +1,178 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::GlResource::TransientContextLock Class Reference
+
+
+ +

RAII helper class to temporarily lock an available context for use. + More...

+ +

#include <SFML/Window/GlResource.hpp>

+
+Inheritance diagram for sf::GlResource::TransientContextLock:
+
+
+ + +sf::NonCopyable + +
+ + + + + + + + +

+Public Member Functions

 TransientContextLock ()
 Default constructor.
 
 ~TransientContextLock ()
 Destructor.
 
+

Detailed Description

+

RAII helper class to temporarily lock an available context for use.

+ +

Definition at line 79 of file GlResource.hpp.

+

Constructor & Destructor Documentation

+ +

◆ TransientContextLock()

+ +
+
+ + + + + + + +
sf::GlResource::TransientContextLock::TransientContextLock ()
+
+ +

Default constructor.

+ +
+
+ +

◆ ~TransientContextLock()

+ +
+
+ + + + + + + +
sf::GlResource::TransientContextLock::~TransientContextLock ()
+
+ +

Destructor.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1GlResource_1_1TransientContextLock.png b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource_1_1TransientContextLock.png new file mode 100644 index 000000000..939f317c9 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1GlResource_1_1TransientContextLock.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Glyph-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Glyph-members.html new file mode 100644 index 000000000..0ebf88dd1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Glyph-members.html @@ -0,0 +1,114 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Glyph Member List
+
+
+ +

This is the complete list of members for sf::Glyph, including all inherited members.

+ + + + + + + +
advancesf::Glyph
boundssf::Glyph
Glyph()sf::Glyphinline
lsbDeltasf::Glyph
rsbDeltasf::Glyph
textureRectsf::Glyph
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Glyph.html b/Space-Invaders/sfml/doc/html/classsf_1_1Glyph.html new file mode 100644 index 000000000..b37e89830 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Glyph.html @@ -0,0 +1,274 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Public Attributes | +List of all members
+
sf::Glyph Class Reference
Graphics module
+
+
+ +

Structure describing a glyph. + More...

+ +

#include <SFML/Graphics/Glyph.hpp>

+ + + + + +

+Public Member Functions

 Glyph ()
 Default constructor.
 
+ + + + + + + + + + + + + + + + +

+Public Attributes

float advance
 Offset to move horizontally to the next character.
 
int lsbDelta
 Left offset after forced autohint. Internally used by getKerning()
 
int rsbDelta
 Right offset after forced autohint. Internally used by getKerning()
 
FloatRect bounds
 Bounding rectangle of the glyph, in coordinates relative to the baseline.
 
IntRect textureRect
 Texture coordinates of the glyph inside the font's texture.
 
+

Detailed Description

+

Structure describing a glyph.

+

A glyph is the visual representation of a character.

+

The sf::Glyph structure provides the information needed to handle the glyph:

    +
  • its coordinates in the font's texture
    • +
  • its bounding rectangle
    • +
  • the offset to apply to get the starting position of the next glyph
    • +
+
See also
sf::Font
+ +

Definition at line 41 of file Glyph.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Glyph()

+ +
+
+ + + + + +
+ + + + + + + +
sf::Glyph::Glyph ()
+ 		+inline
+
+ +

Default constructor.

+ +

Definition at line 49 of file Glyph.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ advance

+ +
+
+ + + + +
float sf::Glyph::advance
+
+ +

Offset to move horizontally to the next character.

+ +

Definition at line 54 of file Glyph.hpp.

+ +
+
+ +

◆ bounds

+ +
+
+ + + + +
FloatRect sf::Glyph::bounds
+
+ +

Bounding rectangle of the glyph, in coordinates relative to the baseline.

+ +

Definition at line 57 of file Glyph.hpp.

+ +
+
+ +

◆ lsbDelta

+ +
+
+ + + + +
int sf::Glyph::lsbDelta
+
+ +

Left offset after forced autohint. Internally used by getKerning()

+ +

Definition at line 55 of file Glyph.hpp.

+ +
+
+ +

◆ rsbDelta

+ +
+
+ + + + +
int sf::Glyph::rsbDelta
+
+ +

Right offset after forced autohint. Internally used by getKerning()

+ +

Definition at line 56 of file Glyph.hpp.

+ +
+
+ +

◆ textureRect

+ +
+
+ + + + +
IntRect sf::Glyph::textureRect
+
+ +

Texture coordinates of the glyph inside the font's texture.

+ +

Definition at line 58 of file Glyph.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Http-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Http-members.html new file mode 100644 index 000000000..2aca1b1ac --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Http-members.html @@ -0,0 +1,112 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Http Member List
+
+
+ +

This is the complete list of members for sf::Http, including all inherited members.

+ + + + + +
Http()sf::Http
Http(const std::string &host, unsigned short port=0)sf::Http
sendRequest(const Request &request, Time timeout=Time::Zero)sf::Http
setHost(const std::string &host, unsigned short port=0)sf::Http
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Http.html b/Space-Invaders/sfml/doc/html/classsf_1_1Http.html new file mode 100644 index 000000000..911b360f7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Http.html @@ -0,0 +1,341 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Member Functions | +List of all members
+
sf::Http Class Reference
Network module
+
+
+ +

A HTTP client. + More...

+ +

#include <SFML/Network/Http.hpp>

+
+Inheritance diagram for sf::Http:
+
+
+ + +sf::NonCopyable + +
+ + + + + + + + +

+Classes

class  Request
 Define a HTTP request. More...
 
class  Response
 Define a HTTP response. More...
 
+ + + + + + + + + + + + + +

+Public Member Functions

 Http ()
 Default constructor.
 
 Http (const std::string &host, unsigned short port=0)
 Construct the HTTP client with the target host.
 
void setHost (const std::string &host, unsigned short port=0)
 Set the target host.
 
Response sendRequest (const Request &request, Time timeout=Time::Zero)
 Send a HTTP request and return the server's response.
 
+

Detailed Description

+

A HTTP client.

+

sf::Http is a very simple HTTP client that allows you to communicate with a web server.

+

You can retrieve web pages, send data to an interactive resource, download a remote file, etc. The HTTPS protocol is not supported.

+

The HTTP client is split into 3 classes:

+

sf::Http::Request builds the request that will be sent to the server. A request is made of:

    +
  • a method (what you want to do)
    • +
  • a target URI (usually the name of the web page or file)
    • +
  • one or more header fields (options that you can pass to the server)
    • +
  • an optional body (for POST requests)
    • +
+

sf::Http::Response parse the response from the web server and provides getters to read them. The response contains:

    +
  • a status code
    • +
  • header fields (that may be answers to the ones that you requested)
    • +
  • a body, which contains the contents of the requested resource
    • +
+

sf::Http provides a simple function, SendRequest, to send a sf::Http::Request and return the corresponding sf::Http::Response from the server.

+

Usage example:

// Create a new HTTP client
+
sf::Http http;
+
+
// We'll work on http://www.sfml-dev.org
+
http.setHost("http://www.sfml-dev.org");
+
+
// Prepare a request to get the 'features.php' page
+
sf::Http::Request request("features.php");
+
+
// Send the request
+
sf::Http::Response response = http.sendRequest(request);
+
+
// Check the status code and display the result
+
sf::Http::Response::Status status = response.getStatus();
+
if (status == sf::Http::Response::Ok)
+
{
+
std::cout << response.getBody() << std::endl;
+
}
+
else
+
{
+
std::cout << "Error " << status << std::endl;
+
}
+
sf::Http::Request
Define a HTTP request.
Definition: Http.hpp:55
+
sf::Http::Response
Define a HTTP response.
Definition: Http.hpp:194
+
sf::Http::Response::getStatus
Status getStatus() const
Get the response status code.
+
sf::Http::Response::Status
Status
Enumerate all the valid status codes for a response.
Definition: Http.hpp:202
+
sf::Http::Response::Ok
@ Ok
Most common code returned when operation was successful.
Definition: Http.hpp:204
+
sf::Http::Response::getBody
const std::string & getBody() const
Get the body of the response.
+
sf::Http
A HTTP client.
Definition: Http.hpp:47
+
sf::Http::setHost
void setHost(const std::string &host, unsigned short port=0)
Set the target host.
+
sf::Http::sendRequest
Response sendRequest(const Request &request, Time timeout=Time::Zero)
Send a HTTP request and return the server's response.
+
+

Definition at line 46 of file Http.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Http() [1/2]

+ +
+
+ + + + + + + +
sf::Http::Http ()
+
+ +

Default constructor.

+ +
+
+ +

◆ Http() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
sf::Http::Http (const std::string & host,
unsigned short port = 0 
)
+
+ +

Construct the HTTP client with the target host.

+

This is equivalent to calling setHost(host, port). The port has a default value of 0, which means that the HTTP client will use the right port according to the protocol used (80 for HTTP). You should leave it like this unless you really need a port other than the standard one, or use an unknown protocol.

+
Parameters
+ + + +
hostWeb server to connect to
portPort to use for connection
+
+
+ +
+
+

Member Function Documentation

+ +

◆ sendRequest()

+ +
+
+ + + + + + + + + + + + + + + + + + +
Response sf::Http::sendRequest (const Request & request,
Time timeout = Time::Zero 
)
+
+ +

Send a HTTP request and return the server's response.

+

You must have a valid host before sending a request (see setHost). Any missing mandatory header field in the request will be added with an appropriate value. Warning: this function waits for the server's response and may not return instantly; use a thread if you don't want to block your application, or use a timeout to limit the time to wait. A value of Time::Zero means that the client will use the system default timeout (which is usually pretty long).

+
Parameters
+ + + +
requestRequest to send
timeoutMaximum time to wait
+
+
+
Returns
Server's response
+ +
+
+ +

◆ setHost()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Http::setHost (const std::string & host,
unsigned short port = 0 
)
+
+ +

Set the target host.

+

This function just stores the host address and port, it doesn't actually connect to it until you send a request. The port has a default value of 0, which means that the HTTP client will use the right port according to the protocol used (80 for HTTP). You should leave it like this unless you really need a port other than the standard one, or use an unknown protocol.

+
Parameters
+ + + +
hostWeb server to connect to
portPort to use for connection
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Http.png b/Space-Invaders/sfml/doc/html/classsf_1_1Http.png new file mode 100644 index 000000000..565107c5a Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Http.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Request-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Request-members.html new file mode 100644 index 000000000..f1425b43c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Request-members.html @@ -0,0 +1,121 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Http::Request Member List
+
+
+ +

This is the complete list of members for sf::Http::Request, including all inherited members.

+ + + + + + + + + + + + + + +
Delete enum valuesf::Http::Request
Get enum valuesf::Http::Request
Head enum valuesf::Http::Request
Http (defined in sf::Http::Request)sf::Http::Requestfriend
Method enum namesf::Http::Request
Post enum valuesf::Http::Request
Put enum valuesf::Http::Request
Request(const std::string &uri="/", Method method=Get, const std::string &body="")sf::Http::Request
setBody(const std::string &body)sf::Http::Request
setField(const std::string &field, const std::string &value)sf::Http::Request
setHttpVersion(unsigned int major, unsigned int minor)sf::Http::Request
setMethod(Method method)sf::Http::Request
setUri(const std::string &uri)sf::Http::Request
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Request.html b/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Request.html new file mode 100644 index 000000000..df3ded6f3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Request.html @@ -0,0 +1,423 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
sf::Http::Request Class Reference
+
+
+ +

Define a HTTP request. + More...

+ +

#include <SFML/Network/Http.hpp>

+ + + + + +

+Public Types

enum  Method {
+  Get +, Post +, Head +, Put +,
+  Delete +
+ }
 Enumerate the available HTTP methods for a request. More...
 
+ + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Request (const std::string &uri="/", Method method=Get, const std::string &body="")
 Default constructor.
 
void setField (const std::string &field, const std::string &value)
 Set the value of a field.
 
void setMethod (Method method)
 Set the request method.
 
void setUri (const std::string &uri)
 Set the requested URI.
 
void setHttpVersion (unsigned int major, unsigned int minor)
 Set the HTTP version for the request.
 
void setBody (const std::string &body)
 Set the body of the request.
 
+ + + +

+Friends

class Http
 
+

Detailed Description

+

Define a HTTP request.

+ +

Definition at line 54 of file Http.hpp.

+

Member Enumeration Documentation

+ +

◆ Method

+ +
+
+ + + + +
enum sf::Http::Request::Method
+
+ +

Enumerate the available HTTP methods for a request.

+ + + + + + +
Enumerator
Get 

Request in get mode, standard method to retrieve a page.

+
Post 

Request in post mode, usually to send data to a page.

+
Head 

Request a page's header only.

+
Put 

Request in put mode, useful for a REST API.

+
Delete 

Request in delete mode, useful for a REST API.

+
+ +

Definition at line 62 of file Http.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Request()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
sf::Http::Request::Request (const std::string & uri = "/",
Method method = Get,
const std::string & body = "" 
)
+
+ +

Default constructor.

+

This constructor creates a GET request, with the root URI ("/") and an empty body.

+
Parameters
+ + + + +
uriTarget URI
methodMethod to use for the request
bodyContent of the request's body
+
+
+ +
+
+

Member Function Documentation

+ +

◆ setBody()

+ +
+
+ + + + + + + + +
void sf::Http::Request::setBody (const std::string & body)
+
+ +

Set the body of the request.

+

The body of a request is optional and only makes sense for POST requests. It is ignored for all other methods. The body is empty by default.

+
Parameters
+ + +
bodyContent of the body
+
+
+ +
+
+ +

◆ setField()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Http::Request::setField (const std::string & field,
const std::string & value 
)
+
+ +

Set the value of a field.

+

The field is created if it doesn't exist. The name of the field is case-insensitive. By default, a request doesn't contain any field (but the mandatory fields are added later by the HTTP client when sending the request).

+
Parameters
+ + + +
fieldName of the field to set
valueValue of the field
+
+
+ +
+
+ +

◆ setHttpVersion()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Http::Request::setHttpVersion (unsigned int major,
unsigned int minor 
)
+
+ +

Set the HTTP version for the request.

+

The HTTP version is 1.0 by default.

+
Parameters
+ + + +
majorMajor HTTP version number
minorMinor HTTP version number
+
+
+ +
+
+ +

◆ setMethod()

+ +
+
+ + + + + + + + +
void sf::Http::Request::setMethod (Method method)
+
+ +

Set the request method.

+

See the Method enumeration for a complete list of all the availale methods. The method is Http::Request::Get by default.

+
Parameters
+ + +
methodMethod to use for the request
+
+
+ +
+
+ +

◆ setUri()

+ +
+
+ + + + + + + + +
void sf::Http::Request::setUri (const std::string & uri)
+
+ +

Set the requested URI.

+

The URI is the resource (usually a web page or a file) that you want to get or post. The URI is "/" (the root page) by default.

+
Parameters
+ + +
uriURI to request, relative to the host
+
+
+ +
+
+

Friends And Related Function Documentation

+ +

◆ Http

+ +
+
+ + + + + +
+ + + + +
friend class Http
+ 		+friend
+
+ +

Definition at line 148 of file Http.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Response-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Response-members.html new file mode 100644 index 000000000..ba214414d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Response-members.html @@ -0,0 +1,139 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Http::Response Member List
+
+
+ +

This is the complete list of members for sf::Http::Response, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Accepted enum valuesf::Http::Response
BadGateway enum valuesf::Http::Response
BadRequest enum valuesf::Http::Response
ConnectionFailed enum valuesf::Http::Response
Created enum valuesf::Http::Response
Forbidden enum valuesf::Http::Response
GatewayTimeout enum valuesf::Http::Response
getBody() constsf::Http::Response
getField(const std::string &field) constsf::Http::Response
getMajorHttpVersion() constsf::Http::Response
getMinorHttpVersion() constsf::Http::Response
getStatus() constsf::Http::Response
Http (defined in sf::Http::Response)sf::Http::Responsefriend
InternalServerError enum valuesf::Http::Response
InvalidResponse enum valuesf::Http::Response
MovedPermanently enum valuesf::Http::Response
MovedTemporarily enum valuesf::Http::Response
MultipleChoices enum valuesf::Http::Response
NoContent enum valuesf::Http::Response
NotFound enum valuesf::Http::Response
NotImplemented enum valuesf::Http::Response
NotModified enum valuesf::Http::Response
Ok enum valuesf::Http::Response
PartialContent enum valuesf::Http::Response
RangeNotSatisfiable enum valuesf::Http::Response
ResetContent enum valuesf::Http::Response
Response()sf::Http::Response
ServiceNotAvailable enum valuesf::Http::Response
Status enum namesf::Http::Response
Unauthorized enum valuesf::Http::Response
VersionNotSupported enum valuesf::Http::Response
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Response.html b/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Response.html new file mode 100644 index 000000000..dff0b3e23 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Http_1_1Response.html @@ -0,0 +1,416 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
sf::Http::Response Class Reference
+
+
+ +

Define a HTTP response. + More...

+ +

#include <SFML/Network/Http.hpp>

+ + + + + +

+Public Types

enum  Status {
+  Ok = 200 +, Created = 201 +, Accepted = 202 +, NoContent = 204 +,
+  ResetContent = 205 +, PartialContent = 206 +, MultipleChoices = 300 +, MovedPermanently = 301 +,
+  MovedTemporarily = 302 +, NotModified = 304 +, BadRequest = 400 +, Unauthorized = 401 +,
+  Forbidden = 403 +, NotFound = 404 +, RangeNotSatisfiable = 407 +, InternalServerError = 500 +,
+  NotImplemented = 501 +, BadGateway = 502 +, ServiceNotAvailable = 503 +, GatewayTimeout = 504 +,
+  VersionNotSupported = 505 +, InvalidResponse = 1000 +, ConnectionFailed = 1001 +
+ }
 Enumerate all the valid status codes for a response. More...
 
+ + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Response ()
 Default constructor.
 
const std::string & getField (const std::string &field) const
 Get the value of a field.
 
Status getStatus () const
 Get the response status code.
 
unsigned int getMajorHttpVersion () const
 Get the major HTTP version number of the response.
 
unsigned int getMinorHttpVersion () const
 Get the minor HTTP version number of the response.
 
const std::string & getBody () const
 Get the body of the response.
 
+ + + +

+Friends

class Http
 
+

Detailed Description

+

Define a HTTP response.

+ +

Definition at line 193 of file Http.hpp.

+

Member Enumeration Documentation

+ +

◆ Status

+ +
+
+ + + + +
enum sf::Http::Response::Status
+
+ +

Enumerate all the valid status codes for a response.

+ + + + + + + + + + + + + + + + + + + + + + + + +
Enumerator
Ok 

Most common code returned when operation was successful.

+
Created 

The resource has successfully been created.

+
Accepted 

The request has been accepted, but will be processed later by the server.

+
NoContent 

The server didn't send any data in return.

+
ResetContent 

The server informs the client that it should clear the view (form) that caused the request to be sent.

+
PartialContent 

The server has sent a part of the resource, as a response to a partial GET request.

+
MultipleChoices 

The requested page can be accessed from several locations.

+
MovedPermanently 

The requested page has permanently moved to a new location.

+
MovedTemporarily 

The requested page has temporarily moved to a new location.

+
NotModified 

For conditional requests, means the requested page hasn't changed and doesn't need to be refreshed.

+
BadRequest 

The server couldn't understand the request (syntax error)

+
Unauthorized 

The requested page needs an authentication to be accessed.

+
Forbidden 

The requested page cannot be accessed at all, even with authentication.

+
NotFound 

The requested page doesn't exist.

+
RangeNotSatisfiable 

The server can't satisfy the partial GET request (with a "Range" header field)

+
InternalServerError 

The server encountered an unexpected error.

+
NotImplemented 

The server doesn't implement a requested feature.

+
BadGateway 

The gateway server has received an error from the source server.

+
ServiceNotAvailable 

The server is temporarily unavailable (overloaded, in maintenance, ...)

+
GatewayTimeout 

The gateway server couldn't receive a response from the source server.

+
VersionNotSupported 

The server doesn't support the requested HTTP version.

+
InvalidResponse 

Response is not a valid HTTP one.

+
ConnectionFailed 

Connection with server failed.

+
+ +

Definition at line 201 of file Http.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Response()

+ +
+
+ + + + + + + +
sf::Http::Response::Response ()
+
+ +

Default constructor.

+

Constructs an empty response.

+ +
+
+

Member Function Documentation

+ +

◆ getBody()

+ +
+
+ + + + + + + +
const std::string & sf::Http::Response::getBody () const
+
+ +

Get the body of the response.

+

The body of a response may contain:

    +
  • the requested page (for GET requests)
    • +
  • a response from the server (for POST requests)
    • +
  • nothing (for HEAD requests)
    • +
  • an error message (in case of an error)
    • +
+
Returns
The response body
+ +
+
+ +

◆ getField()

+ +
+
+ + + + + + + + +
const std::string & sf::Http::Response::getField (const std::string & field) const
+
+ +

Get the value of a field.

+

If the field field is not found in the response header, the empty string is returned. This function uses case-insensitive comparisons.

+
Parameters
+ + +
fieldName of the field to get
+
+
+
Returns
Value of the field, or empty string if not found
+ +
+
+ +

◆ getMajorHttpVersion()

+ +
+
+ + + + + + + +
unsigned int sf::Http::Response::getMajorHttpVersion () const
+
+ +

Get the major HTTP version number of the response.

+
Returns
Major HTTP version number
+
See also
getMinorHttpVersion
+ +
+
+ +

◆ getMinorHttpVersion()

+ +
+
+ + + + + + + +
unsigned int sf::Http::Response::getMinorHttpVersion () const
+
+ +

Get the minor HTTP version number of the response.

+
Returns
Minor HTTP version number
+
See also
getMajorHttpVersion
+ +
+
+ +

◆ getStatus()

+ +
+
+ + + + + + + +
Status sf::Http::Response::getStatus () const
+
+ +

Get the response status code.

+

The status code should be the first thing to be checked after receiving a response, it defines whether it is a success, a failure or anything else (see the Status enumeration).

+
Returns
Status code of the response
+ +
+
+

Friends And Related Function Documentation

+ +

◆ Http

+ +
+
+ + + + + +
+ + + + +
friend class Http
+ 		+friend
+
+ +

Definition at line 308 of file Http.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Image-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Image-members.html new file mode 100644 index 000000000..575784dfe --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Image-members.html @@ -0,0 +1,125 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Image Member List
+
+
+ +

This is the complete list of members for sf::Image, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
copy(const Image &source, unsigned int destX, unsigned int destY, const IntRect &sourceRect=IntRect(0, 0, 0, 0), bool applyAlpha=false)sf::Image
create(unsigned int width, unsigned int height, const Color &color=Color(0, 0, 0))sf::Image
create(unsigned int width, unsigned int height, const Uint8 *pixels)sf::Image
createMaskFromColor(const Color &color, Uint8 alpha=0)sf::Image
flipHorizontally()sf::Image
flipVertically()sf::Image
getPixel(unsigned int x, unsigned int y) constsf::Image
getPixelsPtr() constsf::Image
getSize() constsf::Image
Image()sf::Image
loadFromFile(const std::string &filename)sf::Image
loadFromMemory(const void *data, std::size_t size)sf::Image
loadFromStream(InputStream &stream)sf::Image
saveToFile(const std::string &filename) constsf::Image
saveToMemory(std::vector< sf::Uint8 > &output, const std::string &format) constsf::Image
setPixel(unsigned int x, unsigned int y, const Color &color)sf::Image
~Image()sf::Image
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Image.html b/Space-Invaders/sfml/doc/html/classsf_1_1Image.html new file mode 100644 index 000000000..e00d453e6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Image.html @@ -0,0 +1,771 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::Image Class Reference
Graphics module
+
+
+ +

Class for loading, manipulating and saving images. + More...

+ +

#include <SFML/Graphics/Image.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Image ()
 Default constructor.
 
 ~Image ()
 Destructor.
 
void create (unsigned int width, unsigned int height, const Color &color=Color(0, 0, 0))
 Create the image and fill it with a unique color.
 
void create (unsigned int width, unsigned int height, const Uint8 *pixels)
 Create the image from an array of pixels.
 
bool loadFromFile (const std::string &filename)
 Load the image from a file on disk.
 
bool loadFromMemory (const void *data, std::size_t size)
 Load the image from a file in memory.
 
bool loadFromStream (InputStream &stream)
 Load the image from a custom stream.
 
bool saveToFile (const std::string &filename) const
 Save the image to a file on disk.
 
bool saveToMemory (std::vector< sf::Uint8 > &output, const std::string &format) const
 Save the image to a buffer in memory.
 
Vector2u getSize () const
 Return the size (width and height) of the image.
 
void createMaskFromColor (const Color &color, Uint8 alpha=0)
 Create a transparency mask from a specified color-key.
 
void copy (const Image &source, unsigned int destX, unsigned int destY, const IntRect &sourceRect=IntRect(0, 0, 0, 0), bool applyAlpha=false)
 Copy pixels from another image onto this one.
 
void setPixel (unsigned int x, unsigned int y, const Color &color)
 Change the color of a pixel.
 
Color getPixel (unsigned int x, unsigned int y) const
 Get the color of a pixel.
 
const Uint8 * getPixelsPtr () const
 Get a read-only pointer to the array of pixels.
 
void flipHorizontally ()
 Flip the image horizontally (left <-> right)
 
void flipVertically ()
 Flip the image vertically (top <-> bottom)
 
+

Detailed Description

+

Class for loading, manipulating and saving images.

+

sf::Image is an abstraction to manipulate images as bidimensional arrays of pixels.

+

The class provides functions to load, read, write and save pixels, as well as many other useful functions.

+

sf::Image can handle a unique internal representation of pixels, which is RGBA 32 bits. This means that a pixel must be composed of 8 bits red, green, blue and alpha channels – just like a sf::Color. All the functions that return an array of pixels follow this rule, and all parameters that you pass to sf::Image functions (such as loadFromMemory) must use this representation as well.

+

A sf::Image can be copied, but it is a heavy resource and if possible you should always use [const] references to pass or return them to avoid useless copies.

+

Usage example:

// Load an image file from a file
+
sf::Image background;
+
if (!background.loadFromFile("background.jpg"))
+
return -1;
+
+
// Create a 20x20 image filled with black color
+
sf::Image image;
+
image.create(20, 20, sf::Color::Black);
+
+
// Copy image1 on image2 at position (10, 10)
+
image.copy(background, 10, 10);
+
+
// Make the top-left pixel transparent
+
sf::Color color = image.getPixel(0, 0);
+
color.a = 0;
+
image.setPixel(0, 0, color);
+
+
// Save the image to a file
+
if (!image.saveToFile("result.png"))
+
return -1;
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+
sf::Color::a
Uint8 a
Alpha (opacity) component.
Definition: Color.hpp:99
+
sf::Color::Black
static const Color Black
Black predefined color.
Definition: Color.hpp:83
+
sf::Image
Class for loading, manipulating and saving images.
Definition: Image.hpp:47
+
sf::Image::create
void create(unsigned int width, unsigned int height, const Color &color=Color(0, 0, 0))
Create the image and fill it with a unique color.
+
sf::Image::saveToFile
bool saveToFile(const std::string &filename) const
Save the image to a file on disk.
+
sf::Image::loadFromFile
bool loadFromFile(const std::string &filename)
Load the image from a file on disk.
+
sf::Image::setPixel
void setPixel(unsigned int x, unsigned int y, const Color &color)
Change the color of a pixel.
+
sf::Image::copy
void copy(const Image &source, unsigned int destX, unsigned int destY, const IntRect &sourceRect=IntRect(0, 0, 0, 0), bool applyAlpha=false)
Copy pixels from another image onto this one.
+
sf::Image::getPixel
Color getPixel(unsigned int x, unsigned int y) const
Get the color of a pixel.
+
See also
sf::Texture
+ +

Definition at line 46 of file Image.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Image()

+ +
+
+ + + + + + + +
sf::Image::Image ()
+
+ +

Default constructor.

+

Creates an empty image.

+ +
+
+ +

◆ ~Image()

+ +
+
+ + + + + + + +
sf::Image::~Image ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ copy()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Image::copy (const Image & source,
unsigned int destX,
unsigned int destY,
const IntRect & sourceRect = IntRect(0, 0, 0, 0),
bool applyAlpha = false 
)
+
+ +

Copy pixels from another image onto this one.

+

This function does a slow pixel copy and should not be used intensively. It can be used to prepare a complex static image from several others, but if you need this kind of feature in real-time you'd better use sf::RenderTexture.

+

If sourceRect is empty, the whole image is copied. If applyAlpha is set to true, alpha blending is applied from the source pixels to the destination pixels using the over operator. If it is false, the source pixels are copied unchanged with their alpha value.

+

See https://en.wikipedia.org/wiki/Alpha_compositing for details on the over operator.

+
Parameters
+ + + + + + +
sourceSource image to copy
destXX coordinate of the destination position
destYY coordinate of the destination position
sourceRectSub-rectangle of the source image to copy
applyAlphaShould the copy take into account the source transparency?
+
+
+ +
+
+ +

◆ create() [1/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Image::create (unsigned int width,
unsigned int height,
const Color & color = Color(0, 0, 0) 
)
+
+ +

Create the image and fill it with a unique color.

+
Parameters
+ + + + +
widthWidth of the image
heightHeight of the image
colorFill color
+
+
+ +
+
+ +

◆ create() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Image::create (unsigned int width,
unsigned int height,
const Uint8 * pixels 
)
+
+ +

Create the image from an array of pixels.

+

The pixel array is assumed to contain 32-bits RGBA pixels, and have the given width and height. If not, this is an undefined behavior. If pixels is null, an empty image is created.

+
Parameters
+ + + + +
widthWidth of the image
heightHeight of the image
pixelsArray of pixels to copy to the image
+
+
+ +
+
+ +

◆ createMaskFromColor()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Image::createMaskFromColor (const Color & color,
Uint8 alpha = 0 
)
+
+ +

Create a transparency mask from a specified color-key.

+

This function sets the alpha value of every pixel matching the given color to alpha (0 by default), so that they become transparent.

+
Parameters
+ + + +
colorColor to make transparent
alphaAlpha value to assign to transparent pixels
+
+
+ +
+
+ +

◆ flipHorizontally()

+ +
+
+ + + + + + + +
void sf::Image::flipHorizontally ()
+
+ +

Flip the image horizontally (left <-> right)

+ +
+
+ +

◆ flipVertically()

+ +
+
+ + + + + + + +
void sf::Image::flipVertically ()
+
+ +

Flip the image vertically (top <-> bottom)

+ +
+
+ +

◆ getPixel()

+ +
+
+ + + + + + + + + + + + + + + + + + +
Color sf::Image::getPixel (unsigned int x,
unsigned int y 
) const
+
+ +

Get the color of a pixel.

+

This function doesn't check the validity of the pixel coordinates, using out-of-range values will result in an undefined behavior.

+
Parameters
+ + + +
xX coordinate of pixel to get
yY coordinate of pixel to get
+
+
+
Returns
Color of the pixel at coordinates (x, y)
+
See also
setPixel
+ +
+
+ +

◆ getPixelsPtr()

+ +
+
+ + + + + + + +
const Uint8 * sf::Image::getPixelsPtr () const
+
+ +

Get a read-only pointer to the array of pixels.

+

The returned value points to an array of RGBA pixels made of 8 bits integers components. The size of the array is width * height * 4 (getSize().x * getSize().y * 4). Warning: the returned pointer may become invalid if you modify the image, so you should never store it for too long. If the image is empty, a null pointer is returned.

+
Returns
Read-only pointer to the array of pixels
+ +
+
+ +

◆ getSize()

+ +
+
+ + + + + + + +
Vector2u sf::Image::getSize () const
+
+ +

Return the size (width and height) of the image.

+
Returns
Size of the image, in pixels
+ +
+
+ +

◆ loadFromFile()

+ +
+
+ + + + + + + + +
bool sf::Image::loadFromFile (const std::string & filename)
+
+ +

Load the image from a file on disk.

+

The supported image formats are bmp, png, tga, jpg, gif, psd, hdr, pic and pnm. Some format options are not supported, like jpeg with arithmetic coding or ASCII pnm. If this function fails, the image is left unchanged.

+
Parameters
+ + +
filenamePath of the image file to load
+
+
+
Returns
True if loading was successful
+
See also
loadFromMemory, loadFromStream, saveToFile
+ +
+
+ +

◆ loadFromMemory()

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Image::loadFromMemory (const void * data,
std::size_t size 
)
+
+ +

Load the image from a file in memory.

+

The supported image formats are bmp, png, tga, jpg, gif, psd, hdr, pic and pnm. Some format options are not supported, like jpeg with arithmetic coding or ASCII pnm. If this function fails, the image is left unchanged.

+
Parameters
+ + + +
dataPointer to the file data in memory
sizeSize of the data to load, in bytes
+
+
+
Returns
True if loading was successful
+
See also
loadFromFile, loadFromStream
+ +
+
+ +

◆ loadFromStream()

+ +
+
+ + + + + + + + +
bool sf::Image::loadFromStream (InputStream & stream)
+
+ +

Load the image from a custom stream.

+

The supported image formats are bmp, png, tga, jpg, gif, psd, hdr, pic and pnm. Some format options are not supported, like jpeg with arithmetic coding or ASCII pnm. If this function fails, the image is left unchanged.

+
Parameters
+ + +
streamSource stream to read from
+
+
+
Returns
True if loading was successful
+
See also
loadFromFile, loadFromMemory
+ +
+
+ +

◆ saveToFile()

+ +
+
+ + + + + + + + +
bool sf::Image::saveToFile (const std::string & filename) const
+
+ +

Save the image to a file on disk.

+

The format of the image is automatically deduced from the extension. The supported image formats are bmp, png, tga and jpg. The destination file is overwritten if it already exists. This function fails if the image is empty.

+
Parameters
+ + +
filenamePath of the file to save
+
+
+
Returns
True if saving was successful
+
See also
create, loadFromFile, loadFromMemory
+ +
+
+ +

◆ saveToMemory()

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Image::saveToMemory (std::vector< sf::Uint8 > & output,
const std::string & format 
) const
+
+ +

Save the image to a buffer in memory.

+

The format of the image must be specified. The supported image formats are bmp, png, tga and jpg. This function fails if the image is empty, or if the format was invalid.

+
Parameters
+ + + +
outputBuffer to fill with encoded data
formatEncoding format to use
+
+
+
Returns
True if saving was successful
+
See also
create, loadFromFile, loadFromMemory, saveToFile
+ +
+
+ +

◆ setPixel()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Image::setPixel (unsigned int x,
unsigned int y,
const Color & color 
)
+
+ +

Change the color of a pixel.

+

This function doesn't check the validity of the pixel coordinates, using out-of-range values will result in an undefined behavior.

+
Parameters
+ + + + +
xX coordinate of pixel to change
yY coordinate of pixel to change
colorNew color of the pixel
+
+
+
See also
getPixel
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1InputSoundFile-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1InputSoundFile-members.html new file mode 100644 index 000000000..db968da57 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1InputSoundFile-members.html @@ -0,0 +1,123 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::InputSoundFile Member List
+
+
+ +

This is the complete list of members for sf::InputSoundFile, including all inherited members.

+ + + + + + + + + + + + + + + + +
close()sf::InputSoundFile
getChannelCount() constsf::InputSoundFile
getDuration() constsf::InputSoundFile
getSampleCount() constsf::InputSoundFile
getSampleOffset() constsf::InputSoundFile
getSampleRate() constsf::InputSoundFile
getTimeOffset() constsf::InputSoundFile
InputSoundFile()sf::InputSoundFile
openFromFile(const std::string &filename)sf::InputSoundFile
openFromMemory(const void *data, std::size_t sizeInBytes)sf::InputSoundFile
openFromStream(InputStream &stream)sf::InputSoundFile
read(Int16 *samples, Uint64 maxCount)sf::InputSoundFile
seek(Uint64 sampleOffset)sf::InputSoundFile
seek(Time timeOffset)sf::InputSoundFile
~InputSoundFile()sf::InputSoundFile
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1InputSoundFile.html b/Space-Invaders/sfml/doc/html/classsf_1_1InputSoundFile.html new file mode 100644 index 000000000..1ec6e7b33 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1InputSoundFile.html @@ -0,0 +1,581 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::InputSoundFile Class Reference
Audio module
+
+
+ +

Provide read access to sound files. + More...

+ +

#include <SFML/Audio/InputSoundFile.hpp>

+
+Inheritance diagram for sf::InputSoundFile:
+
+
+ + +sf::NonCopyable + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 InputSoundFile ()
 Default constructor.
 
 ~InputSoundFile ()
 Destructor.
 
bool openFromFile (const std::string &filename)
 Open a sound file from the disk for reading.
 
bool openFromMemory (const void *data, std::size_t sizeInBytes)
 Open a sound file in memory for reading.
 
bool openFromStream (InputStream &stream)
 Open a sound file from a custom stream for reading.
 
Uint64 getSampleCount () const
 Get the total number of audio samples in the file.
 
unsigned int getChannelCount () const
 Get the number of channels used by the sound.
 
unsigned int getSampleRate () const
 Get the sample rate of the sound.
 
Time getDuration () const
 Get the total duration of the sound file.
 
Time getTimeOffset () const
 Get the read offset of the file in time.
 
Uint64 getSampleOffset () const
 Get the read offset of the file in samples.
 
void seek (Uint64 sampleOffset)
 Change the current read position to the given sample offset.
 
void seek (Time timeOffset)
 Change the current read position to the given time offset.
 
Uint64 read (Int16 *samples, Uint64 maxCount)
 Read audio samples from the open file.
 
void close ()
 Close the current file.
 
+

Detailed Description

+

Provide read access to sound files.

+

This class decodes audio samples from a sound file.

+

It is used internally by higher-level classes such as sf::SoundBuffer and sf::Music, but can also be useful if you want to process or analyze audio files without playing them, or if you want to implement your own version of sf::Music with more specific features.

+

Usage example:

// Open a sound file
+
sf::InputSoundFile file;
+
if (!file.openFromFile("music.ogg"))
+
/* error */;
+
+
// Print the sound attributes
+
std::cout << "duration: " << file.getDuration().asSeconds() << std::endl;
+
std::cout << "channels: " << file.getChannelCount() << std::endl;
+
std::cout << "sample rate: " << file.getSampleRate() << std::endl;
+
std::cout << "sample count: " << file.getSampleCount() << std::endl;
+
+
// Read and process batches of samples until the end of file is reached
+
sf::Int16 samples[1024];
+
sf::Uint64 count;
+
do
+
{
+
count = file.read(samples, 1024);
+
+
// process, analyze, play, convert, or whatever
+
// you want to do with the samples...
+
}
+
while (count > 0);
+
sf::InputSoundFile
Provide read access to sound files.
Definition: InputSoundFile.hpp:48
+
sf::InputSoundFile::getChannelCount
unsigned int getChannelCount() const
Get the number of channels used by the sound.
+
sf::InputSoundFile::getSampleCount
Uint64 getSampleCount() const
Get the total number of audio samples in the file.
+
sf::InputSoundFile::getSampleRate
unsigned int getSampleRate() const
Get the sample rate of the sound.
+
sf::InputSoundFile::read
Uint64 read(Int16 *samples, Uint64 maxCount)
Read audio samples from the open file.
+
sf::InputSoundFile::getDuration
Time getDuration() const
Get the total duration of the sound file.
+
sf::InputSoundFile::openFromFile
bool openFromFile(const std::string &filename)
Open a sound file from the disk for reading.
+
sf::Time::asSeconds
float asSeconds() const
Return the time value as a number of seconds.
+
See also
sf::SoundFileReader, sf::OutputSoundFile
+ +

Definition at line 47 of file InputSoundFile.hpp.

+

Constructor & Destructor Documentation

+ +

◆ InputSoundFile()

+ +
+
+ + + + + + + +
sf::InputSoundFile::InputSoundFile ()
+
+ +

Default constructor.

+ +
+
+ +

◆ ~InputSoundFile()

+ +
+
+ + + + + + + +
sf::InputSoundFile::~InputSoundFile ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ close()

+ +
+
+ + + + + + + +
void sf::InputSoundFile::close ()
+
+ +

Close the current file.

+ +
+
+ +

◆ getChannelCount()

+ +
+
+ + + + + + + +
unsigned int sf::InputSoundFile::getChannelCount () const
+
+ +

Get the number of channels used by the sound.

+
Returns
Number of channels (1 = mono, 2 = stereo)
+ +
+
+ +

◆ getDuration()

+ +
+
+ + + + + + + +
Time sf::InputSoundFile::getDuration () const
+
+ +

Get the total duration of the sound file.

+

This function is provided for convenience, the duration is deduced from the other sound file attributes.

+
Returns
Duration of the sound file
+ +
+
+ +

◆ getSampleCount()

+ +
+
+ + + + + + + +
Uint64 sf::InputSoundFile::getSampleCount () const
+
+ +

Get the total number of audio samples in the file.

+
Returns
Number of samples
+ +
+
+ +

◆ getSampleOffset()

+ +
+
+ + + + + + + +
Uint64 sf::InputSoundFile::getSampleOffset () const
+
+ +

Get the read offset of the file in samples.

+
Returns
Sample position
+ +
+
+ +

◆ getSampleRate()

+ +
+
+ + + + + + + +
unsigned int sf::InputSoundFile::getSampleRate () const
+
+ +

Get the sample rate of the sound.

+
Returns
Sample rate, in samples per second
+ +
+
+ +

◆ getTimeOffset()

+ +
+
+ + + + + + + +
Time sf::InputSoundFile::getTimeOffset () const
+
+ +

Get the read offset of the file in time.

+
Returns
Time position
+ +
+
+ +

◆ openFromFile()

+ +
+
+ + + + + + + + +
bool sf::InputSoundFile::openFromFile (const std::string & filename)
+
+ +

Open a sound file from the disk for reading.

+

The supported audio formats are: WAV (PCM only), OGG/Vorbis, FLAC, MP3. The supported sample sizes for FLAC and WAV are 8, 16, 24 and 32 bit.

+

Because of minimp3_ex limitation, for MP3 files with big (>16kb) APEv2 tag, it may not be properly removed, tag data will be treated as MP3 data and there is a low chance of garbage decoded at the end of file. See also: https://github.com/lieff/minimp3

+
Parameters
+ + +
filenamePath of the sound file to load
+
+
+
Returns
True if the file was successfully opened
+ +
+
+ +

◆ openFromMemory()

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::InputSoundFile::openFromMemory (const void * data,
std::size_t sizeInBytes 
)
+
+ +

Open a sound file in memory for reading.

+

The supported audio formats are: WAV (PCM only), OGG/Vorbis, FLAC. The supported sample sizes for FLAC and WAV are 8, 16, 24 and 32 bit.

+
Parameters
+ + + +
dataPointer to the file data in memory
sizeInBytesSize of the data to load, in bytes
+
+
+
Returns
True if the file was successfully opened
+ +
+
+ +

◆ openFromStream()

+ +
+
+ + + + + + + + +
bool sf::InputSoundFile::openFromStream (InputStream & stream)
+
+ +

Open a sound file from a custom stream for reading.

+

The supported audio formats are: WAV (PCM only), OGG/Vorbis, FLAC. The supported sample sizes for FLAC and WAV are 8, 16, 24 and 32 bit.

+
Parameters
+ + +
streamSource stream to read from
+
+
+
Returns
True if the file was successfully opened
+ +
+
+ +

◆ read()

+ +
+
+ + + + + + + + + + + + + + + + + + +
Uint64 sf::InputSoundFile::read (Int16 * samples,
Uint64 maxCount 
)
+
+ +

Read audio samples from the open file.

+
Parameters
+ + + +
samplesPointer to the sample array to fill
maxCountMaximum number of samples to read
+
+
+
Returns
Number of samples actually read (may be less than maxCount)
+ +
+
+ +

◆ seek() [1/2]

+ +
+
+ + + + + + + + +
void sf::InputSoundFile::seek (Time timeOffset)
+
+ +

Change the current read position to the given time offset.

+

Using a time offset is handy but imprecise. If you need an accurate result, consider using the overload which takes a sample offset.

+

If the given time exceeds to total duration, this function jumps to the end of the sound file.

+
Parameters
+ + +
timeOffsetTime to jump to, relative to the beginning
+
+
+ +
+
+ +

◆ seek() [2/2]

+ +
+
+ + + + + + + + +
void sf::InputSoundFile::seek (Uint64 sampleOffset)
+
+ +

Change the current read position to the given sample offset.

+

This function takes a sample offset to provide maximum precision. If you need to jump to a given time, use the other overload.

+

The sample offset takes the channels into account. If you have a time offset instead, you can easily find the corresponding sample offset with the following formula: timeInSeconds * sampleRate * channelCount If the given offset exceeds to total number of samples, this function jumps to the end of the sound file.

+
Parameters
+ + +
sampleOffsetIndex of the sample to jump to, relative to the beginning
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1InputSoundFile.png b/Space-Invaders/sfml/doc/html/classsf_1_1InputSoundFile.png new file mode 100644 index 000000000..5fe4f5500 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1InputSoundFile.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1InputStream-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1InputStream-members.html new file mode 100644 index 000000000..815488f9d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1InputStream-members.html @@ -0,0 +1,113 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::InputStream Member List
+
+
+ +

This is the complete list of members for sf::InputStream, including all inherited members.

+ + + + + + +
getSize()=0sf::InputStreampure virtual
read(void *data, Int64 size)=0sf::InputStreampure virtual
seek(Int64 position)=0sf::InputStreampure virtual
tell()=0sf::InputStreampure virtual
~InputStream()sf::InputStreaminlinevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1InputStream.html b/Space-Invaders/sfml/doc/html/classsf_1_1InputStream.html new file mode 100644 index 000000000..6890c5bf5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1InputStream.html @@ -0,0 +1,368 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::InputStream Class Referenceabstract
System module
+
+
+ +

Abstract class for custom file input streams. + More...

+ +

#include <SFML/System/InputStream.hpp>

+
+Inheritance diagram for sf::InputStream:
+
+
+ + +sf::FileInputStream +sf::MemoryInputStream + +
+ + + + + + + + + + + + + + + + + +

+Public Member Functions

virtual ~InputStream ()
 Virtual destructor.
 
virtual Int64 read (void *data, Int64 size)=0
 Read data from the stream.
 
virtual Int64 seek (Int64 position)=0
 Change the current reading position.
 
virtual Int64 tell ()=0
 Get the current reading position in the stream.
 
virtual Int64 getSize ()=0
 Return the size of the stream.
 
+

Detailed Description

+

Abstract class for custom file input streams.

+

This class allows users to define their own file input sources from which SFML can load resources.

+

SFML resource classes like sf::Texture and sf::SoundBuffer provide loadFromFile and loadFromMemory functions, which read data from conventional sources. However, if you have data coming from a different source (over a network, embedded, encrypted, compressed, etc) you can derive your own class from sf::InputStream and load SFML resources with their loadFromStream function.

+

Usage example:

// custom stream class that reads from inside a zip file
+
class ZipStream : public sf::InputStream
+
{
+
public:
+
+
ZipStream(std::string archive);
+
+
bool open(std::string filename);
+
+
Int64 read(void* data, Int64 size);
+
+
Int64 seek(Int64 position);
+
+
Int64 tell();
+
+
Int64 getSize();
+
+
private:
+
+
...
+
};
+
+
// now you can load textures...
+
sf::Texture texture;
+
ZipStream stream("resources.zip");
+
stream.open("images/img.png");
+
texture.loadFromStream(stream);
+
+
// musics...
+
sf::Music music;
+
ZipStream stream("resources.zip");
+
stream.open("musics/msc.ogg");
+
music.openFromStream(stream);
+
+
// etc.
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::Music
Streamed music played from an audio file.
Definition: Music.hpp:49
+
sf::Music::openFromStream
bool openFromStream(InputStream &stream)
Open a music from an audio file in a custom stream.
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Texture::loadFromStream
bool loadFromStream(InputStream &stream, const IntRect &area=IntRect())
Load the texture from a custom stream.
+
+

Definition at line 41 of file InputStream.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ~InputStream()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::InputStream::~InputStream ()
+ 		+inlinevirtual
+
+ +

Virtual destructor.

+ +

Definition at line 49 of file InputStream.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ getSize()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Int64 sf::InputStream::getSize ()
+ 		+pure virtual
+
+ +

Return the size of the stream.

+
Returns
The total number of bytes available in the stream, or -1 on error
+ +

Implemented in sf::FileInputStream, and sf::MemoryInputStream.

+ +
+
+ +

◆ read()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual Int64 sf::InputStream::read (void * data,
Int64 size 
)
+ 		+pure virtual
+
+ +

Read data from the stream.

+

After reading, the stream's reading position must be advanced by the amount of bytes read.

+
Parameters
+ + + +
dataBuffer where to copy the read data
sizeDesired number of bytes to read
+
+
+
Returns
The number of bytes actually read, or -1 on error
+ +

Implemented in sf::FileInputStream, and sf::MemoryInputStream.

+ +
+
+ +

◆ seek()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual Int64 sf::InputStream::seek (Int64 position)
+ 		+pure virtual
+
+ +

Change the current reading position.

+
Parameters
+ + +
positionThe position to seek to, from the beginning
+
+
+
Returns
The position actually sought to, or -1 on error
+ +

Implemented in sf::FileInputStream, and sf::MemoryInputStream.

+ +
+
+ +

◆ tell()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Int64 sf::InputStream::tell ()
+ 		+pure virtual
+
+ +

Get the current reading position in the stream.

+
Returns
The current position, or -1 on error.
+ +

Implemented in sf::FileInputStream, and sf::MemoryInputStream.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1InputStream.png b/Space-Invaders/sfml/doc/html/classsf_1_1InputStream.png new file mode 100644 index 000000000..552a88bde Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1InputStream.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1IpAddress-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1IpAddress-members.html new file mode 100644 index 000000000..2cf8fa582 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1IpAddress-members.html @@ -0,0 +1,122 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::IpAddress Member List
+
+
+ +

This is the complete list of members for sf::IpAddress, including all inherited members.

+ + + + + + + + + + + + + + + +
Anysf::IpAddressstatic
Broadcastsf::IpAddressstatic
getLocalAddress()sf::IpAddressstatic
getPublicAddress(Time timeout=Time::Zero)sf::IpAddressstatic
IpAddress()sf::IpAddress
IpAddress(const std::string &address)sf::IpAddress
IpAddress(const char *address)sf::IpAddress
IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3)sf::IpAddress
IpAddress(Uint32 address)sf::IpAddressexplicit
LocalHostsf::IpAddressstatic
Nonesf::IpAddressstatic
operator<sf::IpAddressfriend
toInteger() constsf::IpAddress
toString() constsf::IpAddress
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1IpAddress.html b/Space-Invaders/sfml/doc/html/classsf_1_1IpAddress.html new file mode 100644 index 000000000..7f98735ff --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1IpAddress.html @@ -0,0 +1,623 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Static Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
sf::IpAddress Class Reference
Network module
+
+
+ +

Encapsulate an IPv4 network address. + More...

+ +

#include <SFML/Network/IpAddress.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 IpAddress ()
 Default constructor.
 
 IpAddress (const std::string &address)
 Construct the address from a string.
 
 IpAddress (const char *address)
 Construct the address from a string.
 
 IpAddress (Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3)
 Construct the address from 4 bytes.
 
 IpAddress (Uint32 address)
 Construct the address from a 32-bits integer.
 
std::string toString () const
 Get a string representation of the address.
 
Uint32 toInteger () const
 Get an integer representation of the address.
 
+ + + + + + + +

+Static Public Member Functions

static IpAddress getLocalAddress ()
 Get the computer's local address.
 
static IpAddress getPublicAddress (Time timeout=Time::Zero)
 Get the computer's public address.
 
+ + + + + + + + + + + + + +

+Static Public Attributes

static const IpAddress None
 Value representing an empty/invalid address.
 
static const IpAddress Any
 Value representing any address (0.0.0.0)
 
static const IpAddress LocalHost
 The "localhost" address (for connecting a computer to itself locally)
 
static const IpAddress Broadcast
 The "broadcast" address (for sending UDP messages to everyone on a local network)
 
+ + + + +

+Friends

bool operator< (const IpAddress &left, const IpAddress &right)
 Overload of < operator to compare two IP addresses.
 
+

Detailed Description

+

Encapsulate an IPv4 network address.

+

sf::IpAddress is a utility class for manipulating network addresses.

+

It provides a set a implicit constructors and conversion functions to easily build or transform an IP address from/to various representations.

+

Usage example:

sf::IpAddress a0; // an invalid address
+
sf::IpAddress a1 = sf::IpAddress::None; // an invalid address (same as a0)
+
sf::IpAddress a2("127.0.0.1"); // the local host address
+
sf::IpAddress a3 = sf::IpAddress::Broadcast; // the broadcast address
+
sf::IpAddress a4(192, 168, 1, 56); // a local address
+
sf::IpAddress a5("my_computer"); // a local address created from a network name
+
sf::IpAddress a6("89.54.1.169"); // a distant address
+
sf::IpAddress a7("www.google.com"); // a distant address created from a network name
+
sf::IpAddress a8 = sf::IpAddress::getLocalAddress(); // my address on the local network
+
sf::IpAddress a9 = sf::IpAddress::getPublicAddress(); // my address on the internet
+
sf::IpAddress
Encapsulate an IPv4 network address.
Definition: IpAddress.hpp:45
+
sf::IpAddress::None
static const IpAddress None
Value representing an empty/invalid address.
Definition: IpAddress.hpp:184
+
sf::IpAddress::getLocalAddress
static IpAddress getLocalAddress()
Get the computer's local address.
+
sf::IpAddress::getPublicAddress
static IpAddress getPublicAddress(Time timeout=Time::Zero)
Get the computer's public address.
+
sf::IpAddress::Broadcast
static const IpAddress Broadcast
The "broadcast" address (for sending UDP messages to everyone on a local network)
Definition: IpAddress.hpp:187
+

Note that sf::IpAddress currently doesn't support IPv6 nor other types of network addresses.

+ +

Definition at line 44 of file IpAddress.hpp.

+

Constructor & Destructor Documentation

+ +

◆ IpAddress() [1/5]

+ +
+
+ + + + + + + +
sf::IpAddress::IpAddress ()
+
+ +

Default constructor.

+

This constructor creates an empty (invalid) address

+ +
+
+ +

◆ IpAddress() [2/5]

+ +
+
+ + + + + + + + +
sf::IpAddress::IpAddress (const std::string & address)
+
+ +

Construct the address from a string.

+

Here address can be either a decimal address (ex: "192.168.1.56") or a network name (ex: "localhost").

+
Parameters
+ + +
addressIP address or network name
+
+
+ +
+
+ +

◆ IpAddress() [3/5]

+ +
+
+ + + + + + + + +
sf::IpAddress::IpAddress (const char * address)
+
+ +

Construct the address from a string.

+

Here address can be either a decimal address (ex: "192.168.1.56") or a network name (ex: "localhost"). This is equivalent to the constructor taking a std::string parameter, it is defined for convenience so that the implicit conversions from literal strings to IpAddress work.

+
Parameters
+ + +
addressIP address or network name
+
+
+ +
+
+ +

◆ IpAddress() [4/5]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sf::IpAddress::IpAddress (Uint8 byte0,
Uint8 byte1,
Uint8 byte2,
Uint8 byte3 
)
+
+ +

Construct the address from 4 bytes.

+

Calling IpAddress(a, b, c, d) is equivalent to calling IpAddress("a.b.c.d"), but safer as it doesn't have to parse a string to get the address components.

+
Parameters
+ + + + + +
byte0First byte of the address
byte1Second byte of the address
byte2Third byte of the address
byte3Fourth byte of the address
+
+
+ +
+
+ +

◆ IpAddress() [5/5]

+ +
+
+ + + + + +
+ + + + + + + + +
sf::IpAddress::IpAddress (Uint32 address)
+ 		+explicit
+
+ +

Construct the address from a 32-bits integer.

+

This constructor uses the internal representation of the address directly. It should be used for optimization purposes, and only if you got that representation from IpAddress::toInteger().

+
Parameters
+ + +
address4 bytes of the address packed into a 32-bits integer
+
+
+
See also
toInteger
+ +
+
+

Member Function Documentation

+ +

◆ getLocalAddress()

+ +
+
+ + + + + +
+ + + + + + + +
static IpAddress sf::IpAddress::getLocalAddress ()
+ 		+static
+
+ +

Get the computer's local address.

+

The local address is the address of the computer from the LAN point of view, i.e. something like 192.168.1.56. It is meaningful only for communications over the local network. Unlike getPublicAddress, this function is fast and may be used safely anywhere.

+
Returns
Local IP address of the computer
+
See also
getPublicAddress
+ +
+
+ +

◆ getPublicAddress()

+ +
+
+ + + + + +
+ + + + + + + + +
static IpAddress sf::IpAddress::getPublicAddress (Time timeout = Time::Zero)
+ 		+static
+
+ +

Get the computer's public address.

+

The public address is the address of the computer from the internet point of view, i.e. something like 89.54.1.169. It is necessary for communications over the world wide web. The only way to get a public address is to ask it to a distant website; as a consequence, this function depends on both your network connection and the server, and may be very slow. You should use it as few as possible. Because this function depends on the network connection and on a distant server, you may use a time limit if you don't want your program to be possibly stuck waiting in case there is a problem; this limit is deactivated by default.

+
Parameters
+ + +
timeoutMaximum time to wait
+
+
+
Returns
Public IP address of the computer
+
See also
getLocalAddress
+ +
+
+ +

◆ toInteger()

+ +
+
+ + + + + + + +
Uint32 sf::IpAddress::toInteger () const
+
+ +

Get an integer representation of the address.

+

The returned number is the internal representation of the address, and should be used for optimization purposes only (like sending the address through a socket). The integer produced by this function can then be converted back to a sf::IpAddress with the proper constructor.

+
Returns
32-bits unsigned integer representation of the address
+
See also
toString
+ +
+
+ +

◆ toString()

+ +
+
+ + + + + + + +
std::string sf::IpAddress::toString () const
+
+ +

Get a string representation of the address.

+

The returned string is the decimal representation of the IP address (like "192.168.1.56"), even if it was constructed from a host name.

+
Returns
String representation of the address
+
See also
toInteger
+ +
+
+

Friends And Related Function Documentation

+ +

◆ operator<

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator< (const IpAddress & left,
const IpAddress & right 
)
+ 		+friend
+
+ +

Overload of < operator to compare two IP addresses.

+
Parameters
+ + + +
leftLeft operand (a IP address)
rightRight operand (a IP address)
+
+
+
Returns
True if left is lesser than right
+ +
+
+

Member Data Documentation

+ +

◆ Any

+ +
+
+ + + + + +
+ + + + +
const IpAddress sf::IpAddress::Any
+ 		+static
+
+ +

Value representing any address (0.0.0.0)

+ +

Definition at line 185 of file IpAddress.hpp.

+ +
+
+ +

◆ Broadcast

+ +
+
+ + + + + +
+ + + + +
const IpAddress sf::IpAddress::Broadcast
+ 		+static
+
+ +

The "broadcast" address (for sending UDP messages to everyone on a local network)

+ +

Definition at line 187 of file IpAddress.hpp.

+ +
+
+ +

◆ LocalHost

+ +
+
+ + + + + +
+ + + + +
const IpAddress sf::IpAddress::LocalHost
+ 		+static
+
+ +

The "localhost" address (for connecting a computer to itself locally)

+ +

Definition at line 186 of file IpAddress.hpp.

+ +
+
+ +

◆ None

+ +
+
+ + + + + +
+ + + + +
const IpAddress sf::IpAddress::None
+ 		+static
+
+ +

Value representing an empty/invalid address.

+ +

Definition at line 184 of file IpAddress.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Joystick-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Joystick-members.html new file mode 100644 index 000000000..3a04cd185 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Joystick-members.html @@ -0,0 +1,127 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Joystick Member List
+
+
+ +

This is the complete list of members for sf::Joystick, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
Axis enum namesf::Joystick
AxisCount enum valuesf::Joystick
ButtonCount enum valuesf::Joystick
Count enum valuesf::Joystick
getAxisPosition(unsigned int joystick, Axis axis)sf::Joystickstatic
getButtonCount(unsigned int joystick)sf::Joystickstatic
getIdentification(unsigned int joystick)sf::Joystickstatic
hasAxis(unsigned int joystick, Axis axis)sf::Joystickstatic
isButtonPressed(unsigned int joystick, unsigned int button)sf::Joystickstatic
isConnected(unsigned int joystick)sf::Joystickstatic
PovX enum valuesf::Joystick
PovY enum valuesf::Joystick
R enum valuesf::Joystick
U enum valuesf::Joystick
update()sf::Joystickstatic
V enum valuesf::Joystick
X enum valuesf::Joystick
Y enum valuesf::Joystick
Z enum valuesf::Joystick
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Joystick.html b/Space-Invaders/sfml/doc/html/classsf_1_1Joystick.html new file mode 100644 index 000000000..11cdc5523 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Joystick.html @@ -0,0 +1,546 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Static Public Member Functions | +List of all members
+
sf::Joystick Class Reference
Window module
+
+
+ +

Give access to the real-time state of the joysticks. + More...

+ +

#include <SFML/Window/Joystick.hpp>

+ + + + + +

+Classes

struct  Identification
 Structure holding a joystick's identification. More...
 
+ + + + + + + +

+Public Types

enum  { Count = 8 +, ButtonCount = 32 +, AxisCount = 8 + }
 Constants related to joysticks capabilities. More...
 
enum  Axis {
+  X +, Y +, Z +, R +,
+  U +, V +, PovX +, PovY +
+ }
 Axes supported by SFML joysticks. More...
 
+ + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

static bool isConnected (unsigned int joystick)
 Check if a joystick is connected.
 
static unsigned int getButtonCount (unsigned int joystick)
 Return the number of buttons supported by a joystick.
 
static bool hasAxis (unsigned int joystick, Axis axis)
 Check if a joystick supports a given axis.
 
static bool isButtonPressed (unsigned int joystick, unsigned int button)
 Check if a joystick button is pressed.
 
static float getAxisPosition (unsigned int joystick, Axis axis)
 Get the current position of a joystick axis.
 
static Identification getIdentification (unsigned int joystick)
 Get the joystick information.
 
static void update ()
 Update the states of all joysticks.
 
+

Detailed Description

+

Give access to the real-time state of the joysticks.

+

sf::Joystick provides an interface to the state of the joysticks.

+

It only contains static functions, so it's not meant to be instantiated. Instead, each joystick is identified by an index that is passed to the functions of this class.

+

This class allows users to query the state of joysticks at any time and directly, without having to deal with a window and its events. Compared to the JoystickMoved, JoystickButtonPressed and JoystickButtonReleased events, sf::Joystick can retrieve the state of axes and buttons of joysticks at any time (you don't need to store and update a boolean on your side in order to know if a button is pressed or released), and you always get the real state of joysticks, even if they are moved, pressed or released when your window is out of focus and no event is triggered.

+

SFML supports:

+

Unlike the keyboard or mouse, the state of joysticks is sometimes not directly available (depending on the OS), therefore an update() function must be called in order to update the current state of joysticks. When you have a window with event handling, this is done automatically, you don't need to call anything. But if you have no window, or if you want to check joysticks state before creating one, you must call sf::Joystick::update explicitly.

+

Usage example:

// Is joystick #0 connected?
+
bool connected = sf::Joystick::isConnected(0);
+
+
// How many buttons does joystick #0 support?
+
unsigned int buttons = sf::Joystick::getButtonCount(0);
+
+
// Does joystick #0 define a X axis?
+
bool hasX = sf::Joystick::hasAxis(0, sf::Joystick::X);
+
+
// Is button #2 pressed on joystick #0?
+
bool pressed = sf::Joystick::isButtonPressed(0, 2);
+
+
// What's the current position of the Y axis on joystick #0?
+
float position = sf::Joystick::getAxisPosition(0, sf::Joystick::Y);
+
sf::Joystick::hasAxis
static bool hasAxis(unsigned int joystick, Axis axis)
Check if a joystick supports a given axis.
+
sf::Joystick::Y
@ Y
The Y axis.
Definition: Joystick.hpp:63
+
sf::Joystick::X
@ X
The X axis.
Definition: Joystick.hpp:62
+
sf::Joystick::getButtonCount
static unsigned int getButtonCount(unsigned int joystick)
Return the number of buttons supported by a joystick.
+
sf::Joystick::isConnected
static bool isConnected(unsigned int joystick)
Check if a joystick is connected.
+
sf::Joystick::isButtonPressed
static bool isButtonPressed(unsigned int joystick, unsigned int button)
Check if a joystick button is pressed.
+
sf::Joystick::getAxisPosition
static float getAxisPosition(unsigned int joystick, Axis axis)
Get the current position of a joystick axis.
+
See also
sf::Keyboard, sf::Mouse
+ +

Definition at line 41 of file Joystick.hpp.

+

Member Enumeration Documentation

+ +

◆ anonymous enum

+ +
+
+ + + + +
anonymous enum
+
+ +

Constants related to joysticks capabilities.

+ + + + +
Enumerator
Count 

Maximum number of supported joysticks.

+
ButtonCount 

Maximum number of supported buttons.

+
AxisCount 

Maximum number of supported axes.

+
+ +

Definition at line 49 of file Joystick.hpp.

+ +
+
+ +

◆ Axis

+ +
+
+ + + + +
enum sf::Joystick::Axis
+
+ +

Axes supported by SFML joysticks.

+ + + + + + + + + +
Enumerator
X 

The X axis.

+
Y 

The Y axis.

+
Z 

The Z axis.

+
R 

The R axis.

+
U 

The U axis.

+
V 

The V axis.

+
PovX 

The X axis of the point-of-view hat.

+
PovY 

The Y axis of the point-of-view hat.

+
+ +

Definition at line 60 of file Joystick.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ getAxisPosition()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static float sf::Joystick::getAxisPosition (unsigned int joystick,
Axis axis 
)
+ 		+static
+
+ +

Get the current position of a joystick axis.

+

If the joystick is not connected, this function returns 0.

+
Parameters
+ + + +
joystickIndex of the joystick
axisAxis to check
+
+
+
Returns
Current position of the axis, in range [-100 .. 100]
+ +
+
+ +

◆ getButtonCount()

+ +
+
+ + + + + +
+ + + + + + + + +
static unsigned int sf::Joystick::getButtonCount (unsigned int joystick)
+ 		+static
+
+ +

Return the number of buttons supported by a joystick.

+

If the joystick is not connected, this function returns 0.

+
Parameters
+ + +
joystickIndex of the joystick
+
+
+
Returns
Number of buttons supported by the joystick
+ +
+
+ +

◆ getIdentification()

+ +
+
+ + + + + +
+ + + + + + + + +
static Identification sf::Joystick::getIdentification (unsigned int joystick)
+ 		+static
+
+ +

Get the joystick information.

+
Parameters
+ + +
joystickIndex of the joystick
+
+
+
Returns
Structure containing joystick information.
+ +
+
+ +

◆ hasAxis()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool sf::Joystick::hasAxis (unsigned int joystick,
Axis axis 
)
+ 		+static
+
+ +

Check if a joystick supports a given axis.

+

If the joystick is not connected, this function returns false.

+
Parameters
+ + + +
joystickIndex of the joystick
axisAxis to check
+
+
+
Returns
True if the joystick supports the axis, false otherwise
+ +
+
+ +

◆ isButtonPressed()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static bool sf::Joystick::isButtonPressed (unsigned int joystick,
unsigned int button 
)
+ 		+static
+
+ +

Check if a joystick button is pressed.

+

If the joystick is not connected, this function returns false.

+
Parameters
+ + + +
joystickIndex of the joystick
buttonButton to check
+
+
+
Returns
True if the button is pressed, false otherwise
+ +
+
+ +

◆ isConnected()

+ +
+
+ + + + + +
+ + + + + + + + +
static bool sf::Joystick::isConnected (unsigned int joystick)
+ 		+static
+
+ +

Check if a joystick is connected.

+
Parameters
+ + +
joystickIndex of the joystick to check
+
+
+
Returns
True if the joystick is connected, false otherwise
+ +
+
+ +

◆ update()

+ +
+
+ + + + + +
+ + + + + + + +
static void sf::Joystick::update ()
+ 		+static
+
+ +

Update the states of all joysticks.

+

This function is used internally by SFML, so you normally don't have to call it explicitly. However, you may need to call it if you have no window yet (or no window at all): in this case the joystick states are not updated automatically.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Keyboard-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Keyboard-members.html new file mode 100644 index 000000000..2ccf07c74 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Keyboard-members.html @@ -0,0 +1,226 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Keyboard Member List
+
+
+ +

This is the complete list of members for sf::Keyboard, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
A enum valuesf::Keyboard
Add enum valuesf::Keyboard
Apostrophe enum valuesf::Keyboard
B enum valuesf::Keyboard
Backslash enum valuesf::Keyboard
BackSlash enum valuesf::Keyboard
Backspace enum valuesf::Keyboard
BackSpace enum valuesf::Keyboard
C enum valuesf::Keyboard
Comma enum valuesf::Keyboard
D enum valuesf::Keyboard
Dash enum valuesf::Keyboard
Delete enum valuesf::Keyboard
delocalize(Key key)sf::Keyboardstatic
Divide enum valuesf::Keyboard
Down enum valuesf::Keyboard
E enum valuesf::Keyboard
End enum valuesf::Keyboard
Enter enum valuesf::Keyboard
Equal enum valuesf::Keyboard
Escape enum valuesf::Keyboard
F enum valuesf::Keyboard
F1 enum valuesf::Keyboard
F10 enum valuesf::Keyboard
F11 enum valuesf::Keyboard
F12 enum valuesf::Keyboard
F13 enum valuesf::Keyboard
F14 enum valuesf::Keyboard
F15 enum valuesf::Keyboard
F2 enum valuesf::Keyboard
F3 enum valuesf::Keyboard
F4 enum valuesf::Keyboard
F5 enum valuesf::Keyboard
F6 enum valuesf::Keyboard
F7 enum valuesf::Keyboard
F8 enum valuesf::Keyboard
F9 enum valuesf::Keyboard
G enum valuesf::Keyboard
getDescription(Scancode code)sf::Keyboardstatic
Grave enum valuesf::Keyboard
H enum valuesf::Keyboard
Home enum valuesf::Keyboard
Hyphen enum valuesf::Keyboard
I enum valuesf::Keyboard
Insert enum valuesf::Keyboard
isKeyPressed(Key key)sf::Keyboardstatic
isKeyPressed(Scancode code)sf::Keyboardstatic
J enum valuesf::Keyboard
K enum valuesf::Keyboard
Key enum namesf::Keyboard
KeyCount enum valuesf::Keyboard
L enum valuesf::Keyboard
LAlt enum valuesf::Keyboard
LBracket enum valuesf::Keyboard
LControl enum valuesf::Keyboard
Left enum valuesf::Keyboard
localize(Scancode code)sf::Keyboardstatic
LShift enum valuesf::Keyboard
LSystem enum valuesf::Keyboard
M enum valuesf::Keyboard
Menu enum valuesf::Keyboard
Multiply enum valuesf::Keyboard
N enum valuesf::Keyboard
Num0 enum valuesf::Keyboard
Num1 enum valuesf::Keyboard
Num2 enum valuesf::Keyboard
Num3 enum valuesf::Keyboard
Num4 enum valuesf::Keyboard
Num5 enum valuesf::Keyboard
Num6 enum valuesf::Keyboard
Num7 enum valuesf::Keyboard
Num8 enum valuesf::Keyboard
Num9 enum valuesf::Keyboard
Numpad0 enum valuesf::Keyboard
Numpad1 enum valuesf::Keyboard
Numpad2 enum valuesf::Keyboard
Numpad3 enum valuesf::Keyboard
Numpad4 enum valuesf::Keyboard
Numpad5 enum valuesf::Keyboard
Numpad6 enum valuesf::Keyboard
Numpad7 enum valuesf::Keyboard
Numpad8 enum valuesf::Keyboard
Numpad9 enum valuesf::Keyboard
O enum valuesf::Keyboard
P enum valuesf::Keyboard
PageDown enum valuesf::Keyboard
PageUp enum valuesf::Keyboard
Pause enum valuesf::Keyboard
Period enum valuesf::Keyboard
Q enum valuesf::Keyboard
Quote enum valuesf::Keyboard
R enum valuesf::Keyboard
RAlt enum valuesf::Keyboard
RBracket enum valuesf::Keyboard
RControl enum valuesf::Keyboard
Return enum valuesf::Keyboard
Right enum valuesf::Keyboard
RShift enum valuesf::Keyboard
RSystem enum valuesf::Keyboard
S enum valuesf::Keyboard
Scancode typedef (defined in sf::Keyboard)sf::Keyboard
Semicolon enum valuesf::Keyboard
SemiColon enum valuesf::Keyboard
setVirtualKeyboardVisible(bool visible)sf::Keyboardstatic
Slash enum valuesf::Keyboard
Space enum valuesf::Keyboard
Subtract enum valuesf::Keyboard
T enum valuesf::Keyboard
Tab enum valuesf::Keyboard
Tilde enum valuesf::Keyboard
U enum valuesf::Keyboard
Unknown enum valuesf::Keyboard
Up enum valuesf::Keyboard
V enum valuesf::Keyboard
W enum valuesf::Keyboard
X enum valuesf::Keyboard
Y enum valuesf::Keyboard
Z enum valuesf::Keyboard
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Keyboard.html b/Space-Invaders/sfml/doc/html/classsf_1_1Keyboard.html new file mode 100644 index 000000000..5b8b43f2d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Keyboard.html @@ -0,0 +1,792 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Static Public Member Functions | +List of all members
+
sf::Keyboard Class Reference
Window module
+
+
+ +

Give access to the real-time state of the keyboard. + More...

+ +

#include <SFML/Window/Keyboard.hpp>

+ + + + + +

+Classes

struct  Scan
 Scancodes. More...
 
+ + + + + + +

+Public Types

enum  Key {
+  Unknown = -1 +, A = 0 +, B +, C +,
+  D +, E +, F +, G +,
+  H +, I +, J +, K +,
+  L +, M +, N +, O +,
+  P +, Q +, R +, S +,
+  T +, U +, V +, W +,
+  X +, Y +, Z +, Num0 +,
+  Num1 +, Num2 +, Num3 +, Num4 +,
+  Num5 +, Num6 +, Num7 +, Num8 +,
+  Num9 +, Escape +, LControl +, LShift +,
+  LAlt +, LSystem +, RControl +, RShift +,
+  RAlt +, RSystem +, Menu +, LBracket +,
+  RBracket +, Semicolon +, Comma +, Period +,
+  Apostrophe +, Slash +, Backslash +, Grave +,
+  Equal +, Hyphen +, Space +, Enter +,
+  Backspace +, Tab +, PageUp +, PageDown +,
+  End +, Home +, Insert +, Delete +,
+  Add +, Subtract +, Multiply +, Divide +,
+  Left +, Right +, Up +, Down +,
+  Numpad0 +, Numpad1 +, Numpad2 +, Numpad3 +,
+  Numpad4 +, Numpad5 +, Numpad6 +, Numpad7 +,
+  Numpad8 +, Numpad9 +, F1 +, F2 +,
+  F3 +, F4 +, F5 +, F6 +,
+  F7 +, F8 +, F9 +, F10 +,
+  F11 +, F12 +, F13 +, F14 +,
+  F15 +, Pause +, KeyCount +, Tilde = Grave +,
+  Dash = Hyphen +, BackSpace = Backspace +, BackSlash = Backslash +, SemiColon = Semicolon +,
+  Return = Enter +, Quote = Apostrophe +
+ }
 Key codes. More...
 
typedef Scan::Scancode Scancode
 
+ + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

static bool isKeyPressed (Key key)
 Check if a key is pressed.
 
static bool isKeyPressed (Scancode code)
 Check if a key is pressed.
 
static Key localize (Scancode code)
 Localize a physical key to a logical one.
 
static Scancode delocalize (Key key)
 Identify the physical key corresponding to a logical one.
 
static String getDescription (Scancode code)
 Provide a string representation for a given scancode.
 
static void setVirtualKeyboardVisible (bool visible)
 Show or hide the virtual keyboard.
 
+

Detailed Description

+

Give access to the real-time state of the keyboard.

+

sf::Keyboard provides an interface to the state of the keyboard.

+

It only contains static functions (a single keyboard is assumed), so it's not meant to be instantiated.

+

This class allows users to query the keyboard state at any time and directly, without having to deal with a window and its events. Compared to the KeyPressed and KeyReleased events, sf::Keyboard can retrieve the state of a key at any time (you don't need to store and update a boolean on your side in order to know if a key is pressed or released), and you always get the real state of the keyboard, even if keys are pressed or released when your window is out of focus and no event is triggered.

+

Usage example:

if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
+
{
+
// move left...
+
}
+
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
+
{
+
// move right...
+
}
+
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
+
{
+
// quit...
+
}
+
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Scan::Grave))
+
{
+
// open in-game command line (if it's not already open)
+
}
+
sf::Keyboard::isKeyPressed
static bool isKeyPressed(Key key)
Check if a key is pressed.
+
sf::Keyboard::Right
@ Right
Right arrow.
Definition: Keyboard.hpp:129
+
sf::Keyboard::Escape
@ Escape
The Escape key.
Definition: Keyboard.hpp:93
+
sf::Keyboard::Left
@ Left
Left arrow.
Definition: Keyboard.hpp:128
+
sf::Keyboard::Scan::Grave
@ Grave
Keyboard ` and ~ key.
Definition: Keyboard.hpp:246
+
See also
sf::Joystick, sf::Mouse, sf::Touch
+ +

Definition at line 42 of file Keyboard.hpp.

+

Member Typedef Documentation

+ +

◆ Scancode

+ +
+
+ + + + +
typedef Scan::Scancode sf::Keyboard::Scancode
+
+ +

Definition at line 356 of file Keyboard.hpp.

+ +
+
+

Member Enumeration Documentation

+ +

◆ Key

+ +
+
+ + + + +
enum sf::Keyboard::Key
+
+ +

Key codes.

+

The enumerators refer to the "localized" key; i.e. depending on the layout set by the operating system, a key can be mapped to Y or Z.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Enumerator
Unknown 

Unhandled key.

+
A 

The A key.

+
B 

The B key.

+
C 

The C key.

+
D 

The D key.

+
E 

The E key.

+
F 

The F key.

+
G 

The G key.

+
H 

The H key.

+
I 

The I key.

+
J 

The J key.

+
K 

The K key.

+
L 

The L key.

+
M 

The M key.

+
N 

The N key.

+
O 

The O key.

+
P 

The P key.

+
Q 

The Q key.

+
R 

The R key.

+
S 

The S key.

+
T 

The T key.

+
U 

The U key.

+
V 

The V key.

+
W 

The W key.

+
X 

The X key.

+
Y 

The Y key.

+
Z 

The Z key.

+
Num0 

The 0 key.

+
Num1 

The 1 key.

+
Num2 

The 2 key.

+
Num3 

The 3 key.

+
Num4 

The 4 key.

+
Num5 

The 5 key.

+
Num6 

The 6 key.

+
Num7 

The 7 key.

+
Num8 

The 8 key.

+
Num9 

The 9 key.

+
Escape 

The Escape key.

+
LControl 

The left Control key.

+
LShift 

The left Shift key.

+
LAlt 

The left Alt key.

+
LSystem 

The left OS specific key: window (Windows and Linux), apple (macOS), ...

+
RControl 

The right Control key.

+
RShift 

The right Shift key.

+
RAlt 

The right Alt key.

+
RSystem 

The right OS specific key: window (Windows and Linux), apple (macOS), ...

+
Menu 

The Menu key.

+
LBracket 

The [ key.

+
RBracket 

The ] key.

+
Semicolon 

The ; key.

+
Comma 

The , key.

+
Period 

The . key.

+
Apostrophe 

The ' key.

+
Slash 

The / key.

+
Backslash 

The \ key.

+
Grave 

The ` key.

+
Equal 

The = key.

+
Hyphen 

The - key (hyphen)

+
Space 

The Space key.

+
Enter 

The Enter/Return keys.

+
Backspace 

The Backspace key.

+
Tab 

The Tabulation key.

+
PageUp 

The Page up key.

+
PageDown 

The Page down key.

+
End 

The End key.

+
Home 

The Home key.

+
Insert 

The Insert key.

+
Delete 

The Delete key.

+
Add 

The + key.

+
Subtract 

The - key (minus, usually from numpad)

+
Multiply 

The * key.

+
Divide 

The / key.

+
Left 

Left arrow.

+
Right 

Right arrow.

+
Up 

Up arrow.

+
Down 

Down arrow.

+
Numpad0 

The numpad 0 key.

+
Numpad1 

The numpad 1 key.

+
Numpad2 

The numpad 2 key.

+
Numpad3 

The numpad 3 key.

+
Numpad4 

The numpad 4 key.

+
Numpad5 

The numpad 5 key.

+
Numpad6 

The numpad 6 key.

+
Numpad7 

The numpad 7 key.

+
Numpad8 

The numpad 8 key.

+
Numpad9 

The numpad 9 key.

+
F1 

The F1 key.

+
F2 

The F2 key.

+
F3 

The F3 key.

+
F4 

The F4 key.

+
F5 

The F5 key.

+
F6 

The F6 key.

+
F7 

The F7 key.

+
F8 

The F8 key.

+
F9 

The F9 key.

+
F10 

The F10 key.

+
F11 

The F11 key.

+
F12 

The F12 key.

+
F13 

The F13 key.

+
F14 

The F14 key.

+
F15 

The F15 key.

+
Pause 

The Pause key.

+
KeyCount 

Keep last – the total number of keyboard keys.

+
Tilde 
Deprecated:
Use Grave instead
+
Dash 
Deprecated:
Use Hyphen instead
+
BackSpace 
Deprecated:
Use Backspace instead
+
BackSlash 
Deprecated:
Use Backslash instead
+
SemiColon 
Deprecated:
Use Semicolon instead
+
Return 
Deprecated:
Use Enter instead
+
Quote 
Deprecated:
Use Apostrophe instead
+
+ +

Definition at line 54 of file Keyboard.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ delocalize()

+ +
+
+ + + + + +
+ + + + + + + + +
static Scancode sf::Keyboard::delocalize (Key key)
+ 		+static
+
+ +

Identify the physical key corresponding to a logical one.

+
Parameters
+ + +
keyKey to "delocalize"
+
+
+
Returns
The scancode corresponding to the key under the current keyboard layout used by the operating system, or sf::Keyboard::Scan::Unknown when the key cannot be mapped to a sf::Keyboard::Scancode.
+
See also
localize
+ +
+
+ +

◆ getDescription()

+ +
+
+ + + + + +
+ + + + + + + + +
static String sf::Keyboard::getDescription (Scancode code)
+ 		+static
+
+ +

Provide a string representation for a given scancode.

+

The returned string is a short, non-technical description of the key represented with the given scancode. Most effectively used in user interfaces, as the description for the key takes the users keyboard layout into consideration.

+
Warning
The result is OS-dependent: for example, sf::Keyboard::Scan::LSystem is "Left Meta" on Linux, "Left Windows" on Windows and "Left Command" on macOS.
+

The current keyboard layout set by the operating system is used to interpret the scancode: for example, sf::Keyboard::Semicolon is mapped to ";" for layout and to "é" for others.

+
Returns
The localized description of the code
+ +
+
+ +

◆ isKeyPressed() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
static bool sf::Keyboard::isKeyPressed (Key key)
+ 		+static
+
+ +

Check if a key is pressed.

+
Parameters
+ + +
keyKey to check
+
+
+
Returns
True if the key is pressed, false otherwise
+ +
+
+ +

◆ isKeyPressed() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
static bool sf::Keyboard::isKeyPressed (Scancode code)
+ 		+static
+
+ +

Check if a key is pressed.

+
Parameters
+ + +
codeScancode to check
+
+
+
Returns
True if the physical key is pressed, false otherwise
+ +
+
+ +

◆ localize()

+ +
+
+ + + + + +
+ + + + + + + + +
static Key sf::Keyboard::localize (Scancode code)
+ 		+static
+
+ +

Localize a physical key to a logical one.

+
Parameters
+ + +
codeScancode to localize
+
+
+
Returns
The key corresponding to the scancode under the current keyboard layout used by the operating system, or sf::Keyboard::Unknown when the scancode cannot be mapped to a Key.
+
See also
delocalize
+ +
+
+ +

◆ setVirtualKeyboardVisible()

+ +
+
+ + + + + +
+ + + + + + + + +
static void sf::Keyboard::setVirtualKeyboardVisible (bool visible)
+ 		+static
+
+ +

Show or hide the virtual keyboard.

+
Warning
The virtual keyboard is not supported on all systems. It will typically be implemented on mobile OSes (Android, iOS) but not on desktop OSes (Windows, Linux, ...).
+

If the virtual keyboard is not available, this function does nothing.

+
Parameters
+ + +
visibleTrue to show, false to hide
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Listener-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Listener-members.html new file mode 100644 index 000000000..e4d47608a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Listener-members.html @@ -0,0 +1,119 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Listener Member List
+
+
+ +

This is the complete list of members for sf::Listener, including all inherited members.

+ + + + + + + + + + + + +
getDirection()sf::Listenerstatic
getGlobalVolume()sf::Listenerstatic
getPosition()sf::Listenerstatic
getUpVector()sf::Listenerstatic
setDirection(float x, float y, float z)sf::Listenerstatic
setDirection(const Vector3f &direction)sf::Listenerstatic
setGlobalVolume(float volume)sf::Listenerstatic
setPosition(float x, float y, float z)sf::Listenerstatic
setPosition(const Vector3f &position)sf::Listenerstatic
setUpVector(float x, float y, float z)sf::Listenerstatic
setUpVector(const Vector3f &upVector)sf::Listenerstatic
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Listener.html b/Space-Invaders/sfml/doc/html/classsf_1_1Listener.html new file mode 100644 index 000000000..3824a8fef --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Listener.html @@ -0,0 +1,595 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +List of all members
+
sf::Listener Class Reference
Audio module
+
+
+ +

The audio listener is the point in the scene from where all the sounds are heard. + More...

+ +

#include <SFML/Audio/Listener.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

static void setGlobalVolume (float volume)
 Change the global volume of all the sounds and musics.
 
static float getGlobalVolume ()
 Get the current value of the global volume.
 
static void setPosition (float x, float y, float z)
 Set the position of the listener in the scene.
 
static void setPosition (const Vector3f &position)
 Set the position of the listener in the scene.
 
static Vector3f getPosition ()
 Get the current position of the listener in the scene.
 
static void setDirection (float x, float y, float z)
 Set the forward vector of the listener in the scene.
 
static void setDirection (const Vector3f &direction)
 Set the forward vector of the listener in the scene.
 
static Vector3f getDirection ()
 Get the current forward vector of the listener in the scene.
 
static void setUpVector (float x, float y, float z)
 Set the upward vector of the listener in the scene.
 
static void setUpVector (const Vector3f &upVector)
 Set the upward vector of the listener in the scene.
 
static Vector3f getUpVector ()
 Get the current upward vector of the listener in the scene.
 
+

Detailed Description

+

The audio listener is the point in the scene from where all the sounds are heard.

+

The audio listener defines the global properties of the audio environment, it defines where and how sounds and musics are heard.

+

If sf::View is the eyes of the user, then sf::Listener is his ears (by the way, they are often linked together – same position, orientation, etc.).

+

sf::Listener is a simple interface, which allows to setup the listener in the 3D audio environment (position, direction and up vector), and to adjust the global volume.

+

Because the listener is unique in the scene, sf::Listener only contains static functions and doesn't have to be instantiated.

+

Usage example:

// Move the listener to the position (1, 0, -5)
+
sf::Listener::setPosition(1, 0, -5);
+
+
// Make it face the right axis (1, 0, 0)
+
sf::Listener::setDirection(1, 0, 0);
+
+
// Reduce the global volume
+
sf::Listener::setGlobalVolume(50);
+
sf::Listener::setPosition
static void setPosition(float x, float y, float z)
Set the position of the listener in the scene.
+
sf::Listener::setGlobalVolume
static void setGlobalVolume(float volume)
Change the global volume of all the sounds and musics.
+
sf::Listener::setDirection
static void setDirection(float x, float y, float z)
Set the forward vector of the listener in the scene.
+
+

Definition at line 42 of file Listener.hpp.

+

Member Function Documentation

+ +

◆ getDirection()

+ +
+
+ + + + + +
+ + + + + + + +
static Vector3f sf::Listener::getDirection ()
+ 		+static
+
+ +

Get the current forward vector of the listener in the scene.

+
Returns
Listener's forward vector (not normalized)
+
See also
setDirection
+ +
+
+ +

◆ getGlobalVolume()

+ +
+
+ + + + + +
+ + + + + + + +
static float sf::Listener::getGlobalVolume ()
+ 		+static
+
+ +

Get the current value of the global volume.

+
Returns
Current global volume, in the range [0, 100]
+
See also
setGlobalVolume
+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
static Vector3f sf::Listener::getPosition ()
+ 		+static
+
+ +

Get the current position of the listener in the scene.

+
Returns
Listener's position
+
See also
setPosition
+ +
+
+ +

◆ getUpVector()

+ +
+
+ + + + + +
+ + + + + + + +
static Vector3f sf::Listener::getUpVector ()
+ 		+static
+
+ +

Get the current upward vector of the listener in the scene.

+
Returns
Listener's upward vector (not normalized)
+
See also
setUpVector
+ +
+
+ +

◆ setDirection() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
static void sf::Listener::setDirection (const Vector3f & direction)
+ 		+static
+
+ +

Set the forward vector of the listener in the scene.

+

The direction (also called "at vector") is the vector pointing forward from the listener's perspective. Together with the up vector, it defines the 3D orientation of the listener in the scene. The direction vector doesn't have to be normalized. The default listener's direction is (0, 0, -1).

+
Parameters
+ + +
directionNew listener's direction
+
+
+
See also
getDirection, setUpVector, setPosition
+ +
+
+ +

◆ setDirection() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void sf::Listener::setDirection (float x,
float y,
float z 
)
+ 		+static
+
+ +

Set the forward vector of the listener in the scene.

+

The direction (also called "at vector") is the vector pointing forward from the listener's perspective. Together with the up vector, it defines the 3D orientation of the listener in the scene. The direction vector doesn't have to be normalized. The default listener's direction is (0, 0, -1).

+
Parameters
+ + + + +
xX coordinate of the listener's direction
yY coordinate of the listener's direction
zZ coordinate of the listener's direction
+
+
+
See also
getDirection, setUpVector, setPosition
+ +
+
+ +

◆ setGlobalVolume()

+ +
+
+ + + + + +
+ + + + + + + + +
static void sf::Listener::setGlobalVolume (float volume)
+ 		+static
+
+ +

Change the global volume of all the sounds and musics.

+

The volume is a number between 0 and 100; it is combined with the individual volume of each sound / music. The default value for the volume is 100 (maximum).

+
Parameters
+ + +
volumeNew global volume, in the range [0, 100]
+
+
+
See also
getGlobalVolume
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
static void sf::Listener::setPosition (const Vector3f & position)
+ 		+static
+
+ +

Set the position of the listener in the scene.

+

The default listener's position is (0, 0, 0).

+
Parameters
+ + +
positionNew listener's position
+
+
+
See also
getPosition, setDirection
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void sf::Listener::setPosition (float x,
float y,
float z 
)
+ 		+static
+
+ +

Set the position of the listener in the scene.

+

The default listener's position is (0, 0, 0).

+
Parameters
+ + + + +
xX coordinate of the listener's position
yY coordinate of the listener's position
zZ coordinate of the listener's position
+
+
+
See also
getPosition, setDirection
+ +
+
+ +

◆ setUpVector() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
static void sf::Listener::setUpVector (const Vector3f & upVector)
+ 		+static
+
+ +

Set the upward vector of the listener in the scene.

+

The up vector is the vector that points upward from the listener's perspective. Together with the direction, it defines the 3D orientation of the listener in the scene. The up vector doesn't have to be normalized. The default listener's up vector is (0, 1, 0). It is usually not necessary to change it, especially in 2D scenarios.

+
Parameters
+ + +
upVectorNew listener's up vector
+
+
+
See also
getUpVector, setDirection, setPosition
+ +
+
+ +

◆ setUpVector() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static void sf::Listener::setUpVector (float x,
float y,
float z 
)
+ 		+static
+
+ +

Set the upward vector of the listener in the scene.

+

The up vector is the vector that points upward from the listener's perspective. Together with the direction, it defines the 3D orientation of the listener in the scene. The up vector doesn't have to be normalized. The default listener's up vector is (0, 1, 0). It is usually not necessary to change it, especially in 2D scenarios.

+
Parameters
+ + + + +
xX coordinate of the listener's up vector
yY coordinate of the listener's up vector
zZ coordinate of the listener's up vector
+
+
+
See also
getUpVector, setDirection, setPosition
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Lock-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Lock-members.html new file mode 100644 index 000000000..ee46e3401 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Lock-members.html @@ -0,0 +1,110 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Lock Member List
+
+
+ +

This is the complete list of members for sf::Lock, including all inherited members.

+ + + +
Lock(Mutex &mutex)sf::Lockexplicit
~Lock()sf::Lock
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Lock.html b/Space-Invaders/sfml/doc/html/classsf_1_1Lock.html new file mode 100644 index 000000000..9fb7c09fd --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Lock.html @@ -0,0 +1,227 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::Lock Class Reference
System module
+
+
+ +

Automatic wrapper for locking and unlocking mutexes. + More...

+ +

#include <SFML/System/Lock.hpp>

+
+Inheritance diagram for sf::Lock:
+
+
+ + +sf::NonCopyable + +
+ + + + + + + + +

+Public Member Functions

 Lock (Mutex &mutex)
 Construct the lock with a target mutex.
 
 ~Lock ()
 Destructor.
 
+

Detailed Description

+

Automatic wrapper for locking and unlocking mutexes.

+

sf::Lock is a RAII wrapper for sf::Mutex.

+

By unlocking it in its destructor, it ensures that the mutex will always be released when the current scope (most likely a function) ends. This is even more important when an exception or an early return statement can interrupt the execution flow of the function.

+

For maximum robustness, sf::Lock should always be used to lock/unlock a mutex.

+

Usage example:

sf::Mutex mutex;
+
+
void function()
+
{
+
sf::Lock lock(mutex); // mutex is now locked
+
+
functionThatMayThrowAnException(); // mutex is unlocked if this function throws
+
+
if (someCondition)
+
return; // mutex is unlocked
+
+
} // mutex is unlocked
+
sf::Lock
Automatic wrapper for locking and unlocking mutexes.
Definition: Lock.hpp:44
+
sf::Mutex
Blocks concurrent access to shared resources from multiple threads.
Definition: Mutex.hpp:48
+

Because the mutex is not explicitly unlocked in the code, it may remain locked longer than needed. If the region of the code that needs to be protected by the mutex is not the entire function, a good practice is to create a smaller, inner scope so that the lock is limited to this part of the code.

+
sf::Mutex mutex;
+
+
void function()
+
{
+
{
+
sf::Lock lock(mutex);
+
codeThatRequiresProtection();
+
+
} // mutex is unlocked here
+
+
codeThatDoesntCareAboutTheMutex();
+
}
+

Having a mutex locked longer than required is a bad practice which can lead to bad performances. Don't forget that when a mutex is locked, other threads may be waiting doing nothing until it is released.

+
See also
sf::Mutex
+ +

Definition at line 43 of file Lock.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Lock()

+ +
+
+ + + + + +
+ + + + + + + + +
sf::Lock::Lock (Mutex & mutex)
+ 		+explicit
+
+ +

Construct the lock with a target mutex.

+

The mutex passed to sf::Lock is automatically locked.

+
Parameters
+ + +
mutexMutex to lock
+
+
+ +
+
+ +

◆ ~Lock()

+ +
+
+ + + + + + + +
sf::Lock::~Lock ()
+
+ +

Destructor.

+

The destructor of sf::Lock automatically unlocks its mutex.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Lock.png b/Space-Invaders/sfml/doc/html/classsf_1_1Lock.png new file mode 100644 index 000000000..ee69f2e4c Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Lock.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1MemoryInputStream-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1MemoryInputStream-members.html new file mode 100644 index 000000000..0cf7c33ff --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1MemoryInputStream-members.html @@ -0,0 +1,115 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::MemoryInputStream Member List
+
+
+ +

This is the complete list of members for sf::MemoryInputStream, including all inherited members.

+ + + + + + + + +
getSize()sf::MemoryInputStreamvirtual
MemoryInputStream()sf::MemoryInputStream
open(const void *data, std::size_t sizeInBytes)sf::MemoryInputStream
read(void *data, Int64 size)sf::MemoryInputStreamvirtual
seek(Int64 position)sf::MemoryInputStreamvirtual
tell()sf::MemoryInputStreamvirtual
~InputStream()sf::InputStreaminlinevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1MemoryInputStream.html b/Space-Invaders/sfml/doc/html/classsf_1_1MemoryInputStream.html new file mode 100644 index 000000000..7ca7fb38c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1MemoryInputStream.html @@ -0,0 +1,368 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::MemoryInputStream Class Reference
System module
+
+
+ +

Implementation of input stream based on a memory chunk. + More...

+ +

#include <SFML/System/MemoryInputStream.hpp>

+
+Inheritance diagram for sf::MemoryInputStream:
+
+
+ + +sf::InputStream + +
+ + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 MemoryInputStream ()
 Default constructor.
 
void open (const void *data, std::size_t sizeInBytes)
 Open the stream from its data.
 
virtual Int64 read (void *data, Int64 size)
 Read data from the stream.
 
virtual Int64 seek (Int64 position)
 Change the current reading position.
 
virtual Int64 tell ()
 Get the current reading position in the stream.
 
virtual Int64 getSize ()
 Return the size of the stream.
 
+

Detailed Description

+

Implementation of input stream based on a memory chunk.

+

This class is a specialization of InputStream that reads from data in memory.

+

It wraps a memory chunk in the common InputStream interface and therefore allows to use generic classes or functions that accept such a stream, with content already loaded in memory.

+

In addition to the virtual functions inherited from InputStream, MemoryInputStream adds a function to specify the pointer and size of the data in memory.

+

SFML resource classes can usually be loaded directly from memory, so this class shouldn't be useful to you unless you create your own algorithms that operate on an InputStream.

+

Usage example:

void process(InputStream& stream);
+
+
MemoryInputStream stream;
+
stream.open(thePtr, theSize);
+
process(stream);
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::MemoryInputStream
Implementation of input stream based on a memory chunk.
Definition: MemoryInputStream.hpp:44
+
sf::MemoryInputStream::open
void open(const void *data, std::size_t sizeInBytes)
Open the stream from its data.
+

InputStream, FileInputStream

+ +

Definition at line 43 of file MemoryInputStream.hpp.

+

Constructor & Destructor Documentation

+ +

◆ MemoryInputStream()

+ +
+
+ + + + + + + +
sf::MemoryInputStream::MemoryInputStream ()
+
+ +

Default constructor.

+ +
+
+

Member Function Documentation

+ +

◆ getSize()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Int64 sf::MemoryInputStream::getSize ()
+ 		+virtual
+
+ +

Return the size of the stream.

+
Returns
The total number of bytes available in the stream, or -1 on error
+ +

Implements sf::InputStream.

+ +
+
+ +

◆ open()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::MemoryInputStream::open (const void * data,
std::size_t sizeInBytes 
)
+
+ +

Open the stream from its data.

+
Parameters
+ + + +
dataPointer to the data in memory
sizeInBytesSize of the data, in bytes
+
+
+ +
+
+ +

◆ read()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual Int64 sf::MemoryInputStream::read (void * data,
Int64 size 
)
+ 		+virtual
+
+ +

Read data from the stream.

+

After reading, the stream's reading position must be advanced by the amount of bytes read.

+
Parameters
+ + + +
dataBuffer where to copy the read data
sizeDesired number of bytes to read
+
+
+
Returns
The number of bytes actually read, or -1 on error
+ +

Implements sf::InputStream.

+ +
+
+ +

◆ seek()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual Int64 sf::MemoryInputStream::seek (Int64 position)
+ 		+virtual
+
+ +

Change the current reading position.

+
Parameters
+ + +
positionThe position to seek to, from the beginning
+
+
+
Returns
The position actually sought to, or -1 on error
+ +

Implements sf::InputStream.

+ +
+
+ +

◆ tell()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Int64 sf::MemoryInputStream::tell ()
+ 		+virtual
+
+ +

Get the current reading position in the stream.

+
Returns
The current position, or -1 on error.
+ +

Implements sf::InputStream.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1MemoryInputStream.png b/Space-Invaders/sfml/doc/html/classsf_1_1MemoryInputStream.png new file mode 100644 index 000000000..156b5077d Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1MemoryInputStream.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Mouse-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Mouse-members.html new file mode 100644 index 000000000..1d4d3ac58 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Mouse-members.html @@ -0,0 +1,123 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Mouse Member List
+
+
+ +

This is the complete list of members for sf::Mouse, including all inherited members.

+ + + + + + + + + + + + + + + + +
Button enum namesf::Mouse
ButtonCount enum valuesf::Mouse
getPosition()sf::Mousestatic
getPosition(const WindowBase &relativeTo)sf::Mousestatic
HorizontalWheel enum valuesf::Mouse
isButtonPressed(Button button)sf::Mousestatic
Left enum valuesf::Mouse
Middle enum valuesf::Mouse
Right enum valuesf::Mouse
setPosition(const Vector2i &position)sf::Mousestatic
setPosition(const Vector2i &position, const WindowBase &relativeTo)sf::Mousestatic
VerticalWheel enum valuesf::Mouse
Wheel enum namesf::Mouse
XButton1 enum valuesf::Mouse
XButton2 enum valuesf::Mouse
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Mouse.html b/Space-Invaders/sfml/doc/html/classsf_1_1Mouse.html new file mode 100644 index 000000000..a82b64c09 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Mouse.html @@ -0,0 +1,420 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Static Public Member Functions | +List of all members
+
sf::Mouse Class Reference
Window module
+
+
+ +

Give access to the real-time state of the mouse. + More...

+ +

#include <SFML/Window/Mouse.hpp>

+ + + + + + + + +

+Public Types

enum  Button {
+  Left +, Right +, Middle +, XButton1 +,
+  XButton2 +, ButtonCount +
+ }
 Mouse buttons. More...
 
enum  Wheel { VerticalWheel +, HorizontalWheel + }
 Mouse wheels. More...
 
+ + + + + + + + + + + + + + + + +

+Static Public Member Functions

static bool isButtonPressed (Button button)
 Check if a mouse button is pressed.
 
static Vector2i getPosition ()
 Get the current position of the mouse in desktop coordinates.
 
static Vector2i getPosition (const WindowBase &relativeTo)
 Get the current position of the mouse in window coordinates.
 
static void setPosition (const Vector2i &position)
 Set the current position of the mouse in desktop coordinates.
 
static void setPosition (const Vector2i &position, const WindowBase &relativeTo)
 Set the current position of the mouse in window coordinates.
 
+

Detailed Description

+

Give access to the real-time state of the mouse.

+

sf::Mouse provides an interface to the state of the mouse.

+

It only contains static functions (a single mouse is assumed), so it's not meant to be instantiated.

+

This class allows users to query the mouse state at any time and directly, without having to deal with a window and its events. Compared to the MouseMoved, MouseButtonPressed and MouseButtonReleased events, sf::Mouse can retrieve the state of the cursor and the buttons at any time (you don't need to store and update a boolean on your side in order to know if a button is pressed or released), and you always get the real state of the mouse, even if it is moved, pressed or released when your window is out of focus and no event is triggered.

+

The setPosition and getPosition functions can be used to change or retrieve the current position of the mouse pointer. There are two versions: one that operates in global coordinates (relative to the desktop) and one that operates in window coordinates (relative to a specific window).

+

Usage example:

if (sf::Mouse::isButtonPressed(sf::Mouse::Left))
+
{
+
// left click...
+
}
+
+
// get global mouse position
+
sf::Vector2i position = sf::Mouse::getPosition();
+
+
// set mouse position relative to a window
+
sf::Mouse::setPosition(sf::Vector2i(100, 200), window);
+
sf::Mouse::setPosition
static void setPosition(const Vector2i &position)
Set the current position of the mouse in desktop coordinates.
+
sf::Mouse::Left
@ Left
The left mouse button.
Definition: Mouse.hpp:53
+
sf::Mouse::isButtonPressed
static bool isButtonPressed(Button button)
Check if a mouse button is pressed.
+
sf::Mouse::getPosition
static Vector2i getPosition()
Get the current position of the mouse in desktop coordinates.
+
sf::Vector2
Utility template class for manipulating 2-dimensional vectors.
Definition: Vector2.hpp:38
+
See also
sf::Joystick, sf::Keyboard, sf::Touch
+ +

Definition at line 43 of file Mouse.hpp.

+

Member Enumeration Documentation

+ +

◆ Button

+ +
+
+ + + + +
enum sf::Mouse::Button
+
+ +

Mouse buttons.

+ + + + + + + +
Enumerator
Left 

The left mouse button.

+
Right 

The right mouse button.

+
Middle 

The middle (wheel) mouse button.

+
XButton1 

The first extra mouse button.

+
XButton2 

The second extra mouse button.

+
ButtonCount 

Keep last – the total number of mouse buttons.

+
+ +

Definition at line 51 of file Mouse.hpp.

+ +
+
+ +

◆ Wheel

+ +
+
+ + + + +
enum sf::Mouse::Wheel
+
+ +

Mouse wheels.

+ + + +
Enumerator
VerticalWheel 

The vertical mouse wheel.

+
HorizontalWheel 

The horizontal mouse wheel.

+
+ +

Definition at line 66 of file Mouse.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ getPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
static Vector2i sf::Mouse::getPosition ()
+ 		+static
+
+ +

Get the current position of the mouse in desktop coordinates.

+

This function returns the global position of the mouse cursor on the desktop.

+
Returns
Current position of the mouse
+ +
+
+ +

◆ getPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
static Vector2i sf::Mouse::getPosition (const WindowBase & relativeTo)
+ 		+static
+
+ +

Get the current position of the mouse in window coordinates.

+

This function returns the current position of the mouse cursor, relative to the given window.

+
Parameters
+ + +
relativeToReference window
+
+
+
Returns
Current position of the mouse
+ +
+
+ +

◆ isButtonPressed()

+ +
+
+ + + + + +
+ + + + + + + + +
static bool sf::Mouse::isButtonPressed (Button button)
+ 		+static
+
+ +

Check if a mouse button is pressed.

+
Warning
Checking the state of buttons Mouse::XButton1 and Mouse::XButton2 is not supported on Linux with X11.
+
Parameters
+ + +
buttonButton to check
+
+
+
Returns
True if the button is pressed, false otherwise
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
static void sf::Mouse::setPosition (const Vector2i & position)
+ 		+static
+
+ +

Set the current position of the mouse in desktop coordinates.

+

This function sets the global position of the mouse cursor on the desktop.

+
Parameters
+ + +
positionNew position of the mouse
+
+
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void sf::Mouse::setPosition (const Vector2i & position,
const WindowBase & relativeTo 
)
+ 		+static
+
+ +

Set the current position of the mouse in window coordinates.

+

This function sets the current position of the mouse cursor, relative to the given window.

+
Parameters
+ + + +
positionNew position of the mouse
relativeToReference window
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Music-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Music-members.html new file mode 100644 index 000000000..828c816d5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Music-members.html @@ -0,0 +1,157 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Music Member List
+
+
+ +

This is the complete list of members for sf::Music, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
getAttenuation() constsf::SoundSource
getChannelCount() constsf::SoundStream
getDuration() constsf::Music
getLoop() constsf::SoundStream
getLoopPoints() constsf::Music
getMinDistance() constsf::SoundSource
getPitch() constsf::SoundSource
getPlayingOffset() constsf::SoundStream
getPosition() constsf::SoundSource
getSampleRate() constsf::SoundStream
getStatus() constsf::SoundStreamvirtual
getVolume() constsf::SoundSource
sf::SoundStream::initialize(unsigned int channelCount, unsigned int sampleRate)sf::SoundStreamprotected
isRelativeToListener() constsf::SoundSource
m_sourcesf::SoundSourceprotected
Music()sf::Music
NoLoop enum valuesf::SoundStreamprotected
onGetData(Chunk &data)sf::Musicprotectedvirtual
onLoop()sf::Musicprotectedvirtual
onSeek(Time timeOffset)sf::Musicprotectedvirtual
openFromFile(const std::string &filename)sf::Music
openFromMemory(const void *data, std::size_t sizeInBytes)sf::Music
openFromStream(InputStream &stream)sf::Music
operator=(const SoundSource &right)sf::SoundSource
pause()sf::SoundStreamvirtual
Paused enum valuesf::SoundSource
play()sf::SoundStreamvirtual
Playing enum valuesf::SoundSource
setAttenuation(float attenuation)sf::SoundSource
setLoop(bool loop)sf::SoundStream
setLoopPoints(TimeSpan timePoints)sf::Music
setMinDistance(float distance)sf::SoundSource
setPitch(float pitch)sf::SoundSource
setPlayingOffset(Time timeOffset)sf::SoundStream
setPosition(float x, float y, float z)sf::SoundSource
setPosition(const Vector3f &position)sf::SoundSource
setProcessingInterval(Time interval)sf::SoundStreamprotected
setRelativeToListener(bool relative)sf::SoundSource
setVolume(float volume)sf::SoundSource
SoundSource(const SoundSource &copy)sf::SoundSource
SoundSource()sf::SoundSourceprotected
SoundStream()sf::SoundStreamprotected
Status enum namesf::SoundSource
stop()sf::SoundStreamvirtual
Stopped enum valuesf::SoundSource
TimeSpan typedef (defined in sf::Music)sf::Music
~Music()sf::Music
~SoundSource()sf::SoundSourcevirtual
~SoundStream()sf::SoundStreamvirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Music.html b/Space-Invaders/sfml/doc/html/classsf_1_1Music.html new file mode 100644 index 000000000..607246a43 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Music.html @@ -0,0 +1,1570 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +Protected Types | +Protected Member Functions | +Protected Attributes | +List of all members
+
sf::Music Class Reference
Audio module
+
+
+ +

Streamed music played from an audio file. + More...

+ +

#include <SFML/Audio/Music.hpp>

+
+Inheritance diagram for sf::Music:
+
+
+ + +sf::SoundStream +sf::SoundSource +sf::AlResource + +
+ + + + + +

+Classes

struct  Span
 Structure defining a time range using the template type. More...
 
+ + + + + + +

+Public Types

typedef Span< Time > TimeSpan
 
enum  Status { Stopped +, Paused +, Playing + }
 Enumeration of the sound source states. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Music ()
 Default constructor.
 
 ~Music ()
 Destructor.
 
bool openFromFile (const std::string &filename)
 Open a music from an audio file.
 
bool openFromMemory (const void *data, std::size_t sizeInBytes)
 Open a music from an audio file in memory.
 
bool openFromStream (InputStream &stream)
 Open a music from an audio file in a custom stream.
 
Time getDuration () const
 Get the total duration of the music.
 
TimeSpan getLoopPoints () const
 Get the positions of the of the sound's looping sequence.
 
void setLoopPoints (TimeSpan timePoints)
 Sets the beginning and duration of the sound's looping sequence using sf::Time.
 
void play ()
 Start or resume playing the audio stream.
 
void pause ()
 Pause the audio stream.
 
void stop ()
 Stop playing the audio stream.
 
unsigned int getChannelCount () const
 Return the number of channels of the stream.
 
unsigned int getSampleRate () const
 Get the stream sample rate of the stream.
 
Status getStatus () const
 Get the current status of the stream (stopped, paused, playing)
 
void setPlayingOffset (Time timeOffset)
 Change the current playing position of the stream.
 
Time getPlayingOffset () const
 Get the current playing position of the stream.
 
void setLoop (bool loop)
 Set whether or not the stream should loop after reaching the end.
 
bool getLoop () const
 Tell whether or not the stream is in loop mode.
 
void setPitch (float pitch)
 Set the pitch of the sound.
 
void setVolume (float volume)
 Set the volume of the sound.
 
void setPosition (float x, float y, float z)
 Set the 3D position of the sound in the audio scene.
 
void setPosition (const Vector3f &position)
 Set the 3D position of the sound in the audio scene.
 
void setRelativeToListener (bool relative)
 Make the sound's position relative to the listener or absolute.
 
void setMinDistance (float distance)
 Set the minimum distance of the sound.
 
void setAttenuation (float attenuation)
 Set the attenuation factor of the sound.
 
float getPitch () const
 Get the pitch of the sound.
 
float getVolume () const
 Get the volume of the sound.
 
Vector3f getPosition () const
 Get the 3D position of the sound in the audio scene.
 
bool isRelativeToListener () const
 Tell whether the sound's position is relative to the listener or is absolute.
 
float getMinDistance () const
 Get the minimum distance of the sound.
 
float getAttenuation () const
 Get the attenuation factor of the sound.
 
+ + + +

+Protected Types

enum  { NoLoop = -1 + }
 
+ + + + + + + + + + + + + + + + +

+Protected Member Functions

virtual bool onGetData (Chunk &data)
 Request a new chunk of audio samples from the stream source.
 
virtual void onSeek (Time timeOffset)
 Change the current playing position in the stream source.
 
virtual Int64 onLoop ()
 Change the current playing position in the stream source to the loop offset.
 
void initialize (unsigned int channelCount, unsigned int sampleRate)
 Define the audio stream parameters.
 
void setProcessingInterval (Time interval)
 Set the processing interval.
 
+ + + + +

+Protected Attributes

unsigned int m_source
 OpenAL source identifier.
 
+

Detailed Description

+

Streamed music played from an audio file.

+

Musics are sounds that are streamed rather than completely loaded in memory.

+

This is especially useful for compressed musics that usually take hundreds of MB when they are uncompressed: by streaming it instead of loading it entirely, you avoid saturating the memory and have almost no loading delay. This implies that the underlying resource (file, stream or memory buffer) must remain valid for the lifetime of the sf::Music object.

+

Apart from that, a sf::Music has almost the same features as the sf::SoundBuffer / sf::Sound pair: you can play/pause/stop it, request its parameters (channels, sample rate), change the way it is played (pitch, volume, 3D position, ...), etc.

+

As a sound stream, a music is played in its own thread in order not to block the rest of the program. This means that you can leave the music alone after calling play(), it will manage itself very well.

+

Usage example:

// Declare a new music
+
sf::Music music;
+
+
// Open it from an audio file
+
if (!music.openFromFile("music.ogg"))
+
{
+
// error...
+
}
+
+
// Change some parameters
+
music.setPosition(0, 1, 10); // change its 3D position
+
music.setPitch(2); // increase the pitch
+
music.setVolume(50); // reduce the volume
+
music.setLoop(true); // make it loop
+
+
// Play it
+
music.play();
+
sf::Music
Streamed music played from an audio file.
Definition: Music.hpp:49
+
sf::Music::openFromFile
bool openFromFile(const std::string &filename)
Open a music from an audio file.
+
sf::SoundSource::setPosition
void setPosition(float x, float y, float z)
Set the 3D position of the sound in the audio scene.
+
sf::SoundSource::setVolume
void setVolume(float volume)
Set the volume of the sound.
+
sf::SoundSource::setPitch
void setPitch(float pitch)
Set the pitch of the sound.
+
sf::SoundStream::setLoop
void setLoop(bool loop)
Set whether or not the stream should loop after reaching the end.
+
sf::SoundStream::play
void play()
Start or resume playing the audio stream.
+
See also
sf::Sound, sf::SoundStream
+ +

Definition at line 48 of file Music.hpp.

+

Member Typedef Documentation

+ +

◆ TimeSpan

+ +
+
+ + + + +
typedef Span<Time> sf::Music::TimeSpan
+
+ +

Definition at line 87 of file Music.hpp.

+ +
+
+

Member Enumeration Documentation

+ +

◆ anonymous enum

+ +
+
+ + + + + +
+ + + + +
anonymous enum
+ 		+protectedinherited
+
+ + +
Enumerator
NoLoop 

"Invalid" endSeeks value, telling us to continue uninterrupted

+
+ +

Definition at line 183 of file SoundStream.hpp.

+ +
+
+ +

◆ Status

+ +
+
+ + + + + +
+ + + + +
enum sf::SoundSource::Status
+ 		+inherited
+
+ +

Enumeration of the sound source states.

+ + + + +
Enumerator
Stopped 

Sound is not playing.

+
Paused 

Sound is paused.

+
Playing 

Sound is playing.

+
+ +

Definition at line 50 of file SoundSource.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Music()

+ +
+
+ + + + + + + +
sf::Music::Music ()
+
+ +

Default constructor.

+ +
+
+ +

◆ ~Music()

+ +
+
+ + + + + + + +
sf::Music::~Music ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ getAttenuation()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getAttenuation () const
+ 		+inherited
+
+ +

Get the attenuation factor of the sound.

+
Returns
Attenuation factor of the sound
+
See also
setAttenuation, getMinDistance
+ +
+
+ +

◆ getChannelCount()

+ +
+
+ + + + + +
+ + + + + + + +
unsigned int sf::SoundStream::getChannelCount () const
+ 		+inherited
+
+ +

Return the number of channels of the stream.

+

1 channel means a mono sound, 2 means stereo, etc.

+
Returns
Number of channels
+ +
+
+ +

◆ getDuration()

+ +
+
+ + + + + + + +
Time sf::Music::getDuration () const
+
+ +

Get the total duration of the music.

+
Returns
Music duration
+ +
+
+ +

◆ getLoop()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::SoundStream::getLoop () const
+ 		+inherited
+
+ +

Tell whether or not the stream is in loop mode.

+
Returns
True if the stream is looping, false otherwise
+
See also
setLoop
+ +
+
+ +

◆ getLoopPoints()

+ +
+
+ + + + + + + +
TimeSpan sf::Music::getLoopPoints () const
+
+ +

Get the positions of the of the sound's looping sequence.

+
Returns
Loop Time position class.
+
Warning
Since setLoopPoints() performs some adjustments on the provided values and rounds them to internal samples, a call to getLoopPoints() is not guaranteed to return the same times passed into a previous call to setLoopPoints(). However, it is guaranteed to return times that will map to the valid internal samples of this Music if they are later passed to setLoopPoints().
+
See also
setLoopPoints
+ +
+
+ +

◆ getMinDistance()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getMinDistance () const
+ 		+inherited
+
+ +

Get the minimum distance of the sound.

+
Returns
Minimum distance of the sound
+
See also
setMinDistance, getAttenuation
+ +
+
+ +

◆ getPitch()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getPitch () const
+ 		+inherited
+
+ +

Get the pitch of the sound.

+
Returns
Pitch of the sound
+
See also
setPitch
+ +
+
+ +

◆ getPlayingOffset()

+ +
+
+ + + + + +
+ + + + + + + +
Time sf::SoundStream::getPlayingOffset () const
+ 		+inherited
+
+ +

Get the current playing position of the stream.

+
Returns
Current playing position, from the beginning of the stream
+
See also
setPlayingOffset
+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
Vector3f sf::SoundSource::getPosition () const
+ 		+inherited
+
+ +

Get the 3D position of the sound in the audio scene.

+
Returns
Position of the sound
+
See also
setPosition
+ +
+
+ +

◆ getSampleRate()

+ +
+
+ + + + + +
+ + + + + + + +
unsigned int sf::SoundStream::getSampleRate () const
+ 		+inherited
+
+ +

Get the stream sample rate of the stream.

+

The sample rate is the number of audio samples played per second. The higher, the better the quality.

+
Returns
Sample rate, in number of samples per second
+ +
+
+ +

◆ getStatus()

+ +
+
+ + + + + +
+ + + + + + + +
Status sf::SoundStream::getStatus () const
+ 		+virtualinherited
+
+ +

Get the current status of the stream (stopped, paused, playing)

+
Returns
Current status
+ +

Reimplemented from sf::SoundSource.

+ +
+
+ +

◆ getVolume()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getVolume () const
+ 		+inherited
+
+ +

Get the volume of the sound.

+
Returns
Volume of the sound, in the range [0, 100]
+
See also
setVolume
+ +
+
+ +

◆ initialize()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::SoundStream::initialize (unsigned int channelCount,
unsigned int sampleRate 
)
+ 		+protectedinherited
+
+ +

Define the audio stream parameters.

+

This function must be called by derived classes as soon as they know the audio settings of the stream to play. Any attempt to manipulate the stream (play(), ...) before calling this function will fail. It can be called multiple times if the settings of the audio stream change, but only when the stream is stopped.

+
Parameters
+ + + +
channelCountNumber of channels of the stream
sampleRateSample rate, in samples per second
+
+
+ +
+
+ +

◆ isRelativeToListener()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::SoundSource::isRelativeToListener () const
+ 		+inherited
+
+ +

Tell whether the sound's position is relative to the listener or is absolute.

+
Returns
True if the position is relative, false if it's absolute
+
See also
setRelativeToListener
+ +
+
+ +

◆ onGetData()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual bool sf::Music::onGetData (Chunk & data)
+ 		+protectedvirtual
+
+ +

Request a new chunk of audio samples from the stream source.

+

This function fills the chunk from the next samples to read from the audio file.

+
Parameters
+ + +
dataChunk of data to fill
+
+
+
Returns
True to continue playback, false to stop
+ +

Implements sf::SoundStream.

+ +
+
+ +

◆ onLoop()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Int64 sf::Music::onLoop ()
+ 		+protectedvirtual
+
+ +

Change the current playing position in the stream source to the loop offset.

+

This is called by the underlying SoundStream whenever it needs us to reset the seek position for a loop. We then determine whether we are looping on a loop point or the end-of-file, perform the seek, and return the new position.

+
Returns
The seek position after looping (or -1 if there's no loop)
+ +

Reimplemented from sf::SoundStream.

+ +
+
+ +

◆ onSeek()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual void sf::Music::onSeek (Time timeOffset)
+ 		+protectedvirtual
+
+ +

Change the current playing position in the stream source.

+
Parameters
+ + +
timeOffsetNew playing position, from the beginning of the music
+
+
+ +

Implements sf::SoundStream.

+ +
+
+ +

◆ openFromFile()

+ +
+
+ + + + + + + + +
bool sf::Music::openFromFile (const std::string & filename)
+
+ +

Open a music from an audio file.

+

This function doesn't start playing the music (call play() to do so). See the documentation of sf::InputSoundFile for the list of supported formats.

+
Warning
Since the music is not loaded at once but rather streamed continuously, the file must remain accessible until the sf::Music object loads a new music or is destroyed.
+
Parameters
+ + +
filenamePath of the music file to open
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
openFromMemory, openFromStream
+ +
+
+ +

◆ openFromMemory()

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Music::openFromMemory (const void * data,
std::size_t sizeInBytes 
)
+
+ +

Open a music from an audio file in memory.

+

This function doesn't start playing the music (call play() to do so). See the documentation of sf::InputSoundFile for the list of supported formats.

+
Warning
Since the music is not loaded at once but rather streamed continuously, the data buffer must remain accessible until the sf::Music object loads a new music or is destroyed. That is, you can't deallocate the buffer right after calling this function.
+
Parameters
+ + + +
dataPointer to the file data in memory
sizeInBytesSize of the data to load, in bytes
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
openFromFile, openFromStream
+ +
+
+ +

◆ openFromStream()

+ +
+
+ + + + + + + + +
bool sf::Music::openFromStream (InputStream & stream)
+
+ +

Open a music from an audio file in a custom stream.

+

This function doesn't start playing the music (call play() to do so). See the documentation of sf::InputSoundFile for the list of supported formats.

+
Warning
Since the music is not loaded at once but rather streamed continuously, the stream must remain accessible until the sf::Music object loads a new music or is destroyed.
+
Parameters
+ + +
streamSource stream to read from
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
openFromFile, openFromMemory
+ +
+
+ +

◆ pause()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::SoundStream::pause ()
+ 		+virtualinherited
+
+ +

Pause the audio stream.

+

This function pauses the stream if it was playing, otherwise (stream already paused or stopped) it has no effect.

+
See also
play, stop
+ +

Implements sf::SoundSource.

+ +
+
+ +

◆ play()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::SoundStream::play ()
+ 		+virtualinherited
+
+ +

Start or resume playing the audio stream.

+

This function starts the stream if it was stopped, resumes it if it was paused, and restarts it from the beginning if it was already playing. This function uses its own thread so that it doesn't block the rest of the program while the stream is played.

+
See also
pause, stop
+ +

Implements sf::SoundSource.

+ +
+
+ +

◆ setAttenuation()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setAttenuation (float attenuation)
+ 		+inherited
+
+ +

Set the attenuation factor of the sound.

+

The attenuation is a multiplicative factor which makes the sound more or less loud according to its distance from the listener. An attenuation of 0 will produce a non-attenuated sound, i.e. its volume will always be the same whether it is heard from near or from far. On the other hand, an attenuation value such as 100 will make the sound fade out very quickly as it gets further from the listener. The default value of the attenuation is 1.

+
Parameters
+ + +
attenuationNew attenuation factor of the sound
+
+
+
See also
getAttenuation, setMinDistance
+ +
+
+ +

◆ setLoop()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundStream::setLoop (bool loop)
+ 		+inherited
+
+ +

Set whether or not the stream should loop after reaching the end.

+

If set, the stream will restart from beginning after reaching the end and so on, until it is stopped or setLoop(false) is called. The default looping state for streams is false.

+
Parameters
+ + +
loopTrue to play in loop, false to play once
+
+
+
See also
getLoop
+ +
+
+ +

◆ setLoopPoints()

+ +
+
+ + + + + + + + +
void sf::Music::setLoopPoints (TimeSpan timePoints)
+
+ +

Sets the beginning and duration of the sound's looping sequence using sf::Time.

+

setLoopPoints() allows for specifying the beginning offset and the duration of the loop such that, when the music is enabled for looping, it will seamlessly seek to the beginning whenever it encounters the end of the duration. Valid ranges for timePoints.offset and timePoints.length are [0, Dur) and (0, Dur-offset] respectively, where Dur is the value returned by getDuration(). Note that the EOF "loop point" from the end to the beginning of the stream is still honored, in case the caller seeks to a point after the end of the loop range. This function can be safely called at any point after a stream is opened, and will be applied to a playing sound without affecting the current playing offset.

+
Warning
Setting the loop points while the stream's status is Paused will set its status to Stopped. The playing offset will be unaffected.
+
Parameters
+ + +
timePointsThe definition of the loop. Can be any time points within the sound's length
+
+
+
See also
getLoopPoints
+ +
+
+ +

◆ setMinDistance()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setMinDistance (float distance)
+ 		+inherited
+
+ +

Set the minimum distance of the sound.

+

The "minimum distance" of a sound is the maximum distance at which it is heard at its maximum volume. Further than the minimum distance, it will start to fade out according to its attenuation factor. A value of 0 ("inside the head +of the listener") is an invalid value and is forbidden. The default value of the minimum distance is 1.

+
Parameters
+ + +
distanceNew minimum distance of the sound
+
+
+
See also
getMinDistance, setAttenuation
+ +
+
+ +

◆ setPitch()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setPitch (float pitch)
+ 		+inherited
+
+ +

Set the pitch of the sound.

+

The pitch represents the perceived fundamental frequency of a sound; thus you can make a sound more acute or grave by changing its pitch. A side effect of changing the pitch is to modify the playing speed of the sound as well. The default value for the pitch is 1.

+
Parameters
+ + +
pitchNew pitch to apply to the sound
+
+
+
See also
getPitch
+ +
+
+ +

◆ setPlayingOffset()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundStream::setPlayingOffset (Time timeOffset)
+ 		+inherited
+
+ +

Change the current playing position of the stream.

+

The playing position can be changed when the stream is either paused or playing. Changing the playing position when the stream is stopped has no effect, since playing the stream would reset its position.

+
Parameters
+ + +
timeOffsetNew playing position, from the beginning of the stream
+
+
+
See also
getPlayingOffset
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setPosition (const Vector3f & position)
+ 		+inherited
+
+ +

Set the 3D position of the sound in the audio scene.

+

Only sounds with one channel (mono sounds) can be spatialized. The default position of a sound is (0, 0, 0).

+
Parameters
+ + +
positionPosition of the sound in the scene
+
+
+
See also
getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::SoundSource::setPosition (float x,
float y,
float z 
)
+ 		+inherited
+
+ +

Set the 3D position of the sound in the audio scene.

+

Only sounds with one channel (mono sounds) can be spatialized. The default position of a sound is (0, 0, 0).

+
Parameters
+ + + + +
xX coordinate of the position of the sound in the scene
yY coordinate of the position of the sound in the scene
zZ coordinate of the position of the sound in the scene
+
+
+
See also
getPosition
+ +
+
+ +

◆ setProcessingInterval()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundStream::setProcessingInterval (Time interval)
+ 		+protectedinherited
+
+ +

Set the processing interval.

+

The processing interval controls the period at which the audio buffers are filled by calls to onGetData. A smaller interval may be useful for low-latency streams. Note that the given period is only a hint and the actual period may vary. The default processing interval is 10 ms.

+
Parameters
+ + +
intervalProcessing interval
+
+
+ +
+
+ +

◆ setRelativeToListener()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setRelativeToListener (bool relative)
+ 		+inherited
+
+ +

Make the sound's position relative to the listener or absolute.

+

Making a sound relative to the listener will ensure that it will always be played the same way regardless of the position of the listener. This can be useful for non-spatialized sounds, sounds that are produced by the listener, or sounds attached to it. The default value is false (position is absolute).

+
Parameters
+ + +
relativeTrue to set the position relative, false to set it absolute
+
+
+
See also
isRelativeToListener
+ +
+
+ +

◆ setVolume()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setVolume (float volume)
+ 		+inherited
+
+ +

Set the volume of the sound.

+

The volume is a value between 0 (mute) and 100 (full volume). The default value for the volume is 100.

+
Parameters
+ + +
volumeVolume of the sound
+
+
+
See also
getVolume
+ +
+
+ +

◆ stop()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::SoundStream::stop ()
+ 		+virtualinherited
+
+ +

Stop playing the audio stream.

+

This function stops the stream if it was playing or paused, and does nothing if it was already stopped. It also resets the playing position (unlike pause()).

+
See also
play, pause
+ +

Implements sf::SoundSource.

+ +
+
+

Member Data Documentation

+ +

◆ m_source

+ +
+
+ + + + + +
+ + + + +
unsigned int sf::SoundSource::m_source
+ 		+protectedinherited
+
+ +

OpenAL source identifier.

+ +

Definition at line 309 of file SoundSource.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Music.png b/Space-Invaders/sfml/doc/html/classsf_1_1Music.png new file mode 100644 index 000000000..30ed00060 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Music.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Mutex-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Mutex-members.html new file mode 100644 index 000000000..57596fda6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Mutex-members.html @@ -0,0 +1,112 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Mutex Member List
+
+
+ +

This is the complete list of members for sf::Mutex, including all inherited members.

+ + + + + +
lock()sf::Mutex
Mutex()sf::Mutex
unlock()sf::Mutex
~Mutex()sf::Mutex
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Mutex.html b/Space-Invaders/sfml/doc/html/classsf_1_1Mutex.html new file mode 100644 index 000000000..ded26e609 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Mutex.html @@ -0,0 +1,252 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::Mutex Class Reference
System module
+
+
+ +

Blocks concurrent access to shared resources from multiple threads. + More...

+ +

#include <SFML/System/Mutex.hpp>

+
+Inheritance diagram for sf::Mutex:
+
+
+ + +sf::NonCopyable + +
+ + + + + + + + + + + + + + +

+Public Member Functions

 Mutex ()
 Default constructor.
 
 ~Mutex ()
 Destructor.
 
void lock ()
 Lock the mutex.
 
void unlock ()
 Unlock the mutex.
 
+

Detailed Description

+

Blocks concurrent access to shared resources from multiple threads.

+

Mutex stands for "MUTual EXclusion".

+

A mutex is a synchronization object, used when multiple threads are involved.

+

When you want to protect a part of the code from being accessed simultaneously by multiple threads, you typically use a mutex. When a thread is locked by a mutex, any other thread trying to lock it will be blocked until the mutex is released by the thread that locked it. This way, you can allow only one thread at a time to access a critical region of your code.

+

Usage example:

Database database; // this is a critical resource that needs some protection
+
sf::Mutex mutex;
+
+
void thread1()
+
{
+
mutex.lock(); // this call will block the thread if the mutex is already locked by thread2
+
database.write(...);
+
mutex.unlock(); // if thread2 was waiting, it will now be unblocked
+
}
+
+
void thread2()
+
{
+
mutex.lock(); // this call will block the thread if the mutex is already locked by thread1
+
database.write(...);
+
mutex.unlock(); // if thread1 was waiting, it will now be unblocked
+
}
+
sf::Mutex
Blocks concurrent access to shared resources from multiple threads.
Definition: Mutex.hpp:48
+
sf::Mutex::lock
void lock()
Lock the mutex.
+
sf::Mutex::unlock
void unlock()
Unlock the mutex.
+

Be very careful with mutexes. A bad usage can lead to bad problems, like deadlocks (two threads are waiting for each other and the application is globally stuck).

+

To make the usage of mutexes more robust, particularly in environments where exceptions can be thrown, you should use the helper class sf::Lock to lock/unlock mutexes.

+

SFML mutexes are recursive, which means that you can lock a mutex multiple times in the same thread without creating a deadlock. In this case, the first call to lock() behaves as usual, and the following ones have no effect. However, you must call unlock() exactly as many times as you called lock(). If you don't, the mutex won't be released.

+
See also
sf::Lock
+ +

Definition at line 47 of file Mutex.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Mutex()

+ +
+
+ + + + + + + +
sf::Mutex::Mutex ()
+
+ +

Default constructor.

+ +
+
+ +

◆ ~Mutex()

+ +
+
+ + + + + + + +
sf::Mutex::~Mutex ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ lock()

+ +
+
+ + + + + + + +
void sf::Mutex::lock ()
+
+ +

Lock the mutex.

+

If the mutex is already locked in another thread, this call will block the execution until the mutex is released.

+
See also
unlock
+ +
+
+ +

◆ unlock()

+ +
+
+ + + + + + + +
void sf::Mutex::unlock ()
+
+ +

Unlock the mutex.

+
See also
lock
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Mutex.png b/Space-Invaders/sfml/doc/html/classsf_1_1Mutex.png new file mode 100644 index 000000000..2746b61f8 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Mutex.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1NonCopyable-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1NonCopyable-members.html new file mode 100644 index 000000000..604e3d188 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1NonCopyable-members.html @@ -0,0 +1,110 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::NonCopyable Member List
+
+
+ +

This is the complete list of members for sf::NonCopyable, including all inherited members.

+ + + +
NonCopyable()sf::NonCopyableinlineprotected
~NonCopyable()sf::NonCopyableinlineprotected
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1NonCopyable.html b/Space-Invaders/sfml/doc/html/classsf_1_1NonCopyable.html new file mode 100644 index 000000000..a8e5c3a4b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1NonCopyable.html @@ -0,0 +1,224 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Protected Member Functions | +List of all members
+
sf::NonCopyable Class Reference
System module
+
+
+ +

Utility class that makes any derived class non-copyable. + More...

+ +

#include <SFML/System/NonCopyable.hpp>

+
+Inheritance diagram for sf::NonCopyable:
+
+
+ + +sf::Context +sf::Cursor +sf::FileInputStream +sf::Ftp +sf::GlResource::TransientContextLock +sf::Http +sf::InputSoundFile +sf::Lock +sf::Mutex +sf::OutputSoundFile +sf::RenderTarget +sf::Shader +sf::Socket +sf::Thread +sf::ThreadLocal +sf::WindowBase + +
+ + + + + + + + +

+Protected Member Functions

 NonCopyable ()
 Default constructor.
 
 ~NonCopyable ()
 Default destructor.
 
+

Detailed Description

+

Utility class that makes any derived class non-copyable.

+

This class makes its instances non-copyable, by explicitly disabling its copy constructor and its assignment operator.

+

To create a non-copyable class, simply inherit from sf::NonCopyable.

+

The type of inheritance (public or private) doesn't matter, the copy constructor and assignment operator are declared private in sf::NonCopyable so they will end up being inaccessible in both cases. Thus you can use a shorter syntax for inheriting from it (see below).

+

Usage example:

class MyNonCopyableClass : sf::NonCopyable
+
{
+
...
+
};
+
sf::NonCopyable
Utility class that makes any derived class non-copyable.
Definition: NonCopyable.hpp:42
+

Deciding whether the instances of a class can be copied or not is a very important design choice. You are strongly encouraged to think about it before writing a class, and to use sf::NonCopyable when necessary to prevent many potential future errors when using it. This is also a very important indication to users of your class.

+ +

Definition at line 41 of file NonCopyable.hpp.

+

Constructor & Destructor Documentation

+ +

◆ NonCopyable()

+ +
+
+ + + + + +
+ + + + + + + +
sf::NonCopyable::NonCopyable ()
+ 		+inlineprotected
+
+ +

Default constructor.

+

Because this class has a copy constructor, the compiler will not automatically generate the default constructor. That's why we must define it explicitly.

+ +

Definition at line 53 of file NonCopyable.hpp.

+ +
+
+ +

◆ ~NonCopyable()

+ +
+
+ + + + + +
+ + + + + + + +
sf::NonCopyable::~NonCopyable ()
+ 		+inlineprotected
+
+ +

Default destructor.

+

By declaring a protected destructor it's impossible to call delete on a pointer of sf::NonCopyable, thus preventing possible resource leaks.

+ +

Definition at line 63 of file NonCopyable.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1NonCopyable.png b/Space-Invaders/sfml/doc/html/classsf_1_1NonCopyable.png new file mode 100644 index 000000000..b7ff5b462 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1NonCopyable.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1OutputSoundFile-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1OutputSoundFile-members.html new file mode 100644 index 000000000..09b0fa1df --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1OutputSoundFile-members.html @@ -0,0 +1,113 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::OutputSoundFile Member List
+
+
+ +

This is the complete list of members for sf::OutputSoundFile, including all inherited members.

+ + + + + + +
close()sf::OutputSoundFile
openFromFile(const std::string &filename, unsigned int sampleRate, unsigned int channelCount)sf::OutputSoundFile
OutputSoundFile()sf::OutputSoundFile
write(const Int16 *samples, Uint64 count)sf::OutputSoundFile
~OutputSoundFile()sf::OutputSoundFile
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1OutputSoundFile.html b/Space-Invaders/sfml/doc/html/classsf_1_1OutputSoundFile.html new file mode 100644 index 000000000..717256435 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1OutputSoundFile.html @@ -0,0 +1,310 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::OutputSoundFile Class Reference
Audio module
+
+
+ +

Provide write access to sound files. + More...

+ +

#include <SFML/Audio/OutputSoundFile.hpp>

+
+Inheritance diagram for sf::OutputSoundFile:
+
+
+ + +sf::NonCopyable + +
+ + + + + + + + + + + + + + + + + +

+Public Member Functions

 OutputSoundFile ()
 Default constructor.
 
 ~OutputSoundFile ()
 Destructor.
 
bool openFromFile (const std::string &filename, unsigned int sampleRate, unsigned int channelCount)
 Open the sound file from the disk for writing.
 
void write (const Int16 *samples, Uint64 count)
 Write audio samples to the file.
 
void close ()
 Close the current file.
 
+

Detailed Description

+

Provide write access to sound files.

+

This class encodes audio samples to a sound file.

+

It is used internally by higher-level classes such as sf::SoundBuffer, but can also be useful if you want to create audio files from custom data sources, like generated audio samples.

+

Usage example:

// Create a sound file, ogg/vorbis format, 44100 Hz, stereo
+
sf::OutputSoundFile file;
+
if (!file.openFromFile("music.ogg", 44100, 2))
+
/* error */;
+
+
while (...)
+
{
+
// Read or generate audio samples from your custom source
+
std::vector<sf::Int16> samples = ...;
+
+
// Write them to the file
+
file.write(samples.data(), samples.size());
+
}
+
sf::OutputSoundFile
Provide write access to sound files.
Definition: OutputSoundFile.hpp:45
+
sf::OutputSoundFile::write
void write(const Int16 *samples, Uint64 count)
Write audio samples to the file.
+
sf::OutputSoundFile::openFromFile
bool openFromFile(const std::string &filename, unsigned int sampleRate, unsigned int channelCount)
Open the sound file from the disk for writing.
+
See also
sf::SoundFileWriter, sf::InputSoundFile
+ +

Definition at line 44 of file OutputSoundFile.hpp.

+

Constructor & Destructor Documentation

+ +

◆ OutputSoundFile()

+ +
+
+ + + + + + + +
sf::OutputSoundFile::OutputSoundFile ()
+
+ +

Default constructor.

+ +
+
+ +

◆ ~OutputSoundFile()

+ +
+
+ + + + + + + +
sf::OutputSoundFile::~OutputSoundFile ()
+
+ +

Destructor.

+

Closes the file if it was still open.

+ +
+
+

Member Function Documentation

+ +

◆ close()

+ +
+
+ + + + + + + +
void sf::OutputSoundFile::close ()
+
+ +

Close the current file.

+ +
+
+ +

◆ openFromFile()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::OutputSoundFile::openFromFile (const std::string & filename,
unsigned int sampleRate,
unsigned int channelCount 
)
+
+ +

Open the sound file from the disk for writing.

+

The supported audio formats are: WAV, OGG/Vorbis, FLAC.

+
Parameters
+ + + + +
filenamePath of the sound file to write
sampleRateSample rate of the sound
channelCountNumber of channels in the sound
+
+
+
Returns
True if the file was successfully opened
+ +
+
+ +

◆ write()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::OutputSoundFile::write (const Int16 * samples,
Uint64 count 
)
+
+ +

Write audio samples to the file.

+
Parameters
+ + + +
samplesPointer to the sample array to write
countNumber of samples to write
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1OutputSoundFile.png b/Space-Invaders/sfml/doc/html/classsf_1_1OutputSoundFile.png new file mode 100644 index 000000000..e7478c222 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1OutputSoundFile.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Packet-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Packet-members.html new file mode 100644 index 000000000..320248b40 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Packet-members.html @@ -0,0 +1,153 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Packet Member List
+
+
+ +

This is the complete list of members for sf::Packet, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
append(const void *data, std::size_t sizeInBytes)sf::Packet
clear()sf::Packet
endOfPacket() constsf::Packet
getData() constsf::Packet
getDataSize() constsf::Packet
getReadPosition() constsf::Packet
onReceive(const void *data, std::size_t size)sf::Packetprotectedvirtual
onSend(std::size_t &size)sf::Packetprotectedvirtual
operator BoolType() constsf::Packet
operator<<(bool data)sf::Packet
operator<<(Int8 data)sf::Packet
operator<<(Uint8 data)sf::Packet
operator<<(Int16 data)sf::Packet
operator<<(Uint16 data)sf::Packet
operator<<(Int32 data)sf::Packet
operator<<(Uint32 data)sf::Packet
operator<<(Int64 data)sf::Packet
operator<<(Uint64 data)sf::Packet
operator<<(float data)sf::Packet
operator<<(double data)sf::Packet
operator<<(const char *data)sf::Packet
operator<<(const std::string &data)sf::Packet
operator<<(const wchar_t *data)sf::Packet
operator<<(const std::wstring &data)sf::Packet
operator<<(const String &data)sf::Packet
operator>>(bool &data)sf::Packet
operator>>(Int8 &data)sf::Packet
operator>>(Uint8 &data)sf::Packet
operator>>(Int16 &data)sf::Packet
operator>>(Uint16 &data)sf::Packet
operator>>(Int32 &data)sf::Packet
operator>>(Uint32 &data)sf::Packet
operator>>(Int64 &data)sf::Packet
operator>>(Uint64 &data)sf::Packet
operator>>(float &data)sf::Packet
operator>>(double &data)sf::Packet
operator>>(char *data)sf::Packet
operator>>(std::string &data)sf::Packet
operator>>(wchar_t *data)sf::Packet
operator>>(std::wstring &data)sf::Packet
operator>>(String &data)sf::Packet
Packet()sf::Packet
TcpSocket (defined in sf::Packet)sf::Packetfriend
UdpSocket (defined in sf::Packet)sf::Packetfriend
~Packet()sf::Packetvirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Packet.html b/Space-Invaders/sfml/doc/html/classsf_1_1Packet.html new file mode 100644 index 000000000..f9a48d942 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Packet.html @@ -0,0 +1,1358 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Protected Member Functions | +Friends | +List of all members
+
sf::Packet Class Reference
Network module
+
+
+ +

Utility class to build blocks of data to transfer over the network. + More...

+ +

#include <SFML/Network/Packet.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Packet ()
 Default constructor.
 
virtual ~Packet ()
 Virtual destructor.
 
void append (const void *data, std::size_t sizeInBytes)
 Append data to the end of the packet.
 
std::size_t getReadPosition () const
 Get the current reading position in the packet.
 
void clear ()
 Clear the packet.
 
const void * getData () const
 Get a pointer to the data contained in the packet.
 
std::size_t getDataSize () const
 Get the size of the data contained in the packet.
 
bool endOfPacket () const
 Tell if the reading position has reached the end of the packet.
 
 operator BoolType () const
 Test the validity of the packet, for reading.
 
Packet & operator>> (bool &data)
 Overload of operator >> to read data from the packet.
 
Packet & operator>> (Int8 &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (Uint8 &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (Int16 &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (Uint16 &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (Int32 &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (Uint32 &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (Int64 &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (Uint64 &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (float &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (double &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (char *data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (std::string &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (wchar_t *data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (std::wstring &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator>> (String &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (bool data)
 Overload of operator << to write data into the packet.
 
Packet & operator<< (Int8 data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (Uint8 data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (Int16 data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (Uint16 data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (Int32 data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (Uint32 data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (Int64 data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (Uint64 data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (float data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (double data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (const char *data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (const std::string &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (const wchar_t *data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (const std::wstring &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
Packet & operator<< (const String &data)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
+ + + + + + + +

+Protected Member Functions

virtual const void * onSend (std::size_t &size)
 Called before the packet is sent over the network.
 
virtual void onReceive (const void *data, std::size_t size)
 Called after the packet is received over the network.
 
+ + + + + +

+Friends

class TcpSocket
 
class UdpSocket
 
+

Detailed Description

+

Utility class to build blocks of data to transfer over the network.

+

Packets provide a safe and easy way to serialize data, in order to send it over the network using sockets (sf::TcpSocket, sf::UdpSocket).

+

Packets solve 2 fundamental problems that arise when transferring data over the network:

    +
  • data is interpreted correctly according to the endianness
    • +
  • the bounds of the packet are preserved (one send == one receive)
    • +
+

The sf::Packet class provides both input and output modes. It is designed to follow the behavior of standard C++ streams, using operators >> and << to extract and insert data.

+

It is recommended to use only fixed-size types (like sf::Int32, etc.), to avoid possible differences between the sender and the receiver. Indeed, the native C++ types may have different sizes on two platforms and your data may be corrupted if that happens.

+

Usage example:

sf::Uint32 x = 24;
+
std::string s = "hello";
+
double d = 5.89;
+
+
// Group the variables to send into a packet
+
sf::Packet packet;
+
packet << x << s << d;
+
+
// Send it over the network (socket is a valid sf::TcpSocket)
+
socket.send(packet);
+
+
-----------------------------------------------------------------
+
+
// Receive the packet at the other end
+
sf::Packet packet;
+
socket.receive(packet);
+
+
// Extract the variables contained in the packet
+
sf::Uint32 x;
+
std::string s;
+
double d;
+
if (packet >> x >> s >> d)
+
{
+
// Data extracted successfully...
+
}
+
sf::Packet
Utility class to build blocks of data to transfer over the network.
Definition: Packet.hpp:48
+

Packets have built-in operator >> and << overloads for standard types:

    +
  • bool
    • +
  • fixed-size integer types (sf::Int8/16/32, sf::Uint8/16/32)
    • +
  • floating point numbers (float, double)
    • +
  • string types (char*, wchar_t*, std::string, std::wstring, sf::String)
    • +
+

Like standard streams, it is also possible to define your own overloads of operators >> and << in order to handle your custom types.

+
struct MyStruct
+
{
+
float number;
+
sf::Int8 integer;
+
std::string str;
+
};
+
+
sf::Packet& operator <<(sf::Packet& packet, const MyStruct& m)
+
{
+
return packet << m.number << m.integer << m.str;
+
}
+
+
sf::Packet& operator >>(sf::Packet& packet, MyStruct& m)
+
{
+
return packet >> m.number >> m.integer >> m.str;
+
}
+
sf::Packet::operator>>
Packet & operator>>(bool &data)
Overload of operator >> to read data from the packet.
+
sf::Packet::operator<<
Packet & operator<<(bool data)
Overload of operator << to write data into the packet.
+

Packets also provide an extra feature that allows to apply custom transformations to the data before it is sent, and after it is received. This is typically used to handle automatic compression or encryption of the data. This is achieved by inheriting from sf::Packet, and overriding the onSend and onReceive functions.

+

Here is an example:

class ZipPacket : public sf::Packet
+
{
+
virtual const void* onSend(std::size_t& size)
+
{
+
const void* srcData = getData();
+
std::size_t srcSize = getDataSize();
+
+
return MySuperZipFunction(srcData, srcSize, &size);
+
}
+
+
virtual void onReceive(const void* data, std::size_t size)
+
{
+
std::size_t dstSize;
+
const void* dstData = MySuperUnzipFunction(data, size, &dstSize);
+
+
append(dstData, dstSize);
+
}
+
};
+
+
// Use like regular packets:
+
ZipPacket packet;
+
packet << x << s << d;
+
...
+
See also
sf::TcpSocket, sf::UdpSocket
+ +

Definition at line 47 of file Packet.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Packet()

+ +
+
+ + + + + + + +
sf::Packet::Packet ()
+
+ +

Default constructor.

+

Creates an empty packet.

+ +
+
+ +

◆ ~Packet()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::Packet::~Packet ()
+ 		+virtual
+
+ +

Virtual destructor.

+ +
+
+

Member Function Documentation

+ +

◆ append()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Packet::append (const void * data,
std::size_t sizeInBytes 
)
+
+ +

Append data to the end of the packet.

+
Parameters
+ + + +
dataPointer to the sequence of bytes to append
sizeInBytesNumber of bytes to append
+
+
+
See also
clear
+
+getReadPosition
+ +
+
+ +

◆ clear()

+ +
+
+ + + + + + + +
void sf::Packet::clear ()
+
+ +

Clear the packet.

+

After calling Clear, the packet is empty.

+
See also
append
+ +
+
+ +

◆ endOfPacket()

+ +
+
+ + + + + + + +
bool sf::Packet::endOfPacket () const
+
+ +

Tell if the reading position has reached the end of the packet.

+

This function is useful to know if there is some data left to be read, without actually reading it.

+
Returns
True if all data was read, false otherwise
+
See also
operator bool
+ +
+
+ +

◆ getData()

+ +
+
+ + + + + + + +
const void * sf::Packet::getData () const
+
+ +

Get a pointer to the data contained in the packet.

+

Warning: the returned pointer may become invalid after you append data to the packet, therefore it should never be stored. The return pointer is NULL if the packet is empty.

+
Returns
Pointer to the data
+
See also
getDataSize
+ +
+
+ +

◆ getDataSize()

+ +
+
+ + + + + + + +
std::size_t sf::Packet::getDataSize () const
+
+ +

Get the size of the data contained in the packet.

+

This function returns the number of bytes pointed to by what getData returns.

+
Returns
Data size, in bytes
+
See also
getData
+ +
+
+ +

◆ getReadPosition()

+ +
+
+ + + + + + + +
std::size_t sf::Packet::getReadPosition () const
+
+ +

Get the current reading position in the packet.

+

The next read operation will read data from this position

+
Returns
The byte offset of the current read position
+
See also
append
+ +
+
+ +

◆ onReceive()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual void sf::Packet::onReceive (const void * data,
std::size_t size 
)
+ 		+protectedvirtual
+
+ +

Called after the packet is received over the network.

+

This function can be defined by derived classes to transform the data after it is received; this can be used for decompression, decryption, etc. The function receives a pointer to the received data, and must fill the packet with the transformed bytes. The default implementation fills the packet directly without transforming the data.

+
Parameters
+ + + +
dataPointer to the received bytes
sizeNumber of bytes
+
+
+
See also
onSend
+ +
+
+ +

◆ onSend()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual const void * sf::Packet::onSend (std::size_t & size)
+ 		+protectedvirtual
+
+ +

Called before the packet is sent over the network.

+

This function can be defined by derived classes to transform the data before it is sent; this can be used for compression, encryption, etc. The function must return a pointer to the modified data, as well as the number of bytes pointed. The default implementation provides the packet's data without transforming it.

+
Parameters
+ + +
sizeVariable to fill with the size of data to send
+
+
+
Returns
Pointer to the array of bytes to send
+
See also
onReceive
+ +
+
+ +

◆ operator BoolType()

+ +
+
+ + + + + + + +
sf::Packet::operator BoolType () const
+
+ +

Test the validity of the packet, for reading.

+

This operator allows to test the packet as a boolean variable, to check if a reading operation was successful.

+

A packet will be in an invalid state if it has no more data to read.

+

This behavior is the same as standard C++ streams.

+

Usage example:

float x;
+
packet >> x;
+
if (packet)
+
{
+
// ok, x was extracted successfully
+
}
+
+
// -- or --
+
+
float x;
+
if (packet >> x)
+
{
+
// ok, x was extracted successfully
+
}
+

Don't focus on the return type, it's equivalent to bool but it disallows unwanted implicit conversions to integer or pointer types.

+
Returns
True if last data extraction from packet was successful
+
See also
endOfPacket
+ +
+
+ +

◆ operator<<() [1/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (bool data)
+
+ +

Overload of operator << to write data into the packet.

+ +
+
+ +

◆ operator<<() [2/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (const char * data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [3/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (const std::string & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [4/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (const std::wstring & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [5/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (const String & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [6/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (const wchar_t * data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [7/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (double data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [8/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (float data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [9/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (Int16 data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [10/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (Int32 data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [11/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (Int64 data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [12/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (Int8 data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [13/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (Uint16 data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [14/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (Uint32 data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [15/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (Uint64 data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator<<() [16/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator<< (Uint8 data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [1/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (bool & data)
+
+ +

Overload of operator >> to read data from the packet.

+ +
+
+ +

◆ operator>>() [2/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (char * data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [3/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (double & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [4/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (float & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [5/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (Int16 & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [6/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (Int32 & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [7/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (Int64 & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [8/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (Int8 & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [9/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (std::string & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [10/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (std::wstring & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [11/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (String & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [12/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (Uint16 & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [13/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (Uint32 & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [14/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (Uint64 & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [15/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (Uint8 & data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+ +

◆ operator>>() [16/16]

+ +
+
+ + + + + + + + +
Packet & sf::Packet::operator>> (wchar_t * data)
+
+ +

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

+ +
+
+

Friends And Related Function Documentation

+ +

◆ TcpSocket

+ +
+
+ + + + + +
+ + + + +
friend class TcpSocket
+ 		+friend
+
+ +

Definition at line 350 of file Packet.hpp.

+ +
+
+ +

◆ UdpSocket

+ +
+
+ + + + + +
+ + + + +
friend class UdpSocket
+ 		+friend
+
+ +

Definition at line 351 of file Packet.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Rect-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Rect-members.html new file mode 100644 index 000000000..4a675b781 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Rect-members.html @@ -0,0 +1,124 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Rect< T > Member List
+
+
+ +

This is the complete list of members for sf::Rect< T >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
contains(T x, T y) constsf::Rect< T >
contains(const Vector2< T > &point) constsf::Rect< T >
getPosition() constsf::Rect< T >
getSize() constsf::Rect< T >
heightsf::Rect< T >
intersects(const Rect< T > &rectangle) constsf::Rect< T >
intersects(const Rect< T > &rectangle, Rect< T > &intersection) constsf::Rect< T >
leftsf::Rect< T >
operator!=(const Rect< T > &left, const Rect< T > &right)sf::Rect< T >related
operator==(const Rect< T > &left, const Rect< T > &right)sf::Rect< T >related
Rect()sf::Rect< T >
Rect(T rectLeft, T rectTop, T rectWidth, T rectHeight)sf::Rect< T >
Rect(const Vector2< T > &position, const Vector2< T > &size)sf::Rect< T >
Rect(const Rect< U > &rectangle)sf::Rect< T >explicit
topsf::Rect< T >
widthsf::Rect< T >
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Rect.html b/Space-Invaders/sfml/doc/html/classsf_1_1Rect.html new file mode 100644 index 000000000..e34999c92 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Rect.html @@ -0,0 +1,746 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Public Attributes | +Related Functions | +List of all members
+
sf::Rect< T > Class Template Reference
Graphics module
+
+
+ +

Utility class for manipulating 2D axis aligned rectangles. + More...

+ +

#include <SFML/Graphics/Rect.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Rect ()
 Default constructor.
 
 Rect (T rectLeft, T rectTop, T rectWidth, T rectHeight)
 Construct the rectangle from its coordinates.
 
 Rect (const Vector2< T > &position, const Vector2< T > &size)
 Construct the rectangle from position and size.
 
template<typename U >
 Rect (const Rect< U > &rectangle)
 Construct the rectangle from another type of rectangle.
 
bool contains (T x, T y) const
 Check if a point is inside the rectangle's area.
 
bool contains (const Vector2< T > &point) const
 Check if a point is inside the rectangle's area.
 
bool intersects (const Rect< T > &rectangle) const
 Check the intersection between two rectangles.
 
bool intersects (const Rect< T > &rectangle, Rect< T > &intersection) const
 Check the intersection between two rectangles.
 
sf::Vector2< T > getPosition () const
 Get the position of the rectangle's top-left corner.
 
sf::Vector2< T > getSize () const
 Get the size of the rectangle.
 
+ + + + + + + + + + + + + +

+Public Attributes

T left
 Left coordinate of the rectangle.
 
T top
 Top coordinate of the rectangle.
 
T width
 Width of the rectangle.
 
T height
 Height of the rectangle.
 
+ + + + + + + + + + +

+Related Functions

(Note that these are not member functions.)

+
template<typename T >
bool operator== (const Rect< T > &left, const Rect< T > &right)
 Overload of binary operator ==.
 
template<typename T >
bool operator!= (const Rect< T > &left, const Rect< T > &right)
 Overload of binary operator !=.
 
+

Detailed Description

+
template<typename T>
+class sf::Rect< T >

Utility class for manipulating 2D axis aligned rectangles.

+

A rectangle is defined by its top-left corner and its size.

+

It is a very simple class defined for convenience, so its member variables (left, top, width and height) are public and can be accessed directly, just like the vector classes (Vector2 and Vector3).

+

To keep things simple, sf::Rect doesn't define functions to emulate the properties that are not directly members (such as right, bottom, center, etc.), it rather only provides intersection functions.

+

sf::Rect uses the usual rules for its boundaries:

    +
  • The left and top edges are included in the rectangle's area
    • +
  • The right (left + width) and bottom (top + height) edges are excluded from the rectangle's area
    • +
+

This means that sf::IntRect(0, 0, 1, 1) and sf::IntRect(1, 1, 1, 1) don't intersect.

+

sf::Rect is a template and may be used with any numeric type, but for simplicity the instantiations used by SFML are typedef'd:

    +
  • sf::Rect<int> is sf::IntRect
    • +
  • sf::Rect<float> is sf::FloatRect
    • +
+

So that you don't have to care about the template syntax.

+

Usage example:

// Define a rectangle, located at (0, 0) with a size of 20x5
+
sf::IntRect r1(0, 0, 20, 5);
+
+
// Define another rectangle, located at (4, 2) with a size of 18x10
+
sf::Vector2i position(4, 2);
+
sf::Vector2i size(18, 10);
+
sf::IntRect r2(position, size);
+
+
// Test intersections with the point (3, 1)
+
bool b1 = r1.contains(3, 1); // true
+
bool b2 = r2.contains(3, 1); // false
+
+
// Test the intersection between r1 and r2
+
sf::IntRect result;
+
bool b3 = r1.intersects(r2, result); // true
+
// result == (4, 2, 16, 3)
+ +
sf::Rect::intersects
bool intersects(const Rect< T > &rectangle) const
Check the intersection between two rectangles.
+
sf::Vector2
Utility template class for manipulating 2-dimensional vectors.
Definition: Vector2.hpp:38
+
+

Definition at line 42 of file Rect.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Rect() [1/4]

+ +
+
+
+template<typename T >
+ + + + + + + +
sf::Rect< T >::Rect ()
+
+ +

Default constructor.

+

Creates an empty rectangle (it is equivalent to calling Rect(0, 0, 0, 0)).

+ +
+
+ +

◆ Rect() [2/4]

+ +
+
+
+template<typename T >
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sf::Rect< T >::Rect (T rectLeft,
T rectTop,
T rectWidth,
T rectHeight 
)
+
+ +

Construct the rectangle from its coordinates.

+

Be careful, the last two parameters are the width and height, not the right and bottom coordinates!

+
Parameters
+ + + + + +
rectLeftLeft coordinate of the rectangle
rectTopTop coordinate of the rectangle
rectWidthWidth of the rectangle
rectHeightHeight of the rectangle
+
+
+ +
+
+ +

◆ Rect() [3/4]

+ +
+
+
+template<typename T >
+ + + + + + + + + + + + + + + + + + +
sf::Rect< T >::Rect (const Vector2< T > & position,
const Vector2< T > & size 
)
+
+ +

Construct the rectangle from position and size.

+

Be careful, the last parameter is the size, not the bottom-right corner!

+
Parameters
+ + + +
positionPosition of the top-left corner of the rectangle
sizeSize of the rectangle
+
+
+ +
+
+ +

◆ Rect() [4/4]

+ +
+
+
+template<typename T >
+
+template<typename U >
+ + + + + +
+ + + + + + + + +
sf::Rect< T >::Rect (const Rect< U > & rectangle)
+ 		+explicit
+
+ +

Construct the rectangle from another type of rectangle.

+

This constructor doesn't replace the copy constructor, it's called only when U != T. A call to this constructor will fail to compile if U is not convertible to T.

+
Parameters
+ + +
rectangleRectangle to convert
+
+
+ +
+
+

Member Function Documentation

+ +

◆ contains() [1/2]

+ +
+
+
+template<typename T >
+ + + + + + + + +
bool sf::Rect< T >::contains (const Vector2< T > & point) const
+
+ +

Check if a point is inside the rectangle's area.

+

This check is non-inclusive. If the point lies on the edge of the rectangle, this function will return false.

+
Parameters
+ + +
pointPoint to test
+
+
+
Returns
True if the point is inside, false otherwise
+
See also
intersects
+ +
+
+ +

◆ contains() [2/2]

+ +
+
+
+template<typename T >
+ + + + + + + + + + + + + + + + + + +
bool sf::Rect< T >::contains (T x,
T y 
) const
+
+ +

Check if a point is inside the rectangle's area.

+

This check is non-inclusive. If the point lies on the edge of the rectangle, this function will return false.

+
Parameters
+ + + +
xX coordinate of the point to test
yY coordinate of the point to test
+
+
+
Returns
True if the point is inside, false otherwise
+
See also
intersects
+ +
+
+ +

◆ getPosition()

+ +
+
+
+template<typename T >
+ + + + + + + +
sf::Vector2< T > sf::Rect< T >::getPosition () const
+
+ +

Get the position of the rectangle's top-left corner.

+
Returns
Position of rectangle
+
See also
getSize
+ +
+
+ +

◆ getSize()

+ +
+
+
+template<typename T >
+ + + + + + + +
sf::Vector2< T > sf::Rect< T >::getSize () const
+
+ +

Get the size of the rectangle.

+
Returns
Size of rectangle
+
See also
getPosition
+ +
+
+ +

◆ intersects() [1/2]

+ +
+
+
+template<typename T >
+ + + + + + + + +
bool sf::Rect< T >::intersects (const Rect< T > & rectangle) const
+
+ +

Check the intersection between two rectangles.

+
Parameters
+ + +
rectangleRectangle to test
+
+
+
Returns
True if rectangles overlap, false otherwise
+
See also
contains
+ +
+
+ +

◆ intersects() [2/2]

+ +
+
+
+template<typename T >
+ + + + + + + + + + + + + + + + + + +
bool sf::Rect< T >::intersects (const Rect< T > & rectangle,
Rect< T > & intersection 
) const
+
+ +

Check the intersection between two rectangles.

+

This overload returns the overlapped rectangle in the intersection parameter.

+
Parameters
+ + + +
rectangleRectangle to test
intersectionRectangle to be filled with the intersection
+
+
+
Returns
True if rectangles overlap, false otherwise
+
See also
contains
+ +
+
+

Friends And Related Function Documentation

+ +

◆ operator!=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (const Rect< T > & left,
const Rect< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator !=.

+

This operator compares strict difference between two rectangles.

+
Parameters
+ + + +
leftLeft operand (a rectangle)
rightRight operand (a rectangle)
+
+
+
Returns
True if left is not equal to right
+ +
+
+ +

◆ operator==()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (const Rect< T > & left,
const Rect< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator ==.

+

This operator compares strict equality between two rectangles.

+
Parameters
+ + + +
leftLeft operand (a rectangle)
rightRight operand (a rectangle)
+
+
+
Returns
True if left is equal to right
+ +
+
+

Member Data Documentation

+ +

◆ height

+ +
+
+
+template<typename T >
+ + + + +
T sf::Rect< T >::height
+
+ +

Height of the rectangle.

+ +

Definition at line 180 of file Rect.hpp.

+ +
+
+ +

◆ left

+ +
+
+
+template<typename T >
+ + + + +
T sf::Rect< T >::left
+
+ +

Left coordinate of the rectangle.

+ +

Definition at line 177 of file Rect.hpp.

+ +
+
+ +

◆ top

+ +
+
+
+template<typename T >
+ + + + +
T sf::Rect< T >::top
+
+ +

Top coordinate of the rectangle.

+ +

Definition at line 178 of file Rect.hpp.

+ +
+
+ +

◆ width

+ +
+
+
+template<typename T >
+ + + + +
T sf::Rect< T >::width
+
+ +

Width of the rectangle.

+ +

Definition at line 179 of file Rect.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RectangleShape-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1RectangleShape-members.html new file mode 100644 index 000000000..e637fcec7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1RectangleShape-members.html @@ -0,0 +1,149 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::RectangleShape Member List
+
+
+ +

This is the complete list of members for sf::RectangleShape, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
getFillColor() constsf::Shape
getGlobalBounds() constsf::Shape
getInverseTransform() constsf::Transformable
getLocalBounds() constsf::Shape
getOrigin() constsf::Transformable
getOutlineColor() constsf::Shape
getOutlineThickness() constsf::Shape
getPoint(std::size_t index) constsf::RectangleShapevirtual
getPointCount() constsf::RectangleShapevirtual
getPosition() constsf::Transformable
getRotation() constsf::Transformable
getScale() constsf::Transformable
getSize() constsf::RectangleShape
getTexture() constsf::Shape
getTextureRect() constsf::Shape
getTransform() constsf::Transformable
move(float offsetX, float offsetY)sf::Transformable
move(const Vector2f &offset)sf::Transformable
RectangleShape(const Vector2f &size=Vector2f(0, 0))sf::RectangleShapeexplicit
rotate(float angle)sf::Transformable
scale(float factorX, float factorY)sf::Transformable
scale(const Vector2f &factor)sf::Transformable
setFillColor(const Color &color)sf::Shape
setOrigin(float x, float y)sf::Transformable
setOrigin(const Vector2f &origin)sf::Transformable
setOutlineColor(const Color &color)sf::Shape
setOutlineThickness(float thickness)sf::Shape
setPosition(float x, float y)sf::Transformable
setPosition(const Vector2f &position)sf::Transformable
setRotation(float angle)sf::Transformable
setScale(float factorX, float factorY)sf::Transformable
setScale(const Vector2f &factors)sf::Transformable
setSize(const Vector2f &size)sf::RectangleShape
setTexture(const Texture *texture, bool resetRect=false)sf::Shape
setTextureRect(const IntRect &rect)sf::Shape
Shape()sf::Shapeprotected
Transformable()sf::Transformable
update()sf::Shapeprotected
~Drawable()sf::Drawableinlinevirtual
~Shape()sf::Shapevirtual
~Transformable()sf::Transformablevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RectangleShape.html b/Space-Invaders/sfml/doc/html/classsf_1_1RectangleShape.html new file mode 100644 index 000000000..e5d62fb7f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1RectangleShape.html @@ -0,0 +1,1508 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Protected Member Functions | +List of all members
+
sf::RectangleShape Class Reference
Graphics module
+
+
+ +

Specialized shape representing a rectangle. + More...

+ +

#include <SFML/Graphics/RectangleShape.hpp>

+
+Inheritance diagram for sf::RectangleShape:
+
+
+ + +sf::Shape +sf::Drawable +sf::Transformable + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 RectangleShape (const Vector2f &size=Vector2f(0, 0))
 Default constructor.
 
void setSize (const Vector2f &size)
 Set the size of the rectangle.
 
const Vector2f & getSize () const
 Get the size of the rectangle.
 
virtual std::size_t getPointCount () const
 Get the number of points defining the shape.
 
virtual Vector2f getPoint (std::size_t index) const
 Get a point of the rectangle.
 
void setTexture (const Texture *texture, bool resetRect=false)
 Change the source texture of the shape.
 
void setTextureRect (const IntRect &rect)
 Set the sub-rectangle of the texture that the shape will display.
 
void setFillColor (const Color &color)
 Set the fill color of the shape.
 
void setOutlineColor (const Color &color)
 Set the outline color of the shape.
 
void setOutlineThickness (float thickness)
 Set the thickness of the shape's outline.
 
const Texture * getTexture () const
 Get the source texture of the shape.
 
const IntRect & getTextureRect () const
 Get the sub-rectangle of the texture displayed by the shape.
 
const Color & getFillColor () const
 Get the fill color of the shape.
 
const Color & getOutlineColor () const
 Get the outline color of the shape.
 
float getOutlineThickness () const
 Get the outline thickness of the shape.
 
FloatRect getLocalBounds () const
 Get the local bounding rectangle of the entity.
 
FloatRect getGlobalBounds () const
 Get the global (non-minimal) bounding rectangle of the entity.
 
void setPosition (float x, float y)
 set the position of the object
 
void setPosition (const Vector2f &position)
 set the position of the object
 
void setRotation (float angle)
 set the orientation of the object
 
void setScale (float factorX, float factorY)
 set the scale factors of the object
 
void setScale (const Vector2f &factors)
 set the scale factors of the object
 
void setOrigin (float x, float y)
 set the local origin of the object
 
void setOrigin (const Vector2f &origin)
 set the local origin of the object
 
const Vector2f & getPosition () const
 get the position of the object
 
float getRotation () const
 get the orientation of the object
 
const Vector2f & getScale () const
 get the current scale of the object
 
const Vector2f & getOrigin () const
 get the local origin of the object
 
void move (float offsetX, float offsetY)
 Move the object by a given offset.
 
void move (const Vector2f &offset)
 Move the object by a given offset.
 
void rotate (float angle)
 Rotate the object.
 
void scale (float factorX, float factorY)
 Scale the object.
 
void scale (const Vector2f &factor)
 Scale the object.
 
const Transform & getTransform () const
 get the combined transform of the object
 
const Transform & getInverseTransform () const
 get the inverse of the combined transform of the object
 
+ + + + +

+Protected Member Functions

void update ()
 Recompute the internal geometry of the shape.
 
+

Detailed Description

+

Specialized shape representing a rectangle.

+

This class inherits all the functions of sf::Transformable (position, rotation, scale, bounds, ...) as well as the functions of sf::Shape (outline, color, texture, ...).

+

Usage example:

sf::RectangleShape rectangle;
+
rectangle.setSize(sf::Vector2f(100, 50));
+
rectangle.setOutlineColor(sf::Color::Red);
+
rectangle.setOutlineThickness(5);
+
rectangle.setPosition(10, 20);
+
...
+
window.draw(rectangle);
+
sf::Color::Red
static const Color Red
Red predefined color.
Definition: Color.hpp:85
+
sf::RectangleShape
Specialized shape representing a rectangle.
Definition: RectangleShape.hpp:42
+
sf::RectangleShape::setSize
void setSize(const Vector2f &size)
Set the size of the rectangle.
+
sf::Shape::setOutlineColor
void setOutlineColor(const Color &color)
Set the outline color of the shape.
+
sf::Shape::setOutlineThickness
void setOutlineThickness(float thickness)
Set the thickness of the shape's outline.
+
sf::Transformable::setPosition
void setPosition(float x, float y)
set the position of the object
+ +
See also
sf::Shape, sf::CircleShape, sf::ConvexShape
+ +

Definition at line 41 of file RectangleShape.hpp.

+

Constructor & Destructor Documentation

+ +

◆ RectangleShape()

+ +
+
+ + + + + +
+ + + + + + + + +
sf::RectangleShape::RectangleShape (const Vector2f & size = Vector2f(0, 0))
+ 		+explicit
+
+ +

Default constructor.

+
Parameters
+ + +
sizeSize of the rectangle
+
+
+ +
+
+

Member Function Documentation

+ +

◆ getFillColor()

+ +
+
+ + + + + +
+ + + + + + + +
const Color & sf::Shape::getFillColor () const
+ 		+inherited
+
+ +

Get the fill color of the shape.

+
Returns
Fill color of the shape
+
See also
setFillColor
+ +
+
+ +

◆ getGlobalBounds()

+ +
+
+ + + + + +
+ + + + + + + +
FloatRect sf::Shape::getGlobalBounds () const
+ 		+inherited
+
+ +

Get the global (non-minimal) bounding rectangle of the entity.

+

The returned rectangle is in global coordinates, which means that it takes into account the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the shape in the global 2D world's coordinate system.

+

This function does not necessarily return the minimal bounding rectangle. It merely ensures that the returned rectangle covers all the vertices (but possibly more). This allows for a fast approximation of the bounds as a first check; you may want to use more precise checks on top of that.

+
Returns
Global bounding rectangle of the entity
+ +
+
+ +

◆ getInverseTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getInverseTransform () const
+ 		+inherited
+
+ +

get the inverse of the combined transform of the object

+
Returns
Inverse of the combined transformations applied to the object
+
See also
getTransform
+ +
+
+ +

◆ getLocalBounds()

+ +
+
+ + + + + +
+ + + + + + + +
FloatRect sf::Shape::getLocalBounds () const
+ 		+inherited
+
+ +

Get the local bounding rectangle of the entity.

+

The returned rectangle is in local coordinates, which means that it ignores the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the entity in the entity's coordinate system.

+
Returns
Local bounding rectangle of the entity
+ +
+
+ +

◆ getOrigin()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getOrigin () const
+ 		+inherited
+
+ +

get the local origin of the object

+
Returns
Current origin
+
See also
setOrigin
+ +
+
+ +

◆ getOutlineColor()

+ +
+
+ + + + + +
+ + + + + + + +
const Color & sf::Shape::getOutlineColor () const
+ 		+inherited
+
+ +

Get the outline color of the shape.

+
Returns
Outline color of the shape
+
See also
setOutlineColor
+ +
+
+ +

◆ getOutlineThickness()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::Shape::getOutlineThickness () const
+ 		+inherited
+
+ +

Get the outline thickness of the shape.

+
Returns
Outline thickness of the shape
+
See also
setOutlineThickness
+ +
+
+ +

◆ getPoint()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual Vector2f sf::RectangleShape::getPoint (std::size_t index) const
+ 		+virtual
+
+ +

Get a point of the rectangle.

+

The returned point is in local coordinates, that is, the shape's transforms (position, rotation, scale) are not taken into account. The result is undefined if index is out of the valid range.

+
Parameters
+ + +
indexIndex of the point to get, in range [0 .. 3]
+
+
+
Returns
index-th point of the shape
+ +

Implements sf::Shape.

+ +
+
+ +

◆ getPointCount()

+ +
+
+ + + + + +
+ + + + + + + +
virtual std::size_t sf::RectangleShape::getPointCount () const
+ 		+virtual
+
+ +

Get the number of points defining the shape.

+
Returns
Number of points of the shape. For rectangle shapes, this number is always 4.
+ +

Implements sf::Shape.

+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getPosition () const
+ 		+inherited
+
+ +

get the position of the object

+
Returns
Current position
+
See also
setPosition
+ +
+
+ +

◆ getRotation()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::Transformable::getRotation () const
+ 		+inherited
+
+ +

get the orientation of the object

+

The rotation is always in the range [0, 360].

+
Returns
Current rotation, in degrees
+
See also
setRotation
+ +
+
+ +

◆ getScale()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getScale () const
+ 		+inherited
+
+ +

get the current scale of the object

+
Returns
Current scale factors
+
See also
setScale
+ +
+
+ +

◆ getSize()

+ +
+
+ + + + + + + +
const Vector2f & sf::RectangleShape::getSize () const
+
+ +

Get the size of the rectangle.

+
Returns
Size of the rectangle
+
See also
setSize
+ +
+
+ +

◆ getTexture()

+ +
+
+ + + + + +
+ + + + + + + +
const Texture * sf::Shape::getTexture () const
+ 		+inherited
+
+ +

Get the source texture of the shape.

+

If the shape has no source texture, a NULL pointer is returned. The returned pointer is const, which means that you can't modify the texture when you retrieve it with this function.

+
Returns
Pointer to the shape's texture
+
See also
setTexture
+ +
+
+ +

◆ getTextureRect()

+ +
+
+ + + + + +
+ + + + + + + +
const IntRect & sf::Shape::getTextureRect () const
+ 		+inherited
+
+ +

Get the sub-rectangle of the texture displayed by the shape.

+
Returns
Texture rectangle of the shape
+
See also
setTextureRect
+ +
+
+ +

◆ getTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getTransform () const
+ 		+inherited
+
+ +

get the combined transform of the object

+
Returns
Transform combining the position/rotation/scale/origin of the object
+
See also
getInverseTransform
+ +
+
+ +

◆ move() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::move (const Vector2f & offset)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

object.setPosition(object.getPosition() + offset);
+
sf::Transformable::getPosition
const Vector2f & getPosition() const
get the position of the object
+
Parameters
+ + +
offsetOffset
+
+
+
See also
setPosition
+ +
+
+ +

◆ move() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::move (float offsetX,
float offsetY 
)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f pos = object.getPosition();
+
object.setPosition(pos.x + offsetX, pos.y + offsetY);
+
sf::Vector2::x
T x
X coordinate of the vector.
Definition: Vector2.hpp:75
+
sf::Vector2::y
T y
Y coordinate of the vector.
Definition: Vector2.hpp:76
+
Parameters
+ + + +
offsetXX offset
offsetYY offset
+
+
+
See also
setPosition
+ +
+
+ +

◆ rotate()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::rotate (float angle)
+ 		+inherited
+
+ +

Rotate the object.

+

This function adds to the current rotation of the object, unlike setRotation which overwrites it. Thus, it is equivalent to the following code:

object.setRotation(object.getRotation() + angle);
+
sf::Transformable::getRotation
float getRotation() const
get the orientation of the object
+
Parameters
+ + +
angleAngle of rotation, in degrees
+
+
+ +
+
+ +

◆ scale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::scale (const Vector2f & factor)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factor.x, scale.y * factor.y);
+
sf::Transformable::scale
void scale(float factorX, float factorY)
Scale the object.
+
Parameters
+ + +
factorScale factors
+
+
+
See also
setScale
+ +
+
+ +

◆ scale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::scale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factorX, scale.y * factorY);
+
Parameters
+ + + +
factorXHorizontal scale factor
factorYVertical scale factor
+
+
+
See also
setScale
+ +
+
+ +

◆ setFillColor()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setFillColor (const Color & color)
+ 		+inherited
+
+ +

Set the fill color of the shape.

+

This color is modulated (multiplied) with the shape's texture if any. It can be used to colorize the shape, or change its global opacity. You can use sf::Color::Transparent to make the inside of the shape transparent, and have the outline alone. By default, the shape's fill color is opaque white.

+
Parameters
+ + +
colorNew color of the shape
+
+
+
See also
getFillColor, setOutlineColor
+ +
+
+ +

◆ setOrigin() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setOrigin (const Vector2f & origin)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + +
originNew origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOrigin() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setOrigin (float x,
float y 
)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new origin
yY coordinate of the new origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOutlineColor()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setOutlineColor (const Color & color)
+ 		+inherited
+
+ +

Set the outline color of the shape.

+

By default, the shape's outline color is opaque white.

+
Parameters
+ + +
colorNew outline color of the shape
+
+
+
See also
getOutlineColor, setFillColor
+ +
+
+ +

◆ setOutlineThickness()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setOutlineThickness (float thickness)
+ 		+inherited
+
+ +

Set the thickness of the shape's outline.

+

Note that negative values are allowed (so that the outline expands towards the center of the shape), and using zero disables the outline. By default, the outline thickness is 0.

+
Parameters
+ + +
thicknessNew outline thickness
+
+
+
See also
getOutlineThickness
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setPosition (const Vector2f & position)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + +
positionNew position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setPosition (float x,
float y 
)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new position
yY coordinate of the new position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setRotation()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setRotation (float angle)
+ 		+inherited
+
+ +

set the orientation of the object

+

This function completely overwrites the previous rotation. See the rotate function to add an angle based on the previous rotation instead. The default rotation of a transformable object is 0.

+
Parameters
+ + +
angleNew rotation, in degrees
+
+
+
See also
rotate, getRotation
+ +
+
+ +

◆ setScale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setScale (const Vector2f & factors)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + +
factorsNew scale factors
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setScale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setScale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + + +
factorXNew horizontal scale factor
factorYNew vertical scale factor
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setSize()

+ +
+
+ + + + + + + + +
void sf::RectangleShape::setSize (const Vector2f & size)
+
+ +

Set the size of the rectangle.

+
Parameters
+ + +
sizeNew size of the rectangle
+
+
+
See also
getSize
+ +
+
+ +

◆ setTexture()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Shape::setTexture (const Texture * texture,
bool resetRect = false 
)
+ 		+inherited
+
+ +

Change the source texture of the shape.

+

The texture argument refers to a texture that must exist as long as the shape uses it. Indeed, the shape doesn't store its own copy of the texture, but rather keeps a pointer to the one that you passed to this function. If the source texture is destroyed and the shape tries to use it, the behavior is undefined. texture can be NULL to disable texturing. If resetRect is true, the TextureRect property of the shape is automatically adjusted to the size of the new texture. If it is false, the texture rect is left unchanged.

+
Parameters
+ + + +
textureNew texture
resetRectShould the texture rect be reset to the size of the new texture?
+
+
+
See also
getTexture, setTextureRect
+ +
+
+ +

◆ setTextureRect()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Shape::setTextureRect (const IntRect & rect)
+ 		+inherited
+
+ +

Set the sub-rectangle of the texture that the shape will display.

+

The texture rect is useful when you don't want to display the whole texture, but rather a part of it. By default, the texture rect covers the entire texture.

+
Parameters
+ + +
rectRectangle defining the region of the texture to display
+
+
+
See also
getTextureRect, setTexture
+ +
+
+ +

◆ update()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Shape::update ()
+ 		+protectedinherited
+
+ +

Recompute the internal geometry of the shape.

+

This function must be called by the derived class everytime the shape's points change (i.e. the result of either getPointCount or getPoint is different).

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RectangleShape.png b/Space-Invaders/sfml/doc/html/classsf_1_1RectangleShape.png new file mode 100644 index 000000000..5fe54077c Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1RectangleShape.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderStates-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1RenderStates-members.html new file mode 100644 index 000000000..9dbe45964 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1RenderStates-members.html @@ -0,0 +1,119 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::RenderStates Member List
+
+
+ +

This is the complete list of members for sf::RenderStates, including all inherited members.

+ + + + + + + + + + + + +
blendModesf::RenderStates
Defaultsf::RenderStatesstatic
RenderStates()sf::RenderStates
RenderStates(const BlendMode &theBlendMode)sf::RenderStates
RenderStates(const Transform &theTransform)sf::RenderStates
RenderStates(const Texture *theTexture)sf::RenderStates
RenderStates(const Shader *theShader)sf::RenderStates
RenderStates(const BlendMode &theBlendMode, const Transform &theTransform, const Texture *theTexture, const Shader *theShader)sf::RenderStates
shadersf::RenderStates
texturesf::RenderStates
transformsf::RenderStates
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderStates.html b/Space-Invaders/sfml/doc/html/classsf_1_1RenderStates.html new file mode 100644 index 000000000..a7950b7f6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1RenderStates.html @@ -0,0 +1,459 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Public Attributes | +Static Public Attributes | +List of all members
+
sf::RenderStates Class Reference
Graphics module
+
+
+ +

Define the states used for drawing to a RenderTarget. + More...

+ +

#include <SFML/Graphics/RenderStates.hpp>

+ + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 RenderStates ()
 Default constructor.
 
 RenderStates (const BlendMode &theBlendMode)
 Construct a default set of render states with a custom blend mode.
 
 RenderStates (const Transform &theTransform)
 Construct a default set of render states with a custom transform.
 
 RenderStates (const Texture *theTexture)
 Construct a default set of render states with a custom texture.
 
 RenderStates (const Shader *theShader)
 Construct a default set of render states with a custom shader.
 
 RenderStates (const BlendMode &theBlendMode, const Transform &theTransform, const Texture *theTexture, const Shader *theShader)
 Construct a set of render states with all its attributes.
 
+ + + + + + + + + + + + + +

+Public Attributes

BlendMode blendMode
 Blending mode.
 
Transform transform
 Transform.
 
const Texture * texture
 Texture.
 
const Shader * shader
 Shader.
 
+ + + + +

+Static Public Attributes

static const RenderStates Default
 Special instance holding the default render states.
 
+

Detailed Description

+

Define the states used for drawing to a RenderTarget.

+

There are four global states that can be applied to the drawn objects:

+
    +
  • the blend mode: how pixels of the object are blended with the background
    • +
  • the transform: how the object is positioned/rotated/scaled
    • +
  • the texture: what image is mapped to the object
    • +
  • the shader: what custom effect is applied to the object
    • +
+

High-level objects such as sprites or text force some of these states when they are drawn. For example, a sprite will set its own texture, so that you don't have to care about it when drawing the sprite.

+

The transform is a special case: sprites, texts and shapes (and it's a good idea to do it with your own drawable classes too) combine their transform with the one that is passed in the RenderStates structure. So that you can use a "global" transform on top of each object's transform.

+

Most objects, especially high-level drawables, can be drawn directly without defining render states explicitly – the default set of states is ok in most cases.

window.draw(sprite);
+

If you want to use a single specific render state, for example a shader, you can pass it directly to the Draw function: sf::RenderStates has an implicit one-argument constructor for each state.

window.draw(sprite, shader);
+
sf::RenderStates::shader
const Shader * shader
Shader.
Definition: RenderStates.hpp:118
+

When you're inside the Draw function of a drawable object (inherited from sf::Drawable), you can either pass the render states unmodified, or change some of them. For example, a transformable object will combine the current transform with its own transform. A sprite will set its texture. Etc.

+
See also
sf::RenderTarget, sf::Drawable
+ +

Definition at line 45 of file RenderStates.hpp.

+

Constructor & Destructor Documentation

+ +

◆ RenderStates() [1/6]

+ +
+
+ + + + + + + +
sf::RenderStates::RenderStates ()
+
+ +

Default constructor.

+

Constructing a default set of render states is equivalent to using sf::RenderStates::Default. The default set defines:

    +
  • the BlendAlpha blend mode
    • +
  • the identity transform
    • +
  • a null texture
    • +
  • a null shader
    • +
+ +
+
+ +

◆ RenderStates() [2/6]

+ +
+
+ + + + + + + + +
sf::RenderStates::RenderStates (const BlendMode & theBlendMode)
+
+ +

Construct a default set of render states with a custom blend mode.

+
Parameters
+ + +
theBlendModeBlend mode to use
+
+
+ +
+
+ +

◆ RenderStates() [3/6]

+ +
+
+ + + + + + + + +
sf::RenderStates::RenderStates (const Transform & theTransform)
+
+ +

Construct a default set of render states with a custom transform.

+
Parameters
+ + +
theTransformTransform to use
+
+
+ +
+
+ +

◆ RenderStates() [4/6]

+ +
+
+ + + + + + + + +
sf::RenderStates::RenderStates (const Texture * theTexture)
+
+ +

Construct a default set of render states with a custom texture.

+
Parameters
+ + +
theTextureTexture to use
+
+
+ +
+
+ +

◆ RenderStates() [5/6]

+ +
+
+ + + + + + + + +
sf::RenderStates::RenderStates (const Shader * theShader)
+
+ +

Construct a default set of render states with a custom shader.

+
Parameters
+ + +
theShaderShader to use
+
+
+ +
+
+ +

◆ RenderStates() [6/6]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sf::RenderStates::RenderStates (const BlendMode & theBlendMode,
const Transform & theTransform,
const Texture * theTexture,
const Shader * theShader 
)
+
+ +

Construct a set of render states with all its attributes.

+
Parameters
+ + + + + +
theBlendModeBlend mode to use
theTransformTransform to use
theTextureTexture to use
theShaderShader to use
+
+
+ +
+
+

Member Data Documentation

+ +

◆ blendMode

+ +
+
+ + + + +
BlendMode sf::RenderStates::blendMode
+
+ +

Blending mode.

+ +

Definition at line 115 of file RenderStates.hpp.

+ +
+
+ +

◆ Default

+ +
+
+ + + + + +
+ + + + +
const RenderStates sf::RenderStates::Default
+ 		+static
+
+ +

Special instance holding the default render states.

+ +

Definition at line 110 of file RenderStates.hpp.

+ +
+
+ +

◆ shader

+ +
+
+ + + + +
const Shader* sf::RenderStates::shader
+
+ +

Shader.

+ +

Definition at line 118 of file RenderStates.hpp.

+ +
+
+ +

◆ texture

+ +
+
+ + + + +
const Texture* sf::RenderStates::texture
+
+ +

Texture.

+ +

Definition at line 117 of file RenderStates.hpp.

+ +
+
+ +

◆ transform

+ +
+
+ + + + +
Transform sf::RenderStates::transform
+
+ +

Transform.

+ +

Definition at line 116 of file RenderStates.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderTarget-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTarget-members.html new file mode 100644 index 000000000..e2056d496 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTarget-members.html @@ -0,0 +1,130 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::RenderTarget Member List
+
+
+ +

This is the complete list of members for sf::RenderTarget, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + +
clear(const Color &color=Color(0, 0, 0, 255))sf::RenderTarget
draw(const Drawable &drawable, const RenderStates &states=RenderStates::Default)sf::RenderTarget
draw(const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default)sf::RenderTarget
draw(const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default)sf::RenderTarget
draw(const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default)sf::RenderTarget
getDefaultView() constsf::RenderTarget
getSize() const =0sf::RenderTargetpure virtual
getView() constsf::RenderTarget
getViewport(const View &view) constsf::RenderTarget
initialize()sf::RenderTargetprotected
isSrgb() constsf::RenderTargetvirtual
mapCoordsToPixel(const Vector2f &point) constsf::RenderTarget
mapCoordsToPixel(const Vector2f &point, const View &view) constsf::RenderTarget
mapPixelToCoords(const Vector2i &point) constsf::RenderTarget
mapPixelToCoords(const Vector2i &point, const View &view) constsf::RenderTarget
popGLStates()sf::RenderTarget
pushGLStates()sf::RenderTarget
RenderTarget()sf::RenderTargetprotected
resetGLStates()sf::RenderTarget
setActive(bool active=true)sf::RenderTargetvirtual
setView(const View &view)sf::RenderTarget
~RenderTarget()sf::RenderTargetvirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderTarget.html b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTarget.html new file mode 100644 index 000000000..50b69c209 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTarget.html @@ -0,0 +1,917 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Member Functions | +Protected Member Functions | +List of all members
+
sf::RenderTarget Class Referenceabstract
Graphics module
+
+
+ +

Base class for all render targets (window, texture, ...) + More...

+ +

#include <SFML/Graphics/RenderTarget.hpp>

+
+Inheritance diagram for sf::RenderTarget:
+
+
+ + +sf::NonCopyable +sf::RenderTexture +sf::RenderWindow + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

virtual ~RenderTarget ()
 Destructor.
 
void clear (const Color &color=Color(0, 0, 0, 255))
 Clear the entire target with a single color.
 
void setView (const View &view)
 Change the current active view.
 
const View & getView () const
 Get the view currently in use in the render target.
 
const View & getDefaultView () const
 Get the default view of the render target.
 
IntRect getViewport (const View &view) const
 Get the viewport of a view, applied to this render target.
 
Vector2f mapPixelToCoords (const Vector2i &point) const
 Convert a point from target coordinates to world coordinates, using the current view.
 
Vector2f mapPixelToCoords (const Vector2i &point, const View &view) const
 Convert a point from target coordinates to world coordinates.
 
Vector2i mapCoordsToPixel (const Vector2f &point) const
 Convert a point from world coordinates to target coordinates, using the current view.
 
Vector2i mapCoordsToPixel (const Vector2f &point, const View &view) const
 Convert a point from world coordinates to target coordinates.
 
void draw (const Drawable &drawable, const RenderStates &states=RenderStates::Default)
 Draw a drawable object to the render target.
 
void draw (const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default)
 Draw primitives defined by an array of vertices.
 
void draw (const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default)
 Draw primitives defined by a vertex buffer.
 
void draw (const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default)
 Draw primitives defined by a vertex buffer.
 
virtual Vector2u getSize () const =0
 Return the size of the rendering region of the target.
 
virtual bool isSrgb () const
 Tell if the render target will use sRGB encoding when drawing on it.
 
virtual bool setActive (bool active=true)
 Activate or deactivate the render target for rendering.
 
void pushGLStates ()
 Save the current OpenGL render states and matrices.
 
void popGLStates ()
 Restore the previously saved OpenGL render states and matrices.
 
void resetGLStates ()
 Reset the internal OpenGL states so that the target is ready for drawing.
 
+ + + + + + + +

+Protected Member Functions

 RenderTarget ()
 Default constructor.
 
void initialize ()
 Performs the common initialization step after creation.
 
+

Detailed Description

+

Base class for all render targets (window, texture, ...)

+

sf::RenderTarget defines the common behavior of all the 2D render targets usable in the graphics module.

+

It makes it possible to draw 2D entities like sprites, shapes, text without using any OpenGL command directly.

+

A sf::RenderTarget is also able to use views (sf::View), which are a kind of 2D cameras. With views you can globally scroll, rotate or zoom everything that is drawn, without having to transform every single entity. See the documentation of sf::View for more details and sample pieces of code about this class.

+

On top of that, render targets are still able to render direct OpenGL stuff. It is even possible to mix together OpenGL calls and regular SFML drawing commands. When doing so, make sure that OpenGL states are not messed up by calling the pushGLStates/popGLStates functions.

+
See also
sf::RenderWindow, sf::RenderTexture, sf::View
+ +

Definition at line 52 of file RenderTarget.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ~RenderTarget()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::RenderTarget::~RenderTarget ()
+ 		+virtual
+
+ +

Destructor.

+ +
+
+ +

◆ RenderTarget()

+ +
+
+ + + + + +
+ + + + + + + +
sf::RenderTarget::RenderTarget ()
+ 		+protected
+
+ +

Default constructor.

+ +
+
+

Member Function Documentation

+ +

◆ clear()

+ +
+
+ + + + + + + + +
void sf::RenderTarget::clear (const Color & color = Color(0, 0, 0, 255))
+
+ +

Clear the entire target with a single color.

+

This function is usually called once every frame, to clear the previous contents of the target.

+
Parameters
+ + +
colorFill color to use to clear the render target
+
+
+ +
+
+ +

◆ draw() [1/4]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const Drawable & drawable,
const RenderStates & states = RenderStates::Default 
)
+
+ +

Draw a drawable object to the render target.

+
Parameters
+ + + +
drawableObject to draw
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ draw() [2/4]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const Vertex * vertices,
std::size_t vertexCount,
PrimitiveType type,
const RenderStates & states = RenderStates::Default 
)
+
+ +

Draw primitives defined by an array of vertices.

+
Parameters
+ + + + + +
verticesPointer to the vertices
vertexCountNumber of vertices in the array
typeType of primitives to draw
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ draw() [3/4]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const VertexBuffer & vertexBuffer,
const RenderStates & states = RenderStates::Default 
)
+
+ +

Draw primitives defined by a vertex buffer.

+
Parameters
+ + + +
vertexBufferVertex buffer
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ draw() [4/4]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const VertexBuffer & vertexBuffer,
std::size_t firstVertex,
std::size_t vertexCount,
const RenderStates & states = RenderStates::Default 
)
+
+ +

Draw primitives defined by a vertex buffer.

+
Parameters
+ + + + + +
vertexBufferVertex buffer
firstVertexIndex of the first vertex to render
vertexCountNumber of vertices to render
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ getDefaultView()

+ +
+
+ + + + + + + +
const View & sf::RenderTarget::getDefaultView () const
+
+ +

Get the default view of the render target.

+

The default view has the initial size of the render target, and never changes after the target has been created.

+
Returns
The default view of the render target
+
See also
setView, getView
+ +
+
+ +

◆ getSize()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Vector2u sf::RenderTarget::getSize () const
+ 		+pure virtual
+
+ +

Return the size of the rendering region of the target.

+
Returns
Size in pixels
+ +

Implemented in sf::RenderTexture, and sf::RenderWindow.

+ +
+
+ +

◆ getView()

+ +
+
+ + + + + + + +
const View & sf::RenderTarget::getView () const
+
+ +

Get the view currently in use in the render target.

+
Returns
The view object that is currently used
+
See also
setView, getDefaultView
+ +
+
+ +

◆ getViewport()

+ +
+
+ + + + + + + + +
IntRect sf::RenderTarget::getViewport (const View & view) const
+
+ +

Get the viewport of a view, applied to this render target.

+

The viewport is defined in the view as a ratio, this function simply applies this ratio to the current dimensions of the render target to calculate the pixels rectangle that the viewport actually covers in the target.

+
Parameters
+ + +
viewThe view for which we want to compute the viewport
+
+
+
Returns
Viewport rectangle, expressed in pixels
+ +
+
+ +

◆ initialize()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::RenderTarget::initialize ()
+ 		+protected
+
+ +

Performs the common initialization step after creation.

+

The derived classes must call this function after the target is created and ready for drawing.

+ +
+
+ +

◆ isSrgb()

+ +
+
+ + + + + +
+ + + + + + + +
virtual bool sf::RenderTarget::isSrgb () const
+ 		+virtual
+
+ +

Tell if the render target will use sRGB encoding when drawing on it.

+
Returns
True if the render target use sRGB encoding, false otherwise
+ +

Reimplemented in sf::RenderTexture, and sf::RenderWindow.

+ +
+
+ +

◆ mapCoordsToPixel() [1/2]

+ +
+
+ + + + + + + + +
Vector2i sf::RenderTarget::mapCoordsToPixel (const Vector2f & point) const
+
+ +

Convert a point from world coordinates to target coordinates, using the current view.

+

This function is an overload of the mapCoordsToPixel function that implicitly uses the current view. It is equivalent to:

target.mapCoordsToPixel(point, target.getView());
+
Parameters
+ + +
pointPoint to convert
+
+
+
Returns
The converted point, in target coordinates (pixels)
+
See also
mapPixelToCoords
+ +
+
+ +

◆ mapCoordsToPixel() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
Vector2i sf::RenderTarget::mapCoordsToPixel (const Vector2f & point,
const View & view 
) const
+
+ +

Convert a point from world coordinates to target coordinates.

+

This function finds the pixel of the render target that matches the given 2D point. In other words, it goes through the same process as the graphics card, to compute the final position of a rendered point.

+

Initially, both coordinate systems (world units and target pixels) match perfectly. But if you define a custom view or resize your render target, this assertion is not true anymore, i.e. a point located at (150, 75) in your 2D world may map to the pixel (10, 50) of your render target – if the view is translated by (140, 25).

+

This version uses a custom view for calculations, see the other overload of the function if you want to use the current view of the render target.

+
Parameters
+ + + +
pointPoint to convert
viewThe view to use for converting the point
+
+
+
Returns
The converted point, in target coordinates (pixels)
+
See also
mapPixelToCoords
+ +
+
+ +

◆ mapPixelToCoords() [1/2]

+ +
+
+ + + + + + + + +
Vector2f sf::RenderTarget::mapPixelToCoords (const Vector2i & point) const
+
+ +

Convert a point from target coordinates to world coordinates, using the current view.

+

This function is an overload of the mapPixelToCoords function that implicitly uses the current view. It is equivalent to:

target.mapPixelToCoords(point, target.getView());
+
Parameters
+ + +
pointPixel to convert
+
+
+
Returns
The converted point, in "world" coordinates
+
See also
mapCoordsToPixel
+ +
+
+ +

◆ mapPixelToCoords() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
Vector2f sf::RenderTarget::mapPixelToCoords (const Vector2i & point,
const View & view 
) const
+
+ +

Convert a point from target coordinates to world coordinates.

+

This function finds the 2D position that matches the given pixel of the render target. In other words, it does the inverse of what the graphics card does, to find the initial position of a rendered pixel.

+

Initially, both coordinate systems (world units and target pixels) match perfectly. But if you define a custom view or resize your render target, this assertion is not true anymore, i.e. a point located at (10, 50) in your render target may map to the point (150, 75) in your 2D world – if the view is translated by (140, 25).

+

For render-windows, this function is typically used to find which point (or object) is located below the mouse cursor.

+

This version uses a custom view for calculations, see the other overload of the function if you want to use the current view of the render target.

+
Parameters
+ + + +
pointPixel to convert
viewThe view to use for converting the point
+
+
+
Returns
The converted point, in "world" units
+
See also
mapCoordsToPixel
+ +
+
+ +

◆ popGLStates()

+ +
+
+ + + + + + + +
void sf::RenderTarget::popGLStates ()
+
+ +

Restore the previously saved OpenGL render states and matrices.

+

See the description of pushGLStates to get a detailed description of these functions.

+
See also
pushGLStates
+ +
+
+ +

◆ pushGLStates()

+ +
+
+ + + + + + + +
void sf::RenderTarget::pushGLStates ()
+
+ +

Save the current OpenGL render states and matrices.

+

This function can be used when you mix SFML drawing and direct OpenGL rendering. Combined with popGLStates, it ensures that:

    +
  • SFML's internal states are not messed up by your OpenGL code
    • +
  • your OpenGL states are not modified by a call to a SFML function
    • +
+

More specifically, it must be used around code that calls Draw functions. Example:

// OpenGL code here...
+
window.pushGLStates();
+
window.draw(...);
+
window.draw(...);
+
window.popGLStates();
+
// OpenGL code here...
+

Note that this function is quite expensive: it saves all the possible OpenGL states and matrices, even the ones you don't care about. Therefore it should be used wisely. It is provided for convenience, but the best results will be achieved if you handle OpenGL states yourself (because you know which states have really changed, and need to be saved and restored). Take a look at the resetGLStates function if you do so.

+
See also
popGLStates
+ +
+
+ +

◆ resetGLStates()

+ +
+
+ + + + + + + +
void sf::RenderTarget::resetGLStates ()
+
+ +

Reset the internal OpenGL states so that the target is ready for drawing.

+

This function can be used when you mix SFML drawing and direct OpenGL rendering, if you choose not to use pushGLStates/popGLStates. It makes sure that all OpenGL states needed by SFML are set, so that subsequent draw() calls will work as expected.

+

Example:

// OpenGL code here...
+
glPushAttrib(...);
+
window.resetGLStates();
+
window.draw(...);
+
window.draw(...);
+
glPopAttrib(...);
+
// OpenGL code here...
+
+
+
+ +

◆ setActive()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual bool sf::RenderTarget::setActive (bool active = true)
+ 		+virtual
+
+ +

Activate or deactivate the render target for rendering.

+

This function makes the render target's context current for future OpenGL rendering operations (so you shouldn't care about it if you're not doing direct OpenGL stuff). A render target's context is active only on the current thread, if you want to make it active on another thread you have to deactivate it on the previous thread first if it was active. Only one context can be current in a thread, so if you want to draw OpenGL geometry to another render target don't forget to activate it again. Activating a render target will automatically deactivate the previously active context (if any).

+
Parameters
+ + +
activeTrue to activate, false to deactivate
+
+
+
Returns
True if operation was successful, false otherwise
+ +

Reimplemented in sf::RenderTexture, and sf::RenderWindow.

+ +
+
+ +

◆ setView()

+ +
+
+ + + + + + + + +
void sf::RenderTarget::setView (const View & view)
+
+ +

Change the current active view.

+

The view is like a 2D camera, it controls which part of the 2D scene is visible, and how it is viewed in the render target. The new view will affect everything that is drawn, until another view is set. The render target keeps its own copy of the view object, so it is not necessary to keep the original one alive after calling this function. To restore the original view of the target, you can pass the result of getDefaultView() to this function.

+
Parameters
+ + +
viewNew view to use
+
+
+
See also
getView, getDefaultView
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderTarget.png b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTarget.png new file mode 100644 index 000000000..466b447f5 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTarget.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderTexture-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTexture-members.html new file mode 100644 index 000000000..9f1cfb85e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTexture-members.html @@ -0,0 +1,142 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::RenderTexture Member List
+
+
+ +

This is the complete list of members for sf::RenderTexture, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
clear(const Color &color=Color(0, 0, 0, 255))sf::RenderTarget
create(unsigned int width, unsigned int height, bool depthBuffer)sf::RenderTexture
create(unsigned int width, unsigned int height, const ContextSettings &settings=ContextSettings())sf::RenderTexture
display()sf::RenderTexture
draw(const Drawable &drawable, const RenderStates &states=RenderStates::Default)sf::RenderTarget
draw(const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default)sf::RenderTarget
draw(const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default)sf::RenderTarget
draw(const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default)sf::RenderTarget
generateMipmap()sf::RenderTexture
getDefaultView() constsf::RenderTarget
getMaximumAntialiasingLevel()sf::RenderTexturestatic
getSize() constsf::RenderTexturevirtual
getTexture() constsf::RenderTexture
getView() constsf::RenderTarget
getViewport(const View &view) constsf::RenderTarget
initialize()sf::RenderTargetprotected
isRepeated() constsf::RenderTexture
isSmooth() constsf::RenderTexture
isSrgb() constsf::RenderTexturevirtual
mapCoordsToPixel(const Vector2f &point) constsf::RenderTarget
mapCoordsToPixel(const Vector2f &point, const View &view) constsf::RenderTarget
mapPixelToCoords(const Vector2i &point) constsf::RenderTarget
mapPixelToCoords(const Vector2i &point, const View &view) constsf::RenderTarget
popGLStates()sf::RenderTarget
pushGLStates()sf::RenderTarget
RenderTarget()sf::RenderTargetprotected
RenderTexture()sf::RenderTexture
resetGLStates()sf::RenderTarget
setActive(bool active=true)sf::RenderTexturevirtual
setRepeated(bool repeated)sf::RenderTexture
setSmooth(bool smooth)sf::RenderTexture
setView(const View &view)sf::RenderTarget
~RenderTarget()sf::RenderTargetvirtual
~RenderTexture()sf::RenderTexturevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderTexture.html b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTexture.html new file mode 100644 index 000000000..1e93847f8 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTexture.html @@ -0,0 +1,1405 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Static Public Member Functions | +Protected Member Functions | +List of all members
+
sf::RenderTexture Class Reference
Graphics module
+
+
+ +

Target for off-screen 2D rendering into a texture. + More...

+ +

#include <SFML/Graphics/RenderTexture.hpp>

+
+Inheritance diagram for sf::RenderTexture:
+
+
+ + +sf::RenderTarget +sf::NonCopyable + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 RenderTexture ()
 Default constructor.
 
virtual ~RenderTexture ()
 Destructor.
 
bool create (unsigned int width, unsigned int height, bool depthBuffer)
 Create the render-texture.
 
bool create (unsigned int width, unsigned int height, const ContextSettings &settings=ContextSettings())
 Create the render-texture.
 
void setSmooth (bool smooth)
 Enable or disable texture smoothing.
 
bool isSmooth () const
 Tell whether the smooth filtering is enabled or not.
 
void setRepeated (bool repeated)
 Enable or disable texture repeating.
 
bool isRepeated () const
 Tell whether the texture is repeated or not.
 
bool generateMipmap ()
 Generate a mipmap using the current texture data.
 
bool setActive (bool active=true)
 Activate or deactivate the render-texture for rendering.
 
void display ()
 Update the contents of the target texture.
 
virtual Vector2u getSize () const
 Return the size of the rendering region of the texture.
 
virtual bool isSrgb () const
 Tell if the render-texture will use sRGB encoding when drawing on it.
 
const Texture & getTexture () const
 Get a read-only reference to the target texture.
 
void clear (const Color &color=Color(0, 0, 0, 255))
 Clear the entire target with a single color.
 
void setView (const View &view)
 Change the current active view.
 
const View & getView () const
 Get the view currently in use in the render target.
 
const View & getDefaultView () const
 Get the default view of the render target.
 
IntRect getViewport (const View &view) const
 Get the viewport of a view, applied to this render target.
 
Vector2f mapPixelToCoords (const Vector2i &point) const
 Convert a point from target coordinates to world coordinates, using the current view.
 
Vector2f mapPixelToCoords (const Vector2i &point, const View &view) const
 Convert a point from target coordinates to world coordinates.
 
Vector2i mapCoordsToPixel (const Vector2f &point) const
 Convert a point from world coordinates to target coordinates, using the current view.
 
Vector2i mapCoordsToPixel (const Vector2f &point, const View &view) const
 Convert a point from world coordinates to target coordinates.
 
void draw (const Drawable &drawable, const RenderStates &states=RenderStates::Default)
 Draw a drawable object to the render target.
 
void draw (const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default)
 Draw primitives defined by an array of vertices.
 
void draw (const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default)
 Draw primitives defined by a vertex buffer.
 
void draw (const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default)
 Draw primitives defined by a vertex buffer.
 
void pushGLStates ()
 Save the current OpenGL render states and matrices.
 
void popGLStates ()
 Restore the previously saved OpenGL render states and matrices.
 
void resetGLStates ()
 Reset the internal OpenGL states so that the target is ready for drawing.
 
+ + + + +

+Static Public Member Functions

static unsigned int getMaximumAntialiasingLevel ()
 Get the maximum anti-aliasing level supported by the system.
 
+ + + + +

+Protected Member Functions

void initialize ()
 Performs the common initialization step after creation.
 
+

Detailed Description

+

Target for off-screen 2D rendering into a texture.

+

sf::RenderTexture is the little brother of sf::RenderWindow.

+

It implements the same 2D drawing and OpenGL-related functions (see their base class sf::RenderTarget for more details), the difference is that the result is stored in an off-screen texture rather than being show in a window.

+

Rendering to a texture can be useful in a variety of situations:

    +
  • precomputing a complex static texture (like a level's background from multiple tiles)
    • +
  • applying post-effects to the whole scene with shaders
    • +
  • creating a sprite from a 3D object rendered with OpenGL
    • +
  • etc.
    • +
+

Usage example:

+
// Create a new render-window
+
sf::RenderWindow window(sf::VideoMode(800, 600), "SFML window");
+
+
// Create a new render-texture
+
sf::RenderTexture texture;
+
if (!texture.create(500, 500))
+
return -1;
+
+
// The main loop
+
while (window.isOpen())
+
{
+
// Event processing
+
// ...
+
+
// Clear the whole texture with red color
+
texture.clear(sf::Color::Red);
+
+
// Draw stuff to the texture
+
texture.draw(sprite); // sprite is a sf::Sprite
+
texture.draw(shape); // shape is a sf::Shape
+
texture.draw(text); // text is a sf::Text
+
+
// We're done drawing to the texture
+
texture.display();
+
+
// Now we start rendering to the window, clear it first
+
window.clear();
+
+
// Draw the texture
+
sf::Sprite sprite(texture.getTexture());
+
window.draw(sprite);
+
+
// End the current frame and display its contents on screen
+
window.display();
+
}
+
sf::Color::Red
static const Color Red
Red predefined color.
Definition: Color.hpp:85
+
sf::RenderTarget::draw
void draw(const Drawable &drawable, const RenderStates &states=RenderStates::Default)
Draw a drawable object to the render target.
+
sf::RenderTarget::clear
void clear(const Color &color=Color(0, 0, 0, 255))
Clear the entire target with a single color.
+
sf::RenderTexture
Target for off-screen 2D rendering into a texture.
Definition: RenderTexture.hpp:49
+
sf::RenderTexture::create
bool create(unsigned int width, unsigned int height, bool depthBuffer)
Create the render-texture.
+
sf::RenderTexture::getTexture
const Texture & getTexture() const
Get a read-only reference to the target texture.
+
sf::RenderTexture::display
void display()
Update the contents of the target texture.
+
sf::RenderWindow
Window that can serve as a target for 2D drawing.
Definition: RenderWindow.hpp:45
+
sf::Sprite
Drawable representation of a texture, with its own transformations, color, etc.
Definition: Sprite.hpp:48
+
sf::VideoMode
VideoMode defines a video mode (width, height, bpp)
Definition: VideoMode.hpp:42
+

Like sf::RenderWindow, sf::RenderTexture is still able to render direct OpenGL stuff. It is even possible to mix together OpenGL calls and regular SFML drawing commands. If you need a depth buffer for 3D rendering, don't forget to request it when calling RenderTexture::create.

+
See also
sf::RenderTarget, sf::RenderWindow, sf::View, sf::Texture
+ +

Definition at line 48 of file RenderTexture.hpp.

+

Constructor & Destructor Documentation

+ +

◆ RenderTexture()

+ +
+
+ + + + + + + +
sf::RenderTexture::RenderTexture ()
+
+ +

Default constructor.

+

Constructs an empty, invalid render-texture. You must call create to have a valid render-texture.

+
See also
create
+ +
+
+ +

◆ ~RenderTexture()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::RenderTexture::~RenderTexture ()
+ 		+virtual
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ clear()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::RenderTarget::clear (const Color & color = Color(0, 0, 0, 255))
+ 		+inherited
+
+ +

Clear the entire target with a single color.

+

This function is usually called once every frame, to clear the previous contents of the target.

+
Parameters
+ + +
colorFill color to use to clear the render target
+
+
+ +
+
+ +

◆ create() [1/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::RenderTexture::create (unsigned int width,
unsigned int height,
bool depthBuffer 
)
+
+ +

Create the render-texture.

+

Before calling this function, the render-texture is in an invalid state, thus it is mandatory to call it before doing anything with the render-texture. The last parameter, depthBuffer, is useful if you want to use the render-texture for 3D OpenGL rendering that requires a depth buffer. Otherwise it is unnecessary, and you should leave this parameter to false (which is its default value).

+
Parameters
+ + + + +
widthWidth of the render-texture
heightHeight of the render-texture
depthBufferDo you want this render-texture to have a depth buffer?
+
+
+
Returns
True if creation has been successful
+
Deprecated:
Use create(unsigned int, unsigned int, const ContextSettings&) instead.
+ +
+
+ +

◆ create() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::RenderTexture::create (unsigned int width,
unsigned int height,
const ContextSettings & settings = ContextSettings() 
)
+
+ +

Create the render-texture.

+

Before calling this function, the render-texture is in an invalid state, thus it is mandatory to call it before doing anything with the render-texture. The last parameter, settings, is useful if you want to enable multi-sampling or use the render-texture for OpenGL rendering that requires a depth or stencil buffer. Otherwise it is unnecessary, and you should leave this parameter at its default value.

+
Parameters
+ + + + +
widthWidth of the render-texture
heightHeight of the render-texture
settingsAdditional settings for the underlying OpenGL texture and context
+
+
+
Returns
True if creation has been successful
+ +
+
+ +

◆ display()

+ +
+
+ + + + + + + +
void sf::RenderTexture::display ()
+
+ +

Update the contents of the target texture.

+

This function updates the target texture with what has been drawn so far. Like for windows, calling this function is mandatory at the end of rendering. Not calling it may leave the texture in an undefined state.

+ +
+
+ +

◆ draw() [1/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const Drawable & drawable,
const RenderStates & states = RenderStates::Default 
)
+ 		+inherited
+
+ +

Draw a drawable object to the render target.

+
Parameters
+ + + +
drawableObject to draw
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ draw() [2/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const Vertex * vertices,
std::size_t vertexCount,
PrimitiveType type,
const RenderStates & states = RenderStates::Default 
)
+ 		+inherited
+
+ +

Draw primitives defined by an array of vertices.

+
Parameters
+ + + + + +
verticesPointer to the vertices
vertexCountNumber of vertices in the array
typeType of primitives to draw
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ draw() [3/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const VertexBuffer & vertexBuffer,
const RenderStates & states = RenderStates::Default 
)
+ 		+inherited
+
+ +

Draw primitives defined by a vertex buffer.

+
Parameters
+ + + +
vertexBufferVertex buffer
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ draw() [4/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const VertexBuffer & vertexBuffer,
std::size_t firstVertex,
std::size_t vertexCount,
const RenderStates & states = RenderStates::Default 
)
+ 		+inherited
+
+ +

Draw primitives defined by a vertex buffer.

+
Parameters
+ + + + + +
vertexBufferVertex buffer
firstVertexIndex of the first vertex to render
vertexCountNumber of vertices to render
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ generateMipmap()

+ +
+
+ + + + + + + +
bool sf::RenderTexture::generateMipmap ()
+
+ +

Generate a mipmap using the current texture data.

+

This function is similar to Texture::generateMipmap and operates on the texture used as the target for drawing. Be aware that any draw operation may modify the base level image data. For this reason, calling this function only makes sense after all drawing is completed and display has been called. Not calling display after subsequent drawing will lead to undefined behavior if a mipmap had been previously generated.

+
Returns
True if mipmap generation was successful, false if unsuccessful
+ +
+
+ +

◆ getDefaultView()

+ +
+
+ + + + + +
+ + + + + + + +
const View & sf::RenderTarget::getDefaultView () const
+ 		+inherited
+
+ +

Get the default view of the render target.

+

The default view has the initial size of the render target, and never changes after the target has been created.

+
Returns
The default view of the render target
+
See also
setView, getView
+ +
+
+ +

◆ getMaximumAntialiasingLevel()

+ +
+
+ + + + + +
+ + + + + + + +
static unsigned int sf::RenderTexture::getMaximumAntialiasingLevel ()
+ 		+static
+
+ +

Get the maximum anti-aliasing level supported by the system.

+
Returns
The maximum anti-aliasing level supported by the system
+ +
+
+ +

◆ getSize()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Vector2u sf::RenderTexture::getSize () const
+ 		+virtual
+
+ +

Return the size of the rendering region of the texture.

+

The returned value is the size that you passed to the create function.

+
Returns
Size in pixels
+ +

Implements sf::RenderTarget.

+ +
+
+ +

◆ getTexture()

+ +
+
+ + + + + + + +
const Texture & sf::RenderTexture::getTexture () const
+
+ +

Get a read-only reference to the target texture.

+

After drawing to the render-texture and calling Display, you can retrieve the updated texture using this function, and draw it using a sprite (for example). The internal sf::Texture of a render-texture is always the same instance, so that it is possible to call this function once and keep a reference to the texture even after it is modified.

+
Returns
Const reference to the texture
+ +
+
+ +

◆ getView()

+ +
+
+ + + + + +
+ + + + + + + +
const View & sf::RenderTarget::getView () const
+ 		+inherited
+
+ +

Get the view currently in use in the render target.

+
Returns
The view object that is currently used
+
See also
setView, getDefaultView
+ +
+
+ +

◆ getViewport()

+ +
+
+ + + + + +
+ + + + + + + + +
IntRect sf::RenderTarget::getViewport (const View & view) const
+ 		+inherited
+
+ +

Get the viewport of a view, applied to this render target.

+

The viewport is defined in the view as a ratio, this function simply applies this ratio to the current dimensions of the render target to calculate the pixels rectangle that the viewport actually covers in the target.

+
Parameters
+ + +
viewThe view for which we want to compute the viewport
+
+
+
Returns
Viewport rectangle, expressed in pixels
+ +
+
+ +

◆ initialize()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::RenderTarget::initialize ()
+ 		+protectedinherited
+
+ +

Performs the common initialization step after creation.

+

The derived classes must call this function after the target is created and ready for drawing.

+ +
+
+ +

◆ isRepeated()

+ +
+
+ + + + + + + +
bool sf::RenderTexture::isRepeated () const
+
+ +

Tell whether the texture is repeated or not.

+
Returns
True if texture is repeated
+
See also
setRepeated
+ +
+
+ +

◆ isSmooth()

+ +
+
+ + + + + + + +
bool sf::RenderTexture::isSmooth () const
+
+ +

Tell whether the smooth filtering is enabled or not.

+
Returns
True if texture smoothing is enabled
+
See also
setSmooth
+ +
+
+ +

◆ isSrgb()

+ +
+
+ + + + + +
+ + + + + + + +
virtual bool sf::RenderTexture::isSrgb () const
+ 		+virtual
+
+ +

Tell if the render-texture will use sRGB encoding when drawing on it.

+

You can request sRGB encoding for a render-texture by having the sRgbCapable flag set for the context parameter of create() method

+
Returns
True if the render-texture use sRGB encoding, false otherwise
+ +

Reimplemented from sf::RenderTarget.

+ +
+
+ +

◆ mapCoordsToPixel() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
Vector2i sf::RenderTarget::mapCoordsToPixel (const Vector2f & point) const
+ 		+inherited
+
+ +

Convert a point from world coordinates to target coordinates, using the current view.

+

This function is an overload of the mapCoordsToPixel function that implicitly uses the current view. It is equivalent to:

target.mapCoordsToPixel(point, target.getView());
+
Parameters
+ + +
pointPoint to convert
+
+
+
Returns
The converted point, in target coordinates (pixels)
+
See also
mapPixelToCoords
+ +
+
+ +

◆ mapCoordsToPixel() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2i sf::RenderTarget::mapCoordsToPixel (const Vector2f & point,
const View & view 
) const
+ 		+inherited
+
+ +

Convert a point from world coordinates to target coordinates.

+

This function finds the pixel of the render target that matches the given 2D point. In other words, it goes through the same process as the graphics card, to compute the final position of a rendered point.

+

Initially, both coordinate systems (world units and target pixels) match perfectly. But if you define a custom view or resize your render target, this assertion is not true anymore, i.e. a point located at (150, 75) in your 2D world may map to the pixel (10, 50) of your render target – if the view is translated by (140, 25).

+

This version uses a custom view for calculations, see the other overload of the function if you want to use the current view of the render target.

+
Parameters
+ + + +
pointPoint to convert
viewThe view to use for converting the point
+
+
+
Returns
The converted point, in target coordinates (pixels)
+
See also
mapPixelToCoords
+ +
+
+ +

◆ mapPixelToCoords() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
Vector2f sf::RenderTarget::mapPixelToCoords (const Vector2i & point) const
+ 		+inherited
+
+ +

Convert a point from target coordinates to world coordinates, using the current view.

+

This function is an overload of the mapPixelToCoords function that implicitly uses the current view. It is equivalent to:

target.mapPixelToCoords(point, target.getView());
+
Parameters
+ + +
pointPixel to convert
+
+
+
Returns
The converted point, in "world" coordinates
+
See also
mapCoordsToPixel
+ +
+
+ +

◆ mapPixelToCoords() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2f sf::RenderTarget::mapPixelToCoords (const Vector2i & point,
const View & view 
) const
+ 		+inherited
+
+ +

Convert a point from target coordinates to world coordinates.

+

This function finds the 2D position that matches the given pixel of the render target. In other words, it does the inverse of what the graphics card does, to find the initial position of a rendered pixel.

+

Initially, both coordinate systems (world units and target pixels) match perfectly. But if you define a custom view or resize your render target, this assertion is not true anymore, i.e. a point located at (10, 50) in your render target may map to the point (150, 75) in your 2D world – if the view is translated by (140, 25).

+

For render-windows, this function is typically used to find which point (or object) is located below the mouse cursor.

+

This version uses a custom view for calculations, see the other overload of the function if you want to use the current view of the render target.

+
Parameters
+ + + +
pointPixel to convert
viewThe view to use for converting the point
+
+
+
Returns
The converted point, in "world" units
+
See also
mapCoordsToPixel
+ +
+
+ +

◆ popGLStates()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::RenderTarget::popGLStates ()
+ 		+inherited
+
+ +

Restore the previously saved OpenGL render states and matrices.

+

See the description of pushGLStates to get a detailed description of these functions.

+
See also
pushGLStates
+ +
+
+ +

◆ pushGLStates()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::RenderTarget::pushGLStates ()
+ 		+inherited
+
+ +

Save the current OpenGL render states and matrices.

+

This function can be used when you mix SFML drawing and direct OpenGL rendering. Combined with popGLStates, it ensures that:

    +
  • SFML's internal states are not messed up by your OpenGL code
    • +
  • your OpenGL states are not modified by a call to a SFML function
    • +
+

More specifically, it must be used around code that calls Draw functions. Example:

// OpenGL code here...
+
window.pushGLStates();
+
window.draw(...);
+
window.draw(...);
+
window.popGLStates();
+
// OpenGL code here...
+

Note that this function is quite expensive: it saves all the possible OpenGL states and matrices, even the ones you don't care about. Therefore it should be used wisely. It is provided for convenience, but the best results will be achieved if you handle OpenGL states yourself (because you know which states have really changed, and need to be saved and restored). Take a look at the resetGLStates function if you do so.

+
See also
popGLStates
+ +
+
+ +

◆ resetGLStates()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::RenderTarget::resetGLStates ()
+ 		+inherited
+
+ +

Reset the internal OpenGL states so that the target is ready for drawing.

+

This function can be used when you mix SFML drawing and direct OpenGL rendering, if you choose not to use pushGLStates/popGLStates. It makes sure that all OpenGL states needed by SFML are set, so that subsequent draw() calls will work as expected.

+

Example:

// OpenGL code here...
+
glPushAttrib(...);
+
window.resetGLStates();
+
window.draw(...);
+
window.draw(...);
+
glPopAttrib(...);
+
// OpenGL code here...
+
+
+
+ +

◆ setActive()

+ +
+
+ + + + + +
+ + + + + + + + +
bool sf::RenderTexture::setActive (bool active = true)
+ 		+virtual
+
+ +

Activate or deactivate the render-texture for rendering.

+

This function makes the render-texture's context current for future OpenGL rendering operations (so you shouldn't care about it if you're not doing direct OpenGL stuff). Only one context can be current in a thread, so if you want to draw OpenGL geometry to another render target (like a RenderWindow) don't forget to activate it again.

+
Parameters
+ + +
activeTrue to activate, false to deactivate
+
+
+
Returns
True if operation was successful, false otherwise
+ +

Reimplemented from sf::RenderTarget.

+ +
+
+ +

◆ setRepeated()

+ +
+
+ + + + + + + + +
void sf::RenderTexture::setRepeated (bool repeated)
+
+ +

Enable or disable texture repeating.

+

This function is similar to Texture::setRepeated. This parameter is disabled by default.

+
Parameters
+ + +
repeatedTrue to enable repeating, false to disable it
+
+
+
See also
isRepeated
+ +
+
+ +

◆ setSmooth()

+ +
+
+ + + + + + + + +
void sf::RenderTexture::setSmooth (bool smooth)
+
+ +

Enable or disable texture smoothing.

+

This function is similar to Texture::setSmooth. This parameter is disabled by default.

+
Parameters
+ + +
smoothTrue to enable smoothing, false to disable it
+
+
+
See also
isSmooth
+ +
+
+ +

◆ setView()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::RenderTarget::setView (const View & view)
+ 		+inherited
+
+ +

Change the current active view.

+

The view is like a 2D camera, it controls which part of the 2D scene is visible, and how it is viewed in the render target. The new view will affect everything that is drawn, until another view is set. The render target keeps its own copy of the view object, so it is not necessary to keep the original one alive after calling this function. To restore the original view of the target, you can pass the result of getDefaultView() to this function.

+
Parameters
+ + +
viewNew view to use
+
+
+
See also
getView, getDefaultView
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderTexture.png b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTexture.png new file mode 100644 index 000000000..898c85969 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1RenderTexture.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderWindow-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1RenderWindow-members.html new file mode 100644 index 000000000..788d4cdec --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1RenderWindow-members.html @@ -0,0 +1,173 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::RenderWindow Member List
+
+
+ +

This is the complete list of members for sf::RenderWindow, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
capture() constsf::RenderWindow
clear(const Color &color=Color(0, 0, 0, 255))sf::RenderTarget
close()sf::Windowvirtual
create(VideoMode mode, const String &title, Uint32 style=Style::Default)sf::Windowvirtual
create(VideoMode mode, const String &title, Uint32 style, const ContextSettings &settings)sf::Windowvirtual
create(WindowHandle handle)sf::Windowvirtual
create(WindowHandle handle, const ContextSettings &settings)sf::Windowvirtual
createVulkanSurface(const VkInstance &instance, VkSurfaceKHR &surface, const VkAllocationCallbacks *allocator=0)sf::WindowBase
display()sf::Window
draw(const Drawable &drawable, const RenderStates &states=RenderStates::Default)sf::RenderTarget
draw(const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default)sf::RenderTarget
draw(const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default)sf::RenderTarget
draw(const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default)sf::RenderTarget
getDefaultView() constsf::RenderTarget
getPosition() constsf::WindowBase
getSettings() constsf::Window
getSize() constsf::RenderWindowvirtual
getSystemHandle() constsf::WindowBase
getView() constsf::RenderTarget
getViewport(const View &view) constsf::RenderTarget
hasFocus() constsf::WindowBase
initialize()sf::RenderTargetprotected
isOpen() constsf::WindowBase
isSrgb() constsf::RenderWindowvirtual
mapCoordsToPixel(const Vector2f &point) constsf::RenderTarget
mapCoordsToPixel(const Vector2f &point, const View &view) constsf::RenderTarget
mapPixelToCoords(const Vector2i &point) constsf::RenderTarget
mapPixelToCoords(const Vector2i &point, const View &view) constsf::RenderTarget
onCreate()sf::RenderWindowprotectedvirtual
onResize()sf::RenderWindowprotectedvirtual
pollEvent(Event &event)sf::WindowBase
popGLStates()sf::RenderTarget
pushGLStates()sf::RenderTarget
RenderTarget()sf::RenderTargetprotected
RenderWindow()sf::RenderWindow
RenderWindow(VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())sf::RenderWindow
RenderWindow(WindowHandle handle, const ContextSettings &settings=ContextSettings())sf::RenderWindowexplicit
requestFocus()sf::WindowBase
resetGLStates()sf::RenderTarget
setActive(bool active=true)sf::RenderWindowvirtual
sf::Window::setActive(bool active=true) constsf::Window
setFramerateLimit(unsigned int limit)sf::Window
setIcon(unsigned int width, unsigned int height, const Uint8 *pixels)sf::WindowBase
setJoystickThreshold(float threshold)sf::WindowBase
setKeyRepeatEnabled(bool enabled)sf::WindowBase
setMouseCursor(const Cursor &cursor)sf::WindowBase
setMouseCursorGrabbed(bool grabbed)sf::WindowBase
setMouseCursorVisible(bool visible)sf::WindowBase
setPosition(const Vector2i &position)sf::WindowBase
setSize(const Vector2u &size)sf::WindowBase
setTitle(const String &title)sf::WindowBase
setVerticalSyncEnabled(bool enabled)sf::Window
setView(const View &view)sf::RenderTarget
setVisible(bool visible)sf::WindowBase
waitEvent(Event &event)sf::WindowBase
Window()sf::Window
Window(VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())sf::Window
Window(WindowHandle handle, const ContextSettings &settings=ContextSettings())sf::Windowexplicit
WindowBase()sf::WindowBase
WindowBase(VideoMode mode, const String &title, Uint32 style=Style::Default)sf::WindowBase
WindowBase(WindowHandle handle)sf::WindowBaseexplicit
~RenderTarget()sf::RenderTargetvirtual
~RenderWindow()sf::RenderWindowvirtual
~Window()sf::Windowvirtual
~WindowBase()sf::WindowBasevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderWindow.html b/Space-Invaders/sfml/doc/html/classsf_1_1RenderWindow.html new file mode 100644 index 000000000..828c03dda --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1RenderWindow.html @@ -0,0 +1,2465 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Protected Member Functions | +List of all members
+
sf::RenderWindow Class Reference
Graphics module
+
+
+ +

Window that can serve as a target for 2D drawing. + More...

+ +

#include <SFML/Graphics/RenderWindow.hpp>

+
+Inheritance diagram for sf::RenderWindow:
+
+
+ + +sf::Window +sf::RenderTarget +sf::WindowBase +sf::GlResource +sf::NonCopyable +sf::NonCopyable + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 RenderWindow ()
 Default constructor.
 
 RenderWindow (VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())
 Construct a new window.
 
 RenderWindow (WindowHandle handle, const ContextSettings &settings=ContextSettings())
 Construct the window from an existing control.
 
virtual ~RenderWindow ()
 Destructor.
 
virtual Vector2u getSize () const
 Get the size of the rendering region of the window.
 
virtual bool isSrgb () const
 Tell if the window will use sRGB encoding when drawing on it.
 
bool setActive (bool active=true)
 Activate or deactivate the window as the current target for OpenGL rendering.
 
Image capture () const
 Copy the current contents of the window to an image.
 
virtual void create (VideoMode mode, const String &title, Uint32 style=Style::Default)
 Create (or recreate) the window.
 
virtual void create (VideoMode mode, const String &title, Uint32 style, const ContextSettings &settings)
 Create (or recreate) the window.
 
virtual void create (WindowHandle handle)
 Create (or recreate) the window from an existing control.
 
virtual void create (WindowHandle handle, const ContextSettings &settings)
 Create (or recreate) the window from an existing control.
 
virtual void close ()
 Close the window and destroy all the attached resources.
 
const ContextSettings & getSettings () const
 Get the settings of the OpenGL context of the window.
 
void setVerticalSyncEnabled (bool enabled)
 Enable or disable vertical synchronization.
 
void setFramerateLimit (unsigned int limit)
 Limit the framerate to a maximum fixed frequency.
 
bool setActive (bool active=true) const
 Activate or deactivate the window as the current target for OpenGL rendering.
 
void display ()
 Display on screen what has been rendered to the window so far.
 
bool isOpen () const
 Tell whether or not the window is open.
 
bool pollEvent (Event &event)
 Pop the event on top of the event queue, if any, and return it.
 
bool waitEvent (Event &event)
 Wait for an event and return it.
 
Vector2i getPosition () const
 Get the position of the window.
 
void setPosition (const Vector2i &position)
 Change the position of the window on screen.
 
void setSize (const Vector2u &size)
 Change the size of the rendering region of the window.
 
void setTitle (const String &title)
 Change the title of the window.
 
void setIcon (unsigned int width, unsigned int height, const Uint8 *pixels)
 Change the window's icon.
 
void setVisible (bool visible)
 Show or hide the window.
 
void setMouseCursorVisible (bool visible)
 Show or hide the mouse cursor.
 
void setMouseCursorGrabbed (bool grabbed)
 Grab or release the mouse cursor.
 
void setMouseCursor (const Cursor &cursor)
 Set the displayed cursor to a native system cursor.
 
void setKeyRepeatEnabled (bool enabled)
 Enable or disable automatic key-repeat.
 
void setJoystickThreshold (float threshold)
 Change the joystick threshold.
 
void requestFocus ()
 Request the current window to be made the active foreground window.
 
bool hasFocus () const
 Check whether the window has the input focus.
 
WindowHandle getSystemHandle () const
 Get the OS-specific handle of the window.
 
bool createVulkanSurface (const VkInstance &instance, VkSurfaceKHR &surface, const VkAllocationCallbacks *allocator=0)
 Create a Vulkan rendering surface.
 
void clear (const Color &color=Color(0, 0, 0, 255))
 Clear the entire target with a single color.
 
void setView (const View &view)
 Change the current active view.
 
const View & getView () const
 Get the view currently in use in the render target.
 
const View & getDefaultView () const
 Get the default view of the render target.
 
IntRect getViewport (const View &view) const
 Get the viewport of a view, applied to this render target.
 
Vector2f mapPixelToCoords (const Vector2i &point) const
 Convert a point from target coordinates to world coordinates, using the current view.
 
Vector2f mapPixelToCoords (const Vector2i &point, const View &view) const
 Convert a point from target coordinates to world coordinates.
 
Vector2i mapCoordsToPixel (const Vector2f &point) const
 Convert a point from world coordinates to target coordinates, using the current view.
 
Vector2i mapCoordsToPixel (const Vector2f &point, const View &view) const
 Convert a point from world coordinates to target coordinates.
 
void draw (const Drawable &drawable, const RenderStates &states=RenderStates::Default)
 Draw a drawable object to the render target.
 
void draw (const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default)
 Draw primitives defined by an array of vertices.
 
void draw (const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default)
 Draw primitives defined by a vertex buffer.
 
void draw (const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default)
 Draw primitives defined by a vertex buffer.
 
void pushGLStates ()
 Save the current OpenGL render states and matrices.
 
void popGLStates ()
 Restore the previously saved OpenGL render states and matrices.
 
void resetGLStates ()
 Reset the internal OpenGL states so that the target is ready for drawing.
 
+ + + + + + + + + + +

+Protected Member Functions

virtual void onCreate ()
 Function called after the window has been created.
 
virtual void onResize ()
 Function called after the window has been resized.
 
void initialize ()
 Performs the common initialization step after creation.
 
+

Detailed Description

+

Window that can serve as a target for 2D drawing.

+

sf::RenderWindow is the main class of the Graphics module.

+

It defines an OS window that can be painted using the other classes of the graphics module.

+

sf::RenderWindow is derived from sf::Window, thus it inherits all its features: events, window management, OpenGL rendering, etc. See the documentation of sf::Window for a more complete description of all these features, as well as code examples.

+

On top of that, sf::RenderWindow adds more features related to 2D drawing with the graphics module (see its base class sf::RenderTarget for more details). Here is a typical rendering and event loop with a sf::RenderWindow:

+
// Declare and create a new render-window
+
sf::RenderWindow window(sf::VideoMode(800, 600), "SFML window");
+
+
// Limit the framerate to 60 frames per second (this step is optional)
+
window.setFramerateLimit(60);
+
+
// The main loop - ends as soon as the window is closed
+
while (window.isOpen())
+
{
+
// Event processing
+
sf::Event event;
+
while (window.pollEvent(event))
+
{
+
// Request for closing the window
+
if (event.type == sf::Event::Closed)
+
window.close();
+
}
+
+
// Clear the whole window before rendering a new frame
+
window.clear();
+
+
// Draw some graphical entities
+
window.draw(sprite);
+
window.draw(circle);
+
window.draw(text);
+
+
// End the current frame and display its contents on screen
+
window.display();
+
}
+
sf::Event
Defines a system event and its parameters.
Definition: Event.hpp:45
+
sf::Event::type
EventType type
Type of the event.
Definition: Event.hpp:220
+
sf::Event::Closed
@ Closed
The window requested to be closed (no data)
Definition: Event.hpp:190
+
sf::RenderWindow
Window that can serve as a target for 2D drawing.
Definition: RenderWindow.hpp:45
+
sf::VideoMode
VideoMode defines a video mode (width, height, bpp)
Definition: VideoMode.hpp:42
+

Like sf::Window, sf::RenderWindow is still able to render direct OpenGL stuff. It is even possible to mix together OpenGL calls and regular SFML drawing commands.

+
// Create the render window
+
sf::RenderWindow window(sf::VideoMode(800, 600), "SFML OpenGL");
+
+
// Create a sprite and a text to display
+
sf::Sprite sprite;
+
sf::Text text;
+
...
+
+
// Perform OpenGL initializations
+
glMatrixMode(GL_PROJECTION);
+
...
+
+
// Start the rendering loop
+
while (window.isOpen())
+
{
+
// Process events
+
...
+
+
// Draw a background sprite
+
window.pushGLStates();
+
window.draw(sprite);
+
window.popGLStates();
+
+
// Draw a 3D object using OpenGL
+
glBegin(GL_QUADS);
+
glVertex3f(...);
+
...
+
glEnd();
+
+
// Draw text on top of the 3D object
+
window.pushGLStates();
+
window.draw(text);
+
window.popGLStates();
+
+
// Finally, display the rendered frame on screen
+
window.display();
+
}
+
sf::Sprite
Drawable representation of a texture, with its own transformations, color, etc.
Definition: Sprite.hpp:48
+
sf::Text
Graphical text that can be drawn to a render target.
Definition: Text.hpp:49
+
See also
sf::Window, sf::RenderTarget, sf::RenderTexture, sf::View
+ +

Definition at line 44 of file RenderWindow.hpp.

+

Constructor & Destructor Documentation

+ +

◆ RenderWindow() [1/3]

+ +
+
+ + + + + + + +
sf::RenderWindow::RenderWindow ()
+
+ +

Default constructor.

+

This constructor doesn't actually create the window, use the other constructors or call create() to do so.

+ +
+
+ +

◆ RenderWindow() [2/3]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sf::RenderWindow::RenderWindow (VideoMode mode,
const String & title,
Uint32 style = Style::Default,
const ContextSettings & settings = ContextSettings() 
)
+
+ +

Construct a new window.

+

This constructor creates the window with the size and pixel depth defined in mode. An optional style can be passed to customize the look and behavior of the window (borders, title bar, resizable, closable, ...).

+

The fourth parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc. You shouldn't care about these parameters for a regular usage of the graphics module.

+
Parameters
+ + + + + +
modeVideo mode to use (defines the width, height and depth of the rendering area of the window)
titleTitle of the window
styleWindow style, a bitwise OR combination of sf::Style enumerators
settingsAdditional settings for the underlying OpenGL context
+
+
+ +
+
+ +

◆ RenderWindow() [3/3]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
sf::RenderWindow::RenderWindow (WindowHandle handle,
const ContextSettings & settings = ContextSettings() 
)
+ 		+explicit
+
+ +

Construct the window from an existing control.

+

Use this constructor if you want to create an SFML rendering area into an already existing control.

+

The second parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc. You shouldn't care about these parameters for a regular usage of the graphics module.

+
Parameters
+ + + +
handlePlatform-specific handle of the control (HWND on Windows, Window on Linux/FreeBSD, NSWindow on OS X)
settingsAdditional settings for the underlying OpenGL context
+
+
+ +
+
+ +

◆ ~RenderWindow()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::RenderWindow::~RenderWindow ()
+ 		+virtual
+
+ +

Destructor.

+

Closes the window and frees all the resources attached to it.

+ +
+
+

Member Function Documentation

+ +

◆ capture()

+ +
+
+ + + + + + + +
Image sf::RenderWindow::capture () const
+
+ +

Copy the current contents of the window to an image.

+
Deprecated:
Use a sf::Texture and its sf::Texture::update(const Window&) function and copy its contents into an sf::Image instead.
+
sf::Vector2u windowSize = window.getSize();
+
sf::Texture texture;
+
texture.create(windowSize.x, windowSize.y);
+
texture.update(window);
+
sf::Image screenshot = texture.copyToImage();
+
sf::Image
Class for loading, manipulating and saving images.
Definition: Image.hpp:47
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Texture::copyToImage
Image copyToImage() const
Copy the texture pixels to an image.
+
sf::Texture::create
bool create(unsigned int width, unsigned int height)
Create the texture.
+
sf::Texture::update
void update(const Uint8 *pixels)
Update the whole texture from an array of pixels.
+ +
sf::Vector2::x
T x
X coordinate of the vector.
Definition: Vector2.hpp:75
+
sf::Vector2::y
T y
Y coordinate of the vector.
Definition: Vector2.hpp:76
+

This is a slow operation, whose main purpose is to make screenshots of the application. If you want to update an image with the contents of the window and then use it for drawing, you should rather use a sf::Texture and its update(Window&) function. You can also draw things directly to a texture with the sf::RenderTexture class.

+
Returns
Image containing the captured contents
+ +
+
+ +

◆ clear()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::RenderTarget::clear (const Color & color = Color(0, 0, 0, 255))
+ 		+inherited
+
+ +

Clear the entire target with a single color.

+

This function is usually called once every frame, to clear the previous contents of the target.

+
Parameters
+ + +
colorFill color to use to clear the render target
+
+
+ +
+
+ +

◆ close()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::Window::close ()
+ 		+virtualinherited
+
+ +

Close the window and destroy all the attached resources.

+

After calling this function, the sf::Window instance remains valid and you can call create() to recreate the window. All other functions such as pollEvent() or display() will still work (i.e. you don't have to test isOpen() every time), and will have no effect on closed windows.

+ +

Reimplemented from sf::WindowBase.

+ +
+
+ +

◆ create() [1/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
virtual void sf::Window::create (VideoMode mode,
const String & title,
Uint32 style,
const ContextSettings & settings 
)
+ 		+virtualinherited
+
+ +

Create (or recreate) the window.

+

If the window was already created, it closes it first. If style contains Style::Fullscreen, then mode must be a valid video mode.

+

The fourth parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

+
Parameters
+ + + + + +
modeVideo mode to use (defines the width, height and depth of the rendering area of the window)
titleTitle of the window
styleWindow style, a bitwise OR combination of sf::Style enumerators
settingsAdditional settings for the underlying OpenGL context
+
+
+ +
+
+ +

◆ create() [2/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
virtual void sf::Window::create (VideoMode mode,
const String & title,
Uint32 style = Style::Default 
)
+ 		+virtualinherited
+
+ +

Create (or recreate) the window.

+

If the window was already created, it closes it first. If style contains Style::Fullscreen, then mode must be a valid video mode.

+
Parameters
+ + + + +
modeVideo mode to use (defines the width, height and depth of the rendering area of the window)
titleTitle of the window
styleWindow style, a bitwise OR combination of sf::Style enumerators
+
+
+ +

Reimplemented from sf::WindowBase.

+ +
+
+ +

◆ create() [3/4]

+ +
+
+ + + + + +
+ + + + + + + + +
virtual void sf::Window::create (WindowHandle handle)
+ 		+virtualinherited
+
+ +

Create (or recreate) the window from an existing control.

+

Use this function if you want to create an OpenGL rendering area into an already existing control. If the window was already created, it closes it first.

+
Parameters
+ + +
handlePlatform-specific handle of the control
+
+
+ +

Reimplemented from sf::WindowBase.

+ +
+
+ +

◆ create() [4/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual void sf::Window::create (WindowHandle handle,
const ContextSettings & settings 
)
+ 		+virtualinherited
+
+ +

Create (or recreate) the window from an existing control.

+

Use this function if you want to create an OpenGL rendering area into an already existing control. If the window was already created, it closes it first.

+

The second parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

+
Parameters
+ + + +
handlePlatform-specific handle of the control
settingsAdditional settings for the underlying OpenGL context
+
+
+ +
+
+ +

◆ createVulkanSurface()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::WindowBase::createVulkanSurface (const VkInstance & instance,
VkSurfaceKHR & surface,
const VkAllocationCallbacks * allocator = 0 
)
+ 		+inherited
+
+ +

Create a Vulkan rendering surface.

+
Parameters
+ + + + +
instanceVulkan instance
surfaceCreated surface
allocatorAllocator to use
+
+
+
Returns
True if surface creation was successful, false otherwise
+ +
+
+ +

◆ display()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Window::display ()
+ 		+inherited
+
+ +

Display on screen what has been rendered to the window so far.

+

This function is typically called after all OpenGL rendering has been done for the current frame, in order to show it on screen.

+ +
+
+ +

◆ draw() [1/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const Drawable & drawable,
const RenderStates & states = RenderStates::Default 
)
+ 		+inherited
+
+ +

Draw a drawable object to the render target.

+
Parameters
+ + + +
drawableObject to draw
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ draw() [2/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const Vertex * vertices,
std::size_t vertexCount,
PrimitiveType type,
const RenderStates & states = RenderStates::Default 
)
+ 		+inherited
+
+ +

Draw primitives defined by an array of vertices.

+
Parameters
+ + + + + +
verticesPointer to the vertices
vertexCountNumber of vertices in the array
typeType of primitives to draw
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ draw() [3/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const VertexBuffer & vertexBuffer,
const RenderStates & states = RenderStates::Default 
)
+ 		+inherited
+
+ +

Draw primitives defined by a vertex buffer.

+
Parameters
+ + + +
vertexBufferVertex buffer
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ draw() [4/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void sf::RenderTarget::draw (const VertexBuffer & vertexBuffer,
std::size_t firstVertex,
std::size_t vertexCount,
const RenderStates & states = RenderStates::Default 
)
+ 		+inherited
+
+ +

Draw primitives defined by a vertex buffer.

+
Parameters
+ + + + + +
vertexBufferVertex buffer
firstVertexIndex of the first vertex to render
vertexCountNumber of vertices to render
statesRender states to use for drawing
+
+
+ +
+
+ +

◆ getDefaultView()

+ +
+
+ + + + + +
+ + + + + + + +
const View & sf::RenderTarget::getDefaultView () const
+ 		+inherited
+
+ +

Get the default view of the render target.

+

The default view has the initial size of the render target, and never changes after the target has been created.

+
Returns
The default view of the render target
+
See also
setView, getView
+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
Vector2i sf::WindowBase::getPosition () const
+ 		+inherited
+
+ +

Get the position of the window.

+
Returns
Position of the window, in pixels
+
See also
setPosition
+ +
+
+ +

◆ getSettings()

+ +
+
+ + + + + +
+ + + + + + + +
const ContextSettings & sf::Window::getSettings () const
+ 		+inherited
+
+ +

Get the settings of the OpenGL context of the window.

+

Note that these settings may be different from what was passed to the constructor or the create() function, if one or more settings were not supported. In this case, SFML chose the closest match.

+
Returns
Structure containing the OpenGL context settings
+ +
+
+ +

◆ getSize()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Vector2u sf::RenderWindow::getSize () const
+ 		+virtual
+
+ +

Get the size of the rendering region of the window.

+

The size doesn't include the titlebar and borders of the window.

+
Returns
Size in pixels
+ +

Implements sf::RenderTarget.

+ +
+
+ +

◆ getSystemHandle()

+ +
+
+ + + + + +
+ + + + + + + +
WindowHandle sf::WindowBase::getSystemHandle () const
+ 		+inherited
+
+ +

Get the OS-specific handle of the window.

+

The type of the returned handle is sf::WindowHandle, which is a typedef to the handle type defined by the OS. You shouldn't need to use this function, unless you have very specific stuff to implement that SFML doesn't support, or implement a temporary workaround until a bug is fixed.

+
Returns
System handle of the window
+ +
+
+ +

◆ getView()

+ +
+
+ + + + + +
+ + + + + + + +
const View & sf::RenderTarget::getView () const
+ 		+inherited
+
+ +

Get the view currently in use in the render target.

+
Returns
The view object that is currently used
+
See also
setView, getDefaultView
+ +
+
+ +

◆ getViewport()

+ +
+
+ + + + + +
+ + + + + + + + +
IntRect sf::RenderTarget::getViewport (const View & view) const
+ 		+inherited
+
+ +

Get the viewport of a view, applied to this render target.

+

The viewport is defined in the view as a ratio, this function simply applies this ratio to the current dimensions of the render target to calculate the pixels rectangle that the viewport actually covers in the target.

+
Parameters
+ + +
viewThe view for which we want to compute the viewport
+
+
+
Returns
Viewport rectangle, expressed in pixels
+ +
+
+ +

◆ hasFocus()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::WindowBase::hasFocus () const
+ 		+inherited
+
+ +

Check whether the window has the input focus.

+

At any given time, only one window may have the input focus to receive input events such as keystrokes or most mouse events.

+
Returns
True if window has focus, false otherwise
+
See also
requestFocus
+ +
+
+ +

◆ initialize()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::RenderTarget::initialize ()
+ 		+protectedinherited
+
+ +

Performs the common initialization step after creation.

+

The derived classes must call this function after the target is created and ready for drawing.

+ +
+
+ +

◆ isOpen()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::WindowBase::isOpen () const
+ 		+inherited
+
+ +

Tell whether or not the window is open.

+

This function returns whether or not the window exists. Note that a hidden window (setVisible(false)) is open (therefore this function would return true).

+
Returns
True if the window is open, false if it has been closed
+ +
+
+ +

◆ isSrgb()

+ +
+
+ + + + + +
+ + + + + + + +
virtual bool sf::RenderWindow::isSrgb () const
+ 		+virtual
+
+ +

Tell if the window will use sRGB encoding when drawing on it.

+

You can request sRGB encoding for a window by having the sRgbCapable flag set in the ContextSettings

+
Returns
True if the window use sRGB encoding, false otherwise
+ +

Reimplemented from sf::RenderTarget.

+ +
+
+ +

◆ mapCoordsToPixel() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
Vector2i sf::RenderTarget::mapCoordsToPixel (const Vector2f & point) const
+ 		+inherited
+
+ +

Convert a point from world coordinates to target coordinates, using the current view.

+

This function is an overload of the mapCoordsToPixel function that implicitly uses the current view. It is equivalent to:

target.mapCoordsToPixel(point, target.getView());
+
Parameters
+ + +
pointPoint to convert
+
+
+
Returns
The converted point, in target coordinates (pixels)
+
See also
mapPixelToCoords
+ +
+
+ +

◆ mapCoordsToPixel() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2i sf::RenderTarget::mapCoordsToPixel (const Vector2f & point,
const View & view 
) const
+ 		+inherited
+
+ +

Convert a point from world coordinates to target coordinates.

+

This function finds the pixel of the render target that matches the given 2D point. In other words, it goes through the same process as the graphics card, to compute the final position of a rendered point.

+

Initially, both coordinate systems (world units and target pixels) match perfectly. But if you define a custom view or resize your render target, this assertion is not true anymore, i.e. a point located at (150, 75) in your 2D world may map to the pixel (10, 50) of your render target – if the view is translated by (140, 25).

+

This version uses a custom view for calculations, see the other overload of the function if you want to use the current view of the render target.

+
Parameters
+ + + +
pointPoint to convert
viewThe view to use for converting the point
+
+
+
Returns
The converted point, in target coordinates (pixels)
+
See also
mapPixelToCoords
+ +
+
+ +

◆ mapPixelToCoords() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
Vector2f sf::RenderTarget::mapPixelToCoords (const Vector2i & point) const
+ 		+inherited
+
+ +

Convert a point from target coordinates to world coordinates, using the current view.

+

This function is an overload of the mapPixelToCoords function that implicitly uses the current view. It is equivalent to:

target.mapPixelToCoords(point, target.getView());
+
Parameters
+ + +
pointPixel to convert
+
+
+
Returns
The converted point, in "world" coordinates
+
See also
mapCoordsToPixel
+ +
+
+ +

◆ mapPixelToCoords() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2f sf::RenderTarget::mapPixelToCoords (const Vector2i & point,
const View & view 
) const
+ 		+inherited
+
+ +

Convert a point from target coordinates to world coordinates.

+

This function finds the 2D position that matches the given pixel of the render target. In other words, it does the inverse of what the graphics card does, to find the initial position of a rendered pixel.

+

Initially, both coordinate systems (world units and target pixels) match perfectly. But if you define a custom view or resize your render target, this assertion is not true anymore, i.e. a point located at (10, 50) in your render target may map to the point (150, 75) in your 2D world – if the view is translated by (140, 25).

+

For render-windows, this function is typically used to find which point (or object) is located below the mouse cursor.

+

This version uses a custom view for calculations, see the other overload of the function if you want to use the current view of the render target.

+
Parameters
+ + + +
pointPixel to convert
viewThe view to use for converting the point
+
+
+
Returns
The converted point, in "world" units
+
See also
mapCoordsToPixel
+ +
+
+ +

◆ onCreate()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::RenderWindow::onCreate ()
+ 		+protectedvirtual
+
+ +

Function called after the window has been created.

+

This function is called so that derived classes can perform their own specific initialization as soon as the window is created.

+ +

Reimplemented from sf::WindowBase.

+ +
+
+ +

◆ onResize()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::RenderWindow::onResize ()
+ 		+protectedvirtual
+
+ +

Function called after the window has been resized.

+

This function is called so that derived classes can perform custom actions when the size of the window changes.

+ +

Reimplemented from sf::WindowBase.

+ +
+
+ +

◆ pollEvent()

+ +
+
+ + + + + +
+ + + + + + + + +
bool sf::WindowBase::pollEvent (Event & event)
+ 		+inherited
+
+ +

Pop the event on top of the event queue, if any, and return it.

+

This function is not blocking: if there's no pending event then it will return false and leave event unmodified. Note that more than one event may be present in the event queue, thus you should always call this function in a loop to make sure that you process every pending event.

sf::Event event;
+
while (window.pollEvent(event))
+
{
+
// process event...
+
}
+
Parameters
+ + +
eventEvent to be returned
+
+
+
Returns
True if an event was returned, or false if the event queue was empty
+
See also
waitEvent
+ +
+
+ +

◆ popGLStates()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::RenderTarget::popGLStates ()
+ 		+inherited
+
+ +

Restore the previously saved OpenGL render states and matrices.

+

See the description of pushGLStates to get a detailed description of these functions.

+
See also
pushGLStates
+ +
+
+ +

◆ pushGLStates()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::RenderTarget::pushGLStates ()
+ 		+inherited
+
+ +

Save the current OpenGL render states and matrices.

+

This function can be used when you mix SFML drawing and direct OpenGL rendering. Combined with popGLStates, it ensures that:

    +
  • SFML's internal states are not messed up by your OpenGL code
    • +
  • your OpenGL states are not modified by a call to a SFML function
    • +
+

More specifically, it must be used around code that calls Draw functions. Example:

// OpenGL code here...
+
window.pushGLStates();
+
window.draw(...);
+
window.draw(...);
+
window.popGLStates();
+
// OpenGL code here...
+

Note that this function is quite expensive: it saves all the possible OpenGL states and matrices, even the ones you don't care about. Therefore it should be used wisely. It is provided for convenience, but the best results will be achieved if you handle OpenGL states yourself (because you know which states have really changed, and need to be saved and restored). Take a look at the resetGLStates function if you do so.

+
See also
popGLStates
+ +
+
+ +

◆ requestFocus()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::WindowBase::requestFocus ()
+ 		+inherited
+
+ +

Request the current window to be made the active foreground window.

+

At any given time, only one window may have the input focus to receive input events such as keystrokes or mouse events. If a window requests focus, it only hints to the operating system, that it would like to be focused. The operating system is free to deny the request. This is not to be confused with setActive().

+
See also
hasFocus
+ +
+
+ +

◆ resetGLStates()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::RenderTarget::resetGLStates ()
+ 		+inherited
+
+ +

Reset the internal OpenGL states so that the target is ready for drawing.

+

This function can be used when you mix SFML drawing and direct OpenGL rendering, if you choose not to use pushGLStates/popGLStates. It makes sure that all OpenGL states needed by SFML are set, so that subsequent draw() calls will work as expected.

+

Example:

// OpenGL code here...
+
glPushAttrib(...);
+
window.resetGLStates();
+
window.draw(...);
+
window.draw(...);
+
glPopAttrib(...);
+
// OpenGL code here...
+
+
+
+ +

◆ setActive() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
bool sf::RenderWindow::setActive (bool active = true)
+ 		+virtual
+
+ +

Activate or deactivate the window as the current target for OpenGL rendering.

+

A window is active only on the current thread, if you want to make it active on another thread you have to deactivate it on the previous thread first if it was active. Only one window can be active on a thread at a time, thus the window previously active (if any) automatically gets deactivated. This is not to be confused with requestFocus().

+
Parameters
+ + +
activeTrue to activate, false to deactivate
+
+
+
Returns
True if operation was successful, false otherwise
+ +

Reimplemented from sf::RenderTarget.

+ +
+
+ +

◆ setActive() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
bool sf::Window::setActive (bool active = true) const
+ 		+inherited
+
+ +

Activate or deactivate the window as the current target for OpenGL rendering.

+

A window is active only on the current thread, if you want to make it active on another thread you have to deactivate it on the previous thread first if it was active. Only one window can be active on a thread at a time, thus the window previously active (if any) automatically gets deactivated. This is not to be confused with requestFocus().

+
Parameters
+ + +
activeTrue to activate, false to deactivate
+
+
+
Returns
True if operation was successful, false otherwise
+ +
+
+ +

◆ setFramerateLimit()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Window::setFramerateLimit (unsigned int limit)
+ 		+inherited
+
+ +

Limit the framerate to a maximum fixed frequency.

+

If a limit is set, the window will use a small delay after each call to display() to ensure that the current frame lasted long enough to match the framerate limit. SFML will try to match the given limit as much as it can, but since it internally uses sf::sleep, whose precision depends on the underlying OS, the results may be a little unprecise as well (for example, you can get 65 FPS when requesting 60).

+
Parameters
+ + +
limitFramerate limit, in frames per seconds (use 0 to disable limit)
+
+
+ +
+
+ +

◆ setIcon()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::WindowBase::setIcon (unsigned int width,
unsigned int height,
const Uint8 * pixels 
)
+ 		+inherited
+
+ +

Change the window's icon.

+

pixels must be an array of width x height pixels in 32-bits RGBA format.

+

The OS default icon is used by default.

+
Parameters
+ + + + +
widthIcon's width, in pixels
heightIcon's height, in pixels
pixelsPointer to the array of pixels in memory. The pixels are copied, so you need not keep the source alive after calling this function.
+
+
+
See also
setTitle
+ +
+
+ +

◆ setJoystickThreshold()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setJoystickThreshold (float threshold)
+ 		+inherited
+
+ +

Change the joystick threshold.

+

The joystick threshold is the value below which no JoystickMoved event will be generated.

+

The threshold value is 0.1 by default.

+
Parameters
+ + +
thresholdNew threshold, in the range [0, 100]
+
+
+ +
+
+ +

◆ setKeyRepeatEnabled()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setKeyRepeatEnabled (bool enabled)
+ 		+inherited
+
+ +

Enable or disable automatic key-repeat.

+

If key repeat is enabled, you will receive repeated KeyPressed events while keeping a key pressed. If it is disabled, you will only get a single event when the key is pressed.

+

Key repeat is enabled by default.

+
Parameters
+ + +
enabledTrue to enable, false to disable
+
+
+ +
+
+ +

◆ setMouseCursor()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setMouseCursor (const Cursor & cursor)
+ 		+inherited
+
+ +

Set the displayed cursor to a native system cursor.

+

Upon window creation, the arrow cursor is used by default.

+
Warning
The cursor must not be destroyed while in use by the window.
+
+Features related to Cursor are not supported on iOS and Android.
+
Parameters
+ + +
cursorNative system cursor type to display
+
+
+
See also
sf::Cursor::loadFromSystem
+
+sf::Cursor::loadFromPixels
+ +
+
+ +

◆ setMouseCursorGrabbed()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setMouseCursorGrabbed (bool grabbed)
+ 		+inherited
+
+ +

Grab or release the mouse cursor.

+

If set, grabs the mouse cursor inside this window's client area so it may no longer be moved outside its bounds. Note that grabbing is only active while the window has focus.

+
Parameters
+ + +
grabbedTrue to enable, false to disable
+
+
+ +
+
+ +

◆ setMouseCursorVisible()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setMouseCursorVisible (bool visible)
+ 		+inherited
+
+ +

Show or hide the mouse cursor.

+

The mouse cursor is visible by default.

+
Parameters
+ + +
visibleTrue to show the mouse cursor, false to hide it
+
+
+ +
+
+ +

◆ setPosition()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setPosition (const Vector2i & position)
+ 		+inherited
+
+ +

Change the position of the window on screen.

+

This function only works for top-level windows (i.e. it will be ignored for windows created from the handle of a child window/control).

+
Parameters
+ + +
positionNew position, in pixels
+
+
+
See also
getPosition
+ +
+
+ +

◆ setSize()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setSize (const Vector2u & size)
+ 		+inherited
+
+ +

Change the size of the rendering region of the window.

+
Parameters
+ + +
sizeNew size, in pixels
+
+
+
See also
getSize
+ +
+
+ +

◆ setTitle()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setTitle (const String & title)
+ 		+inherited
+
+ +

Change the title of the window.

+
Parameters
+ + +
titleNew title
+
+
+
See also
setIcon
+ +
+
+ +

◆ setVerticalSyncEnabled()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Window::setVerticalSyncEnabled (bool enabled)
+ 		+inherited
+
+ +

Enable or disable vertical synchronization.

+

Activating vertical synchronization will limit the number of frames displayed to the refresh rate of the monitor. This can avoid some visual artifacts, and limit the framerate to a good value (but not constant across different computers).

+

Vertical synchronization is disabled by default.

+
Parameters
+ + +
enabledTrue to enable v-sync, false to deactivate it
+
+
+ +
+
+ +

◆ setView()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::RenderTarget::setView (const View & view)
+ 		+inherited
+
+ +

Change the current active view.

+

The view is like a 2D camera, it controls which part of the 2D scene is visible, and how it is viewed in the render target. The new view will affect everything that is drawn, until another view is set. The render target keeps its own copy of the view object, so it is not necessary to keep the original one alive after calling this function. To restore the original view of the target, you can pass the result of getDefaultView() to this function.

+
Parameters
+ + +
viewNew view to use
+
+
+
See also
getView, getDefaultView
+ +
+
+ +

◆ setVisible()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setVisible (bool visible)
+ 		+inherited
+
+ +

Show or hide the window.

+

The window is shown by default.

+
Parameters
+ + +
visibleTrue to show the window, false to hide it
+
+
+ +
+
+ +

◆ waitEvent()

+ +
+
+ + + + + +
+ + + + + + + + +
bool sf::WindowBase::waitEvent (Event & event)
+ 		+inherited
+
+ +

Wait for an event and return it.

+

This function is blocking: if there's no pending event then it will wait until an event is received. After this function returns (and no error occurred), the event object is always valid and filled properly. This function is typically used when you have a thread that is dedicated to events handling: you want to make this thread sleep as long as no new event is received.

sf::Event event;
+
if (window.waitEvent(event))
+
{
+
// process event...
+
}
+
Parameters
+ + +
eventEvent to be returned
+
+
+
Returns
False if any error occurred
+
See also
pollEvent
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1RenderWindow.png b/Space-Invaders/sfml/doc/html/classsf_1_1RenderWindow.png new file mode 100644 index 000000000..6dbfe5818 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1RenderWindow.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Sensor-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Sensor-members.html new file mode 100644 index 000000000..7c1ecd3fc --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Sensor-members.html @@ -0,0 +1,119 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Sensor Member List
+
+
+ +

This is the complete list of members for sf::Sensor, including all inherited members.

+ + + + + + + + + + + + +
Accelerometer enum valuesf::Sensor
Count enum valuesf::Sensor
getValue(Type sensor)sf::Sensorstatic
Gravity enum valuesf::Sensor
Gyroscope enum valuesf::Sensor
isAvailable(Type sensor)sf::Sensorstatic
Magnetometer enum valuesf::Sensor
Orientation enum valuesf::Sensor
setEnabled(Type sensor, bool enabled)sf::Sensorstatic
Type enum namesf::Sensor
UserAcceleration enum valuesf::Sensor
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Sensor.html b/Space-Invaders/sfml/doc/html/classsf_1_1Sensor.html new file mode 100644 index 000000000..aba634062 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Sensor.html @@ -0,0 +1,324 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Static Public Member Functions | +List of all members
+
sf::Sensor Class Reference
Window module
+
+
+ +

Give access to the real-time state of the sensors. + More...

+ +

#include <SFML/Window/Sensor.hpp>

+ + + + + +

+Public Types

enum  Type {
+  Accelerometer +, Gyroscope +, Magnetometer +, Gravity +,
+  UserAcceleration +, Orientation +, Count +
+ }
 Sensor type. More...
 
+ + + + + + + + + + +

+Static Public Member Functions

static bool isAvailable (Type sensor)
 Check if a sensor is available on the underlying platform.
 
static void setEnabled (Type sensor, bool enabled)
 Enable or disable a sensor.
 
static Vector3f getValue (Type sensor)
 Get the current sensor value.
 
+

Detailed Description

+

Give access to the real-time state of the sensors.

+

sf::Sensor provides an interface to the state of the various sensors that a device provides.

+

It only contains static functions, so it's not meant to be instantiated.

+

This class allows users to query the sensors values at any time and directly, without having to deal with a window and its events. Compared to the SensorChanged event, sf::Sensor can retrieve the state of a sensor at any time (you don't need to store and update its current value on your side).

+

Depending on the OS and hardware of the device (phone, tablet, ...), some sensor types may not be available. You should always check the availability of a sensor before trying to read it, with the sf::Sensor::isAvailable function.

+

You may wonder why some sensor types look so similar, for example Accelerometer and Gravity / UserAcceleration. The first one is the raw measurement of the acceleration, and takes into account both the earth gravity and the user movement. The others are more precise: they provide these components separately, which is usually more useful. In fact they are not direct sensors, they are computed internally based on the raw acceleration and other sensors. This is exactly the same for Gyroscope vs Orientation.

+

Because sensors consume a non-negligible amount of current, they are all disabled by default. You must call sf::Sensor::setEnabled for each sensor in which you are interested.

+

Usage example:

if (sf::Sensor::isAvailable(sf::Sensor::Gravity))
+
{
+
// gravity sensor is available
+
}
+
+
// enable the gravity sensor
+
sf::Sensor::setEnabled(sf::Sensor::Gravity, true);
+
+
// get the current value of gravity
+
sf::Vector3f gravity = sf::Sensor::getValue(sf::Sensor::Gravity);
+
sf::Sensor::Gravity
@ Gravity
Measures the direction and intensity of gravity, independent of device acceleration (m/s^2)
Definition: Sensor.hpp:55
+
sf::Sensor::isAvailable
static bool isAvailable(Type sensor)
Check if a sensor is available on the underlying platform.
+
sf::Sensor::getValue
static Vector3f getValue(Type sensor)
Get the current sensor value.
+
sf::Sensor::setEnabled
static void setEnabled(Type sensor, bool enabled)
Enable or disable a sensor.
+
sf::Vector3
Utility template class for manipulating 3-dimensional vectors.
Definition: Vector3.hpp:38
+
+

Definition at line 42 of file Sensor.hpp.

+

Member Enumeration Documentation

+ +

◆ Type

+ +
+
+ + + + +
enum sf::Sensor::Type
+
+ +

Sensor type.

+ + + + + + + + +
Enumerator
Accelerometer 

Measures the raw acceleration (m/s^2)

+
Gyroscope 

Measures the raw rotation rates (degrees/s)

+
Magnetometer 

Measures the ambient magnetic field (micro-teslas)

+
Gravity 

Measures the direction and intensity of gravity, independent of device acceleration (m/s^2)

+
UserAcceleration 

Measures the direction and intensity of device acceleration, independent of the gravity (m/s^2)

+
Orientation 

Measures the absolute 3D orientation (degrees)

+
Count 

Keep last – the total number of sensor types.

+
+ +

Definition at line 50 of file Sensor.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ getValue()

+ +
+
+ + + + + +
+ + + + + + + + +
static Vector3f sf::Sensor::getValue (Type sensor)
+ 		+static
+
+ +

Get the current sensor value.

+
Parameters
+ + +
sensorSensor to read
+
+
+
Returns
The current sensor value
+ +
+
+ +

◆ isAvailable()

+ +
+
+ + + + + +
+ + + + + + + + +
static bool sf::Sensor::isAvailable (Type sensor)
+ 		+static
+
+ +

Check if a sensor is available on the underlying platform.

+
Parameters
+ + +
sensorSensor to check
+
+
+
Returns
True if the sensor is available, false otherwise
+ +
+
+ +

◆ setEnabled()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void sf::Sensor::setEnabled (Type sensor,
bool enabled 
)
+ 		+static
+
+ +

Enable or disable a sensor.

+

All sensors are disabled by default, to avoid consuming too much battery power. Once a sensor is enabled, it starts sending events of the corresponding type.

+

This function does nothing if the sensor is unavailable.

+
Parameters
+ + + +
sensorSensor to enable
enabledTrue to enable, false to disable
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Shader-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Shader-members.html new file mode 100644 index 000000000..6ea2d0846 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Shader-members.html @@ -0,0 +1,160 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Shader Member List
+
+
+ +

This is the complete list of members for sf::Shader, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bind(const Shader *shader)sf::Shaderstatic
CurrentTexturesf::Shaderstatic
Fragment enum valuesf::Shader
Geometry enum valuesf::Shader
getNativeHandle() constsf::Shader
isAvailable()sf::Shaderstatic
isGeometryAvailable()sf::Shaderstatic
loadFromFile(const std::string &filename, Type type)sf::Shader
loadFromFile(const std::string &vertexShaderFilename, const std::string &fragmentShaderFilename)sf::Shader
loadFromFile(const std::string &vertexShaderFilename, const std::string &geometryShaderFilename, const std::string &fragmentShaderFilename)sf::Shader
loadFromMemory(const std::string &shader, Type type)sf::Shader
loadFromMemory(const std::string &vertexShader, const std::string &fragmentShader)sf::Shader
loadFromMemory(const std::string &vertexShader, const std::string &geometryShader, const std::string &fragmentShader)sf::Shader
loadFromStream(InputStream &stream, Type type)sf::Shader
loadFromStream(InputStream &vertexShaderStream, InputStream &fragmentShaderStream)sf::Shader
loadFromStream(InputStream &vertexShaderStream, InputStream &geometryShaderStream, InputStream &fragmentShaderStream)sf::Shader
setParameter(const std::string &name, float x)sf::Shader
setParameter(const std::string &name, float x, float y)sf::Shader
setParameter(const std::string &name, float x, float y, float z)sf::Shader
setParameter(const std::string &name, float x, float y, float z, float w)sf::Shader
setParameter(const std::string &name, const Vector2f &vector)sf::Shader
setParameter(const std::string &name, const Vector3f &vector)sf::Shader
setParameter(const std::string &name, const Color &color)sf::Shader
setParameter(const std::string &name, const Transform &transform)sf::Shader
setParameter(const std::string &name, const Texture &texture)sf::Shader
setParameter(const std::string &name, CurrentTextureType)sf::Shader
setUniform(const std::string &name, float x)sf::Shader
setUniform(const std::string &name, const Glsl::Vec2 &vector)sf::Shader
setUniform(const std::string &name, const Glsl::Vec3 &vector)sf::Shader
setUniform(const std::string &name, const Glsl::Vec4 &vector)sf::Shader
setUniform(const std::string &name, int x)sf::Shader
setUniform(const std::string &name, const Glsl::Ivec2 &vector)sf::Shader
setUniform(const std::string &name, const Glsl::Ivec3 &vector)sf::Shader
setUniform(const std::string &name, const Glsl::Ivec4 &vector)sf::Shader
setUniform(const std::string &name, bool x)sf::Shader
setUniform(const std::string &name, const Glsl::Bvec2 &vector)sf::Shader
setUniform(const std::string &name, const Glsl::Bvec3 &vector)sf::Shader
setUniform(const std::string &name, const Glsl::Bvec4 &vector)sf::Shader
setUniform(const std::string &name, const Glsl::Mat3 &matrix)sf::Shader
setUniform(const std::string &name, const Glsl::Mat4 &matrix)sf::Shader
setUniform(const std::string &name, const Texture &texture)sf::Shader
setUniform(const std::string &name, CurrentTextureType)sf::Shader
setUniformArray(const std::string &name, const float *scalarArray, std::size_t length)sf::Shader
setUniformArray(const std::string &name, const Glsl::Vec2 *vectorArray, std::size_t length)sf::Shader
setUniformArray(const std::string &name, const Glsl::Vec3 *vectorArray, std::size_t length)sf::Shader
setUniformArray(const std::string &name, const Glsl::Vec4 *vectorArray, std::size_t length)sf::Shader
setUniformArray(const std::string &name, const Glsl::Mat3 *matrixArray, std::size_t length)sf::Shader
setUniformArray(const std::string &name, const Glsl::Mat4 *matrixArray, std::size_t length)sf::Shader
Shader()sf::Shader
Type enum namesf::Shader
Vertex enum valuesf::Shader
~Shader()sf::Shader
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Shader.html b/Space-Invaders/sfml/doc/html/classsf_1_1Shader.html new file mode 100644 index 000000000..e11d75911 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Shader.html @@ -0,0 +1,2175 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +Static Public Member Functions | +Static Public Attributes | +List of all members
+
sf::Shader Class Reference
Graphics module
+
+
+ +

Shader class (vertex, geometry and fragment) + More...

+ +

#include <SFML/Graphics/Shader.hpp>

+
+Inheritance diagram for sf::Shader:
+
+
+ + +sf::GlResource +sf::NonCopyable + +
+ + + + + +

+Classes

struct  CurrentTextureType
 Special type that can be passed to setUniform(), and that represents the texture of the object being drawn. More...
 
+ + + + +

+Public Types

enum  Type { Vertex +, Geometry +, Fragment + }
 Types of shaders. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Shader ()
 Default constructor.
 
 ~Shader ()
 Destructor.
 
bool loadFromFile (const std::string &filename, Type type)
 Load the vertex, geometry or fragment shader from a file.
 
bool loadFromFile (const std::string &vertexShaderFilename, const std::string &fragmentShaderFilename)
 Load both the vertex and fragment shaders from files.
 
bool loadFromFile (const std::string &vertexShaderFilename, const std::string &geometryShaderFilename, const std::string &fragmentShaderFilename)
 Load the vertex, geometry and fragment shaders from files.
 
bool loadFromMemory (const std::string &shader, Type type)
 Load the vertex, geometry or fragment shader from a source code in memory.
 
bool loadFromMemory (const std::string &vertexShader, const std::string &fragmentShader)
 Load both the vertex and fragment shaders from source codes in memory.
 
bool loadFromMemory (const std::string &vertexShader, const std::string &geometryShader, const std::string &fragmentShader)
 Load the vertex, geometry and fragment shaders from source codes in memory.
 
bool loadFromStream (InputStream &stream, Type type)
 Load the vertex, geometry or fragment shader from a custom stream.
 
bool loadFromStream (InputStream &vertexShaderStream, InputStream &fragmentShaderStream)
 Load both the vertex and fragment shaders from custom streams.
 
bool loadFromStream (InputStream &vertexShaderStream, InputStream &geometryShaderStream, InputStream &fragmentShaderStream)
 Load the vertex, geometry and fragment shaders from custom streams.
 
void setUniform (const std::string &name, float x)
 Specify value for float uniform.
 
void setUniform (const std::string &name, const Glsl::Vec2 &vector)
 Specify value for vec2 uniform.
 
void setUniform (const std::string &name, const Glsl::Vec3 &vector)
 Specify value for vec3 uniform.
 
void setUniform (const std::string &name, const Glsl::Vec4 &vector)
 Specify value for vec4 uniform.
 
void setUniform (const std::string &name, int x)
 Specify value for int uniform.
 
void setUniform (const std::string &name, const Glsl::Ivec2 &vector)
 Specify value for ivec2 uniform.
 
void setUniform (const std::string &name, const Glsl::Ivec3 &vector)
 Specify value for ivec3 uniform.
 
void setUniform (const std::string &name, const Glsl::Ivec4 &vector)
 Specify value for ivec4 uniform.
 
void setUniform (const std::string &name, bool x)
 Specify value for bool uniform.
 
void setUniform (const std::string &name, const Glsl::Bvec2 &vector)
 Specify value for bvec2 uniform.
 
void setUniform (const std::string &name, const Glsl::Bvec3 &vector)
 Specify value for bvec3 uniform.
 
void setUniform (const std::string &name, const Glsl::Bvec4 &vector)
 Specify value for bvec4 uniform.
 
void setUniform (const std::string &name, const Glsl::Mat3 &matrix)
 Specify value for mat3 matrix.
 
void setUniform (const std::string &name, const Glsl::Mat4 &matrix)
 Specify value for mat4 matrix.
 
void setUniform (const std::string &name, const Texture &texture)
 Specify a texture as sampler2D uniform.
 
void setUniform (const std::string &name, CurrentTextureType)
 Specify current texture as sampler2D uniform.
 
void setUniformArray (const std::string &name, const float *scalarArray, std::size_t length)
 Specify values for float[] array uniform.
 
void setUniformArray (const std::string &name, const Glsl::Vec2 *vectorArray, std::size_t length)
 Specify values for vec2[] array uniform.
 
void setUniformArray (const std::string &name, const Glsl::Vec3 *vectorArray, std::size_t length)
 Specify values for vec3[] array uniform.
 
void setUniformArray (const std::string &name, const Glsl::Vec4 *vectorArray, std::size_t length)
 Specify values for vec4[] array uniform.
 
void setUniformArray (const std::string &name, const Glsl::Mat3 *matrixArray, std::size_t length)
 Specify values for mat3[] array uniform.
 
void setUniformArray (const std::string &name, const Glsl::Mat4 *matrixArray, std::size_t length)
 Specify values for mat4[] array uniform.
 
void setParameter (const std::string &name, float x)
 Change a float parameter of the shader.
 
void setParameter (const std::string &name, float x, float y)
 Change a 2-components vector parameter of the shader.
 
void setParameter (const std::string &name, float x, float y, float z)
 Change a 3-components vector parameter of the shader.
 
void setParameter (const std::string &name, float x, float y, float z, float w)
 Change a 4-components vector parameter of the shader.
 
void setParameter (const std::string &name, const Vector2f &vector)
 Change a 2-components vector parameter of the shader.
 
void setParameter (const std::string &name, const Vector3f &vector)
 Change a 3-components vector parameter of the shader.
 
void setParameter (const std::string &name, const Color &color)
 Change a color parameter of the shader.
 
void setParameter (const std::string &name, const Transform &transform)
 Change a matrix parameter of the shader.
 
void setParameter (const std::string &name, const Texture &texture)
 Change a texture parameter of the shader.
 
void setParameter (const std::string &name, CurrentTextureType)
 Change a texture parameter of the shader.
 
unsigned int getNativeHandle () const
 Get the underlying OpenGL handle of the shader.
 
+ + + + + + + + + + +

+Static Public Member Functions

static void bind (const Shader *shader)
 Bind a shader for rendering.
 
static bool isAvailable ()
 Tell whether or not the system supports shaders.
 
static bool isGeometryAvailable ()
 Tell whether or not the system supports geometry shaders.
 
+ + + + +

+Static Public Attributes

static CurrentTextureType CurrentTexture
 Represents the texture of the object being drawn.
 
+

Detailed Description

+

Shader class (vertex, geometry and fragment)

+

Shaders are programs written using a specific language, executed directly by the graphics card and allowing to apply real-time operations to the rendered entities.

+

There are three kinds of shaders:

    +
  • Vertex shaders, that process vertices
    • +
  • Geometry shaders, that process primitives
    • +
  • Fragment (pixel) shaders, that process pixels
    • +
+

A sf::Shader can be composed of either a vertex shader alone, a geometry shader alone, a fragment shader alone, or any combination of them. (see the variants of the load functions).

+

Shaders are written in GLSL, which is a C-like language dedicated to OpenGL shaders. You'll probably need to learn its basics before writing your own shaders for SFML.

+

Like any C/C++ program, a GLSL shader has its own variables called uniforms that you can set from your C++ application. sf::Shader handles different types of uniforms:

    +
  • scalars: float, int, bool
    • +
  • vectors (2, 3 or 4 components)
    • +
  • matrices (3x3 or 4x4)
    • +
  • samplers (textures)
    • +
+

Some SFML-specific types can be converted:

+

Every uniform variable in a shader can be set through one of the setUniform() or setUniformArray() overloads. For example, if you have a shader with the following uniforms:

uniform float offset;
+
uniform vec3 point;
+
uniform vec4 color;
+
uniform mat4 matrix;
+
uniform sampler2D overlay;
+
uniform sampler2D current;
+

You can set their values from C++ code as follows, using the types defined in the sf::Glsl namespace:

shader.setUniform("offset", 2.f);
+
shader.setUniform("point", sf::Vector3f(0.5f, 0.8f, 0.3f));
+
shader.setUniform("color", sf::Glsl::Vec4(color)); // color is a sf::Color
+
shader.setUniform("matrix", sf::Glsl::Mat4(transform)); // transform is a sf::Transform
+
shader.setUniform("overlay", texture); // texture is a sf::Texture
+
shader.setUniform("current", sf::Shader::CurrentTexture);
+
sf::Shader::CurrentTexture
static CurrentTextureType CurrentTexture
Represents the texture of the object being drawn.
Definition: Shader.hpp:82
+
sf::Vector3
Utility template class for manipulating 3-dimensional vectors.
Definition: Vector3.hpp:38
+
sf::Glsl::Mat4
implementation defined Mat4
4x4 float matrix (mat4 in GLSL)
Definition: Glsl.hpp:181
+
sf::Glsl::Vec4
implementation defined Vec4
4D float vector (vec4 in GLSL)
Definition: Glsl.hpp:110
+

The old setParameter() overloads are deprecated and will be removed in a future version. You should use their setUniform() equivalents instead.

+

The special Shader::CurrentTexture argument maps the given sampler2D uniform to the current texture of the object being drawn (which cannot be known in advance).

+

To apply a shader to a drawable, you must pass it as an additional parameter to the RenderWindow::draw function:

window.draw(sprite, &shader);
+

... which is in fact just a shortcut for this:

sf::RenderStates states;
+
states.shader = &shader;
+
window.draw(sprite, states);
+
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderStates::shader
const Shader * shader
Shader.
Definition: RenderStates.hpp:118
+

In the code above we pass a pointer to the shader, because it may be null (which means "no shader").

+

Shaders can be used on any drawable, but some combinations are not interesting. For example, using a vertex shader on a sf::Sprite is limited because there are only 4 vertices, the sprite would have to be subdivided in order to apply wave effects. Another bad example is a fragment shader with sf::Text: the texture of the text is not the actual text that you see on screen, it is a big texture containing all the characters of the font in an arbitrary order; thus, texture lookups on pixels other than the current one may not give you the expected result.

+

Shaders can also be used to apply global post-effects to the current contents of the target (like the old sf::PostFx class in SFML 1). This can be done in two different ways:

    +
  • draw everything to a sf::RenderTexture, then draw it to the main target using the shader
    • +
  • draw everything directly to the main target, then use sf::Texture::update(Window&) to copy its contents to a texture and draw it to the main target using the shader
    • +
+

The first technique is more optimized because it doesn't involve retrieving the target's pixels to system memory, but the second one doesn't impact the rendering process and can be easily inserted anywhere without impacting all the code.

+

Like sf::Texture that can be used as a raw OpenGL texture, sf::Shader can also be used directly as a raw shader for custom OpenGL geometry.

sf::Shader::bind(&shader);
+
... render OpenGL geometry ...
+
sf::Shader::bind(NULL);
+
sf::Shader::bind
static void bind(const Shader *shader)
Bind a shader for rendering.
+
See also
sf::Glsl
+ +

Definition at line 52 of file Shader.hpp.

+

Member Enumeration Documentation

+ +

◆ Type

+ +
+
+ + + + +
enum sf::Shader::Type
+
+ +

Types of shaders.

+ + + + +
Enumerator
Vertex 

Vertex shader

+
Geometry 

Geometry shader.

+
Fragment 

Fragment (pixel) shader.

+
+ +

Definition at line 60 of file Shader.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Shader()

+ +
+
+ + + + + + + +
sf::Shader::Shader ()
+
+ +

Default constructor.

+

This constructor creates an invalid shader.

+ +
+
+ +

◆ ~Shader()

+ +
+
+ + + + + + + +
sf::Shader::~Shader ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ bind()

+ +
+
+ + + + + +
+ + + + + + + + +
static void sf::Shader::bind (const Shader * shader)
+ 		+static
+
+ +

Bind a shader for rendering.

+

This function is not part of the graphics API, it mustn't be used when drawing SFML entities. It must be used only if you mix sf::Shader with OpenGL code.

+
sf::Shader s1, s2;
+
...
+
sf::Shader::bind(&s1);
+
// draw OpenGL stuff that use s1...
+
sf::Shader::bind(&s2);
+
// draw OpenGL stuff that use s2...
+
sf::Shader::bind(NULL);
+
// draw OpenGL stuff that use no shader...
+
sf::Shader
Shader class (vertex, geometry and fragment)
Definition: Shader.hpp:53
+
Parameters
+ + +
shaderShader to bind, can be null to use no shader
+
+
+ +
+
+ +

◆ getNativeHandle()

+ +
+
+ + + + + + + +
unsigned int sf::Shader::getNativeHandle () const
+
+ +

Get the underlying OpenGL handle of the shader.

+

You shouldn't need to use this function, unless you have very specific stuff to implement that SFML doesn't support, or implement a temporary workaround until a bug is fixed.

+
Returns
OpenGL handle of the shader or 0 if not yet loaded
+ +
+
+ +

◆ isAvailable()

+ +
+
+ + + + + +
+ + + + + + + +
static bool sf::Shader::isAvailable ()
+ 		+static
+
+ +

Tell whether or not the system supports shaders.

+

This function should always be called before using the shader features. If it returns false, then any attempt to use sf::Shader will fail.

+
Returns
True if shaders are supported, false otherwise
+ +
+
+ +

◆ isGeometryAvailable()

+ +
+
+ + + + + +
+ + + + + + + +
static bool sf::Shader::isGeometryAvailable ()
+ 		+static
+
+ +

Tell whether or not the system supports geometry shaders.

+

This function should always be called before using the geometry shader features. If it returns false, then any attempt to use sf::Shader geometry shader features will fail.

+

This function can only return true if isAvailable() would also return true, since shaders in general have to be supported in order for geometry shaders to be supported as well.

+

Note: The first call to this function, whether by your code or SFML will result in a context switch.

+
Returns
True if geometry shaders are supported, false otherwise
+ +
+
+ +

◆ loadFromFile() [1/3]

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Shader::loadFromFile (const std::string & filename,
Type type 
)
+
+ +

Load the vertex, geometry or fragment shader from a file.

+

This function loads a single shader, vertex, geometry or fragment, identified by the second argument. The source must be a text file containing a valid shader in GLSL language. GLSL is a C-like language dedicated to OpenGL shaders; you'll probably need to read a good documentation for it before writing your own shaders.

+
Parameters
+ + + +
filenamePath of the vertex, geometry or fragment shader file to load
typeType of shader (vertex, geometry or fragment)
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromMemory, loadFromStream
+ +
+
+ +

◆ loadFromFile() [2/3]

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Shader::loadFromFile (const std::string & vertexShaderFilename,
const std::string & fragmentShaderFilename 
)
+
+ +

Load both the vertex and fragment shaders from files.

+

This function loads both the vertex and the fragment shaders. If one of them fails to load, the shader is left empty (the valid shader is unloaded). The sources must be text files containing valid shaders in GLSL language. GLSL is a C-like language dedicated to OpenGL shaders; you'll probably need to read a good documentation for it before writing your own shaders.

+
Parameters
+ + + +
vertexShaderFilenamePath of the vertex shader file to load
fragmentShaderFilenamePath of the fragment shader file to load
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromMemory, loadFromStream
+ +
+
+ +

◆ loadFromFile() [3/3]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::Shader::loadFromFile (const std::string & vertexShaderFilename,
const std::string & geometryShaderFilename,
const std::string & fragmentShaderFilename 
)
+
+ +

Load the vertex, geometry and fragment shaders from files.

+

This function loads the vertex, geometry and fragment shaders. If one of them fails to load, the shader is left empty (the valid shader is unloaded). The sources must be text files containing valid shaders in GLSL language. GLSL is a C-like language dedicated to OpenGL shaders; you'll probably need to read a good documentation for it before writing your own shaders.

+
Parameters
+ + + + +
vertexShaderFilenamePath of the vertex shader file to load
geometryShaderFilenamePath of the geometry shader file to load
fragmentShaderFilenamePath of the fragment shader file to load
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromMemory, loadFromStream
+ +
+
+ +

◆ loadFromMemory() [1/3]

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Shader::loadFromMemory (const std::string & shader,
Type type 
)
+
+ +

Load the vertex, geometry or fragment shader from a source code in memory.

+

This function loads a single shader, vertex, geometry or fragment, identified by the second argument. The source code must be a valid shader in GLSL language. GLSL is a C-like language dedicated to OpenGL shaders; you'll probably need to read a good documentation for it before writing your own shaders.

+
Parameters
+ + + +
shaderString containing the source code of the shader
typeType of shader (vertex, geometry or fragment)
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromStream
+ +
+
+ +

◆ loadFromMemory() [2/3]

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Shader::loadFromMemory (const std::string & vertexShader,
const std::string & fragmentShader 
)
+
+ +

Load both the vertex and fragment shaders from source codes in memory.

+

This function loads both the vertex and the fragment shaders. If one of them fails to load, the shader is left empty (the valid shader is unloaded). The sources must be valid shaders in GLSL language. GLSL is a C-like language dedicated to OpenGL shaders; you'll probably need to read a good documentation for it before writing your own shaders.

+
Parameters
+ + + +
vertexShaderString containing the source code of the vertex shader
fragmentShaderString containing the source code of the fragment shader
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromStream
+ +
+
+ +

◆ loadFromMemory() [3/3]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::Shader::loadFromMemory (const std::string & vertexShader,
const std::string & geometryShader,
const std::string & fragmentShader 
)
+
+ +

Load the vertex, geometry and fragment shaders from source codes in memory.

+

This function loads the vertex, geometry and fragment shaders. If one of them fails to load, the shader is left empty (the valid shader is unloaded). The sources must be valid shaders in GLSL language. GLSL is a C-like language dedicated to OpenGL shaders; you'll probably need to read a good documentation for it before writing your own shaders.

+
Parameters
+ + + + +
vertexShaderString containing the source code of the vertex shader
geometryShaderString containing the source code of the geometry shader
fragmentShaderString containing the source code of the fragment shader
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromStream
+ +
+
+ +

◆ loadFromStream() [1/3]

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Shader::loadFromStream (InputStream & stream,
Type type 
)
+
+ +

Load the vertex, geometry or fragment shader from a custom stream.

+

This function loads a single shader, vertex, geometry or fragment, identified by the second argument. The source code must be a valid shader in GLSL language. GLSL is a C-like language dedicated to OpenGL shaders; you'll probably need to read a good documentation for it before writing your own shaders.

+
Parameters
+ + + +
streamSource stream to read from
typeType of shader (vertex, geometry or fragment)
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromMemory
+ +
+
+ +

◆ loadFromStream() [2/3]

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Shader::loadFromStream (InputStream & vertexShaderStream,
InputStream & fragmentShaderStream 
)
+
+ +

Load both the vertex and fragment shaders from custom streams.

+

This function loads both the vertex and the fragment shaders. If one of them fails to load, the shader is left empty (the valid shader is unloaded). The source codes must be valid shaders in GLSL language. GLSL is a C-like language dedicated to OpenGL shaders; you'll probably need to read a good documentation for it before writing your own shaders.

+
Parameters
+ + + +
vertexShaderStreamSource stream to read the vertex shader from
fragmentShaderStreamSource stream to read the fragment shader from
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromMemory
+ +
+
+ +

◆ loadFromStream() [3/3]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::Shader::loadFromStream (InputStream & vertexShaderStream,
InputStream & geometryShaderStream,
InputStream & fragmentShaderStream 
)
+
+ +

Load the vertex, geometry and fragment shaders from custom streams.

+

This function loads the vertex, geometry and fragment shaders. If one of them fails to load, the shader is left empty (the valid shader is unloaded). The source codes must be valid shaders in GLSL language. GLSL is a C-like language dedicated to OpenGL shaders; you'll probably need to read a good documentation for it before writing your own shaders.

+
Parameters
+ + + + +
vertexShaderStreamSource stream to read the vertex shader from
geometryShaderStreamSource stream to read the geometry shader from
fragmentShaderStreamSource stream to read the fragment shader from
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromMemory
+ +
+
+ +

◆ setParameter() [1/10]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setParameter (const std::string & name,
const Color & color 
)
+
+ +

Change a color parameter of the shader.

+
Deprecated:
Use setUniform(const std::string&, const Glsl::Vec4&) instead.
+ +
+
+ +

◆ setParameter() [2/10]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setParameter (const std::string & name,
const Texture & texture 
)
+
+ +

Change a texture parameter of the shader.

+
Deprecated:
Use setUniform(const std::string&, const Texture&) instead.
+ +
+
+ +

◆ setParameter() [3/10]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setParameter (const std::string & name,
const Transform & transform 
)
+
+ +

Change a matrix parameter of the shader.

+
Deprecated:
Use setUniform(const std::string&, const Glsl::Mat4&) instead.
+ +
+
+ +

◆ setParameter() [4/10]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setParameter (const std::string & name,
const Vector2f & vector 
)
+
+ +

Change a 2-components vector parameter of the shader.

+
Deprecated:
Use setUniform(const std::string&, const Glsl::Vec2&) instead.
+ +
+
+ +

◆ setParameter() [5/10]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setParameter (const std::string & name,
const Vector3f & vector 
)
+
+ +

Change a 3-components vector parameter of the shader.

+
Deprecated:
Use setUniform(const std::string&, const Glsl::Vec3&) instead.
+ +
+
+ +

◆ setParameter() [6/10]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setParameter (const std::string & name,
CurrentTextureType  
)
+
+ +

Change a texture parameter of the shader.

+
Deprecated:
Use setUniform(const std::string&, CurrentTextureType) instead.
+ +
+
+ +

◆ setParameter() [7/10]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setParameter (const std::string & name,
float x 
)
+
+ +

Change a float parameter of the shader.

+
Deprecated:
Use setUniform(const std::string&, float) instead.
+ +
+
+ +

◆ setParameter() [8/10]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Shader::setParameter (const std::string & name,
float x,
float y 
)
+
+ +

Change a 2-components vector parameter of the shader.

+
Deprecated:
Use setUniform(const std::string&, const Glsl::Vec2&) instead.
+ +
+
+ +

◆ setParameter() [9/10]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Shader::setParameter (const std::string & name,
float x,
float y,
float z 
)
+
+ +

Change a 3-components vector parameter of the shader.

+
Deprecated:
Use setUniform(const std::string&, const Glsl::Vec3&) instead.
+ +
+
+ +

◆ setParameter() [10/10]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Shader::setParameter (const std::string & name,
float x,
float y,
float z,
float w 
)
+
+ +

Change a 4-components vector parameter of the shader.

+
Deprecated:
Use setUniform(const std::string&, const Glsl::Vec4&) instead.
+ +
+
+ +

◆ setUniform() [1/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
bool x 
)
+
+ +

Specify value for bool uniform.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
xValue of the bool scalar
+
+
+ +
+
+ +

◆ setUniform() [2/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Bvec2 & vector 
)
+
+ +

Specify value for bvec2 uniform.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
vectorValue of the bvec2 vector
+
+
+ +
+
+ +

◆ setUniform() [3/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Bvec3 & vector 
)
+
+ +

Specify value for bvec3 uniform.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
vectorValue of the bvec3 vector
+
+
+ +
+
+ +

◆ setUniform() [4/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Bvec4 & vector 
)
+
+ +

Specify value for bvec4 uniform.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
vectorValue of the bvec4 vector
+
+
+ +
+
+ +

◆ setUniform() [5/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Ivec2 & vector 
)
+
+ +

Specify value for ivec2 uniform.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
vectorValue of the ivec2 vector
+
+
+ +
+
+ +

◆ setUniform() [6/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Ivec3 & vector 
)
+
+ +

Specify value for ivec3 uniform.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
vectorValue of the ivec3 vector
+
+
+ +
+
+ +

◆ setUniform() [7/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Ivec4 & vector 
)
+
+ +

Specify value for ivec4 uniform.

+

This overload can also be called with sf::Color objects that are converted to sf::Glsl::Ivec4.

+

If color conversions are used, the ivec4 uniform in GLSL will hold the same values as the original sf::Color instance. For example, sf::Color(255, 127, 0, 255) is mapped to ivec4(255, 127, 0, 255).

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
vectorValue of the ivec4 vector
+
+
+ +
+
+ +

◆ setUniform() [8/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Mat3 & matrix 
)
+
+ +

Specify value for mat3 matrix.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
matrixValue of the mat3 matrix
+
+
+ +
+
+ +

◆ setUniform() [9/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Mat4 & matrix 
)
+
+ +

Specify value for mat4 matrix.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
matrixValue of the mat4 matrix
+
+
+ +
+
+ +

◆ setUniform() [10/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Vec2 & vector 
)
+
+ +

Specify value for vec2 uniform.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
vectorValue of the vec2 vector
+
+
+ +
+
+ +

◆ setUniform() [11/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Vec3 & vector 
)
+
+ +

Specify value for vec3 uniform.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
vectorValue of the vec3 vector
+
+
+ +
+
+ +

◆ setUniform() [12/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Glsl::Vec4 & vector 
)
+
+ +

Specify value for vec4 uniform.

+

This overload can also be called with sf::Color objects that are converted to sf::Glsl::Vec4.

+

It is important to note that the components of the color are normalized before being passed to the shader. Therefore, they are converted from range [0 .. 255] to range [0 .. 1]. For example, a sf::Color(255, 127, 0, 255) will be transformed to a vec4(1.0, 0.5, 0.0, 1.0) in the shader.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
vectorValue of the vec4 vector
+
+
+ +
+
+ +

◆ setUniform() [13/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
const Texture & texture 
)
+
+ +

Specify a texture as sampler2D uniform.

+

name is the name of the variable to change in the shader. The corresponding parameter in the shader must be a 2D texture (sampler2D GLSL type).

+

Example:

uniform sampler2D the_texture; // this is the variable in the shader
+
sf::Texture texture;
+
...
+
shader.setUniform("the_texture", texture);
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+

It is important to note that texture must remain alive as long as the shader uses it, no copy is made internally.

+

To use the texture of the object being drawn, which cannot be known in advance, you can pass the special value sf::Shader::CurrentTexture:

shader.setUniform("the_texture", sf::Shader::CurrentTexture).
+
Parameters
+ + + +
nameName of the texture in the shader
textureTexture to assign
+
+
+ +
+
+ +

◆ setUniform() [14/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
CurrentTextureType  
)
+
+ +

Specify current texture as sampler2D uniform.

+

This overload maps a shader texture variable to the texture of the object being drawn, which cannot be known in advance. The second argument must be sf::Shader::CurrentTexture. The corresponding parameter in the shader must be a 2D texture (sampler2D GLSL type).

+

Example:

uniform sampler2D current; // this is the variable in the shader
+
shader.setUniform("current", sf::Shader::CurrentTexture);
+
Parameters
+ + +
nameName of the texture in the shader
+
+
+ +
+
+ +

◆ setUniform() [15/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
float x 
)
+
+ +

Specify value for float uniform.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
xValue of the float scalar
+
+
+ +
+
+ +

◆ setUniform() [16/16]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniform (const std::string & name,
int x 
)
+
+ +

Specify value for int uniform.

+
Parameters
+ + + +
nameName of the uniform variable in GLSL
xValue of the int scalar
+
+
+ +
+
+ +

◆ setUniformArray() [1/6]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniformArray (const std::string & name,
const float * scalarArray,
std::size_t length 
)
+
+ +

Specify values for float[] array uniform.

+
Parameters
+ + + + +
nameName of the uniform variable in GLSL
scalarArraypointer to array of float values
lengthNumber of elements in the array
+
+
+ +
+
+ +

◆ setUniformArray() [2/6]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniformArray (const std::string & name,
const Glsl::Mat3 * matrixArray,
std::size_t length 
)
+
+ +

Specify values for mat3[] array uniform.

+
Parameters
+ + + + +
nameName of the uniform variable in GLSL
matrixArraypointer to array of mat3 values
lengthNumber of elements in the array
+
+
+ +
+
+ +

◆ setUniformArray() [3/6]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniformArray (const std::string & name,
const Glsl::Mat4 * matrixArray,
std::size_t length 
)
+
+ +

Specify values for mat4[] array uniform.

+
Parameters
+ + + + +
nameName of the uniform variable in GLSL
matrixArraypointer to array of mat4 values
lengthNumber of elements in the array
+
+
+ +
+
+ +

◆ setUniformArray() [4/6]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniformArray (const std::string & name,
const Glsl::Vec2 * vectorArray,
std::size_t length 
)
+
+ +

Specify values for vec2[] array uniform.

+
Parameters
+ + + + +
nameName of the uniform variable in GLSL
vectorArraypointer to array of vec2 values
lengthNumber of elements in the array
+
+
+ +
+
+ +

◆ setUniformArray() [5/6]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniformArray (const std::string & name,
const Glsl::Vec3 * vectorArray,
std::size_t length 
)
+
+ +

Specify values for vec3[] array uniform.

+
Parameters
+ + + + +
nameName of the uniform variable in GLSL
vectorArraypointer to array of vec3 values
lengthNumber of elements in the array
+
+
+ +
+
+ +

◆ setUniformArray() [6/6]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Shader::setUniformArray (const std::string & name,
const Glsl::Vec4 * vectorArray,
std::size_t length 
)
+
+ +

Specify values for vec4[] array uniform.

+
Parameters
+ + + + +
nameName of the uniform variable in GLSL
vectorArraypointer to array of vec4 values
lengthNumber of elements in the array
+
+
+ +
+
+

Member Data Documentation

+ +

◆ CurrentTexture

+ +
+
+ + + + + +
+ + + + +
CurrentTextureType sf::Shader::CurrentTexture
+ 		+static
+
+ +

Represents the texture of the object being drawn.

+
See also
setUniform(const std::string&, CurrentTextureType)
+ +

Definition at line 82 of file Shader.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Shader.png b/Space-Invaders/sfml/doc/html/classsf_1_1Shader.png new file mode 100644 index 000000000..90ad37ea6 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Shader.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Shape-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Shape-members.html new file mode 100644 index 000000000..fe7246ab9 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Shape-members.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Shape Member List
+
+
+ +

This is the complete list of members for sf::Shape, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
getFillColor() constsf::Shape
getGlobalBounds() constsf::Shape
getInverseTransform() constsf::Transformable
getLocalBounds() constsf::Shape
getOrigin() constsf::Transformable
getOutlineColor() constsf::Shape
getOutlineThickness() constsf::Shape
getPoint(std::size_t index) const =0sf::Shapepure virtual
getPointCount() const =0sf::Shapepure virtual
getPosition() constsf::Transformable
getRotation() constsf::Transformable
getScale() constsf::Transformable
getTexture() constsf::Shape
getTextureRect() constsf::Shape
getTransform() constsf::Transformable
move(float offsetX, float offsetY)sf::Transformable
move(const Vector2f &offset)sf::Transformable
rotate(float angle)sf::Transformable
scale(float factorX, float factorY)sf::Transformable
scale(const Vector2f &factor)sf::Transformable
setFillColor(const Color &color)sf::Shape
setOrigin(float x, float y)sf::Transformable
setOrigin(const Vector2f &origin)sf::Transformable
setOutlineColor(const Color &color)sf::Shape
setOutlineThickness(float thickness)sf::Shape
setPosition(float x, float y)sf::Transformable
setPosition(const Vector2f &position)sf::Transformable
setRotation(float angle)sf::Transformable
setScale(float factorX, float factorY)sf::Transformable
setScale(const Vector2f &factors)sf::Transformable
setTexture(const Texture *texture, bool resetRect=false)sf::Shape
setTextureRect(const IntRect &rect)sf::Shape
Shape()sf::Shapeprotected
Transformable()sf::Transformable
update()sf::Shapeprotected
~Drawable()sf::Drawableinlinevirtual
~Shape()sf::Shapevirtual
~Transformable()sf::Transformablevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Shape.html b/Space-Invaders/sfml/doc/html/classsf_1_1Shape.html new file mode 100644 index 000000000..546175073 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Shape.html @@ -0,0 +1,1389 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Protected Member Functions | +List of all members
+
sf::Shape Class Referenceabstract
Graphics module
+
+
+ +

Base class for textured shapes with outline. + More...

+ +

#include <SFML/Graphics/Shape.hpp>

+
+Inheritance diagram for sf::Shape:
+
+
+ + +sf::Drawable +sf::Transformable +sf::CircleShape +sf::ConvexShape +sf::RectangleShape + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

virtual ~Shape ()
 Virtual destructor.
 
void setTexture (const Texture *texture, bool resetRect=false)
 Change the source texture of the shape.
 
void setTextureRect (const IntRect &rect)
 Set the sub-rectangle of the texture that the shape will display.
 
void setFillColor (const Color &color)
 Set the fill color of the shape.
 
void setOutlineColor (const Color &color)
 Set the outline color of the shape.
 
void setOutlineThickness (float thickness)
 Set the thickness of the shape's outline.
 
const Texture * getTexture () const
 Get the source texture of the shape.
 
const IntRect & getTextureRect () const
 Get the sub-rectangle of the texture displayed by the shape.
 
const Color & getFillColor () const
 Get the fill color of the shape.
 
const Color & getOutlineColor () const
 Get the outline color of the shape.
 
float getOutlineThickness () const
 Get the outline thickness of the shape.
 
virtual std::size_t getPointCount () const =0
 Get the total number of points of the shape.
 
virtual Vector2f getPoint (std::size_t index) const =0
 Get a point of the shape.
 
FloatRect getLocalBounds () const
 Get the local bounding rectangle of the entity.
 
FloatRect getGlobalBounds () const
 Get the global (non-minimal) bounding rectangle of the entity.
 
void setPosition (float x, float y)
 set the position of the object
 
void setPosition (const Vector2f &position)
 set the position of the object
 
void setRotation (float angle)
 set the orientation of the object
 
void setScale (float factorX, float factorY)
 set the scale factors of the object
 
void setScale (const Vector2f &factors)
 set the scale factors of the object
 
void setOrigin (float x, float y)
 set the local origin of the object
 
void setOrigin (const Vector2f &origin)
 set the local origin of the object
 
const Vector2f & getPosition () const
 get the position of the object
 
float getRotation () const
 get the orientation of the object
 
const Vector2f & getScale () const
 get the current scale of the object
 
const Vector2f & getOrigin () const
 get the local origin of the object
 
void move (float offsetX, float offsetY)
 Move the object by a given offset.
 
void move (const Vector2f &offset)
 Move the object by a given offset.
 
void rotate (float angle)
 Rotate the object.
 
void scale (float factorX, float factorY)
 Scale the object.
 
void scale (const Vector2f &factor)
 Scale the object.
 
const Transform & getTransform () const
 get the combined transform of the object
 
const Transform & getInverseTransform () const
 get the inverse of the combined transform of the object
 
+ + + + + + + +

+Protected Member Functions

 Shape ()
 Default constructor.
 
void update ()
 Recompute the internal geometry of the shape.
 
+

Detailed Description

+

Base class for textured shapes with outline.

+

sf::Shape is a drawable class that allows to define and display a custom convex shape on a render target.

+

It's only an abstract base, it needs to be specialized for concrete types of shapes (circle, rectangle, convex polygon, star, ...).

+

In addition to the attributes provided by the specialized shape classes, a shape always has the following attributes:

    +
  • a texture
    • +
  • a texture rectangle
    • +
  • a fill color
    • +
  • an outline color
    • +
  • an outline thickness
    • +
+

Each feature is optional, and can be disabled easily:

    +
  • the texture can be null
    • +
  • the fill/outline colors can be sf::Color::Transparent
    • +
  • the outline thickness can be zero
    • +
+

You can write your own derived shape class, there are only two virtual functions to override:

    +
  • getPointCount must return the number of points of the shape
    • +
  • getPoint must return the points of the shape
    • +
+
See also
sf::RectangleShape, sf::CircleShape, sf::ConvexShape, sf::Transformable
+ +

Definition at line 44 of file Shape.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ~Shape()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::Shape::~Shape ()
+ 		+virtual
+
+ +

Virtual destructor.

+ +
+
+ +

◆ Shape()

+ +
+
+ + + + + +
+ + + + + + + +
sf::Shape::Shape ()
+ 		+protected
+
+ +

Default constructor.

+ +
+
+

Member Function Documentation

+ +

◆ getFillColor()

+ +
+
+ + + + + + + +
const Color & sf::Shape::getFillColor () const
+
+ +

Get the fill color of the shape.

+
Returns
Fill color of the shape
+
See also
setFillColor
+ +
+
+ +

◆ getGlobalBounds()

+ +
+
+ + + + + + + +
FloatRect sf::Shape::getGlobalBounds () const
+
+ +

Get the global (non-minimal) bounding rectangle of the entity.

+

The returned rectangle is in global coordinates, which means that it takes into account the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the shape in the global 2D world's coordinate system.

+

This function does not necessarily return the minimal bounding rectangle. It merely ensures that the returned rectangle covers all the vertices (but possibly more). This allows for a fast approximation of the bounds as a first check; you may want to use more precise checks on top of that.

+
Returns
Global bounding rectangle of the entity
+ +
+
+ +

◆ getInverseTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getInverseTransform () const
+ 		+inherited
+
+ +

get the inverse of the combined transform of the object

+
Returns
Inverse of the combined transformations applied to the object
+
See also
getTransform
+ +
+
+ +

◆ getLocalBounds()

+ +
+
+ + + + + + + +
FloatRect sf::Shape::getLocalBounds () const
+
+ +

Get the local bounding rectangle of the entity.

+

The returned rectangle is in local coordinates, which means that it ignores the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the entity in the entity's coordinate system.

+
Returns
Local bounding rectangle of the entity
+ +
+
+ +

◆ getOrigin()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getOrigin () const
+ 		+inherited
+
+ +

get the local origin of the object

+
Returns
Current origin
+
See also
setOrigin
+ +
+
+ +

◆ getOutlineColor()

+ +
+
+ + + + + + + +
const Color & sf::Shape::getOutlineColor () const
+
+ +

Get the outline color of the shape.

+
Returns
Outline color of the shape
+
See also
setOutlineColor
+ +
+
+ +

◆ getOutlineThickness()

+ +
+
+ + + + + + + +
float sf::Shape::getOutlineThickness () const
+
+ +

Get the outline thickness of the shape.

+
Returns
Outline thickness of the shape
+
See also
setOutlineThickness
+ +
+
+ +

◆ getPoint()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual Vector2f sf::Shape::getPoint (std::size_t index) const
+ 		+pure virtual
+
+ +

Get a point of the shape.

+

The returned point is in local coordinates, that is, the shape's transforms (position, rotation, scale) are not taken into account. The result is undefined if index is out of the valid range.

+
Parameters
+ + +
indexIndex of the point to get, in range [0 .. getPointCount() - 1]
+
+
+
Returns
index-th point of the shape
+
See also
getPointCount
+ +

Implemented in sf::CircleShape, sf::ConvexShape, and sf::RectangleShape.

+ +
+
+ +

◆ getPointCount()

+ +
+
+ + + + + +
+ + + + + + + +
virtual std::size_t sf::Shape::getPointCount () const
+ 		+pure virtual
+
+ +

Get the total number of points of the shape.

+
Returns
Number of points of the shape
+
See also
getPoint
+ +

Implemented in sf::CircleShape, sf::ConvexShape, and sf::RectangleShape.

+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getPosition () const
+ 		+inherited
+
+ +

get the position of the object

+
Returns
Current position
+
See also
setPosition
+ +
+
+ +

◆ getRotation()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::Transformable::getRotation () const
+ 		+inherited
+
+ +

get the orientation of the object

+

The rotation is always in the range [0, 360].

+
Returns
Current rotation, in degrees
+
See also
setRotation
+ +
+
+ +

◆ getScale()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getScale () const
+ 		+inherited
+
+ +

get the current scale of the object

+
Returns
Current scale factors
+
See also
setScale
+ +
+
+ +

◆ getTexture()

+ +
+
+ + + + + + + +
const Texture * sf::Shape::getTexture () const
+
+ +

Get the source texture of the shape.

+

If the shape has no source texture, a NULL pointer is returned. The returned pointer is const, which means that you can't modify the texture when you retrieve it with this function.

+
Returns
Pointer to the shape's texture
+
See also
setTexture
+ +
+
+ +

◆ getTextureRect()

+ +
+
+ + + + + + + +
const IntRect & sf::Shape::getTextureRect () const
+
+ +

Get the sub-rectangle of the texture displayed by the shape.

+
Returns
Texture rectangle of the shape
+
See also
setTextureRect
+ +
+
+ +

◆ getTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getTransform () const
+ 		+inherited
+
+ +

get the combined transform of the object

+
Returns
Transform combining the position/rotation/scale/origin of the object
+
See also
getInverseTransform
+ +
+
+ +

◆ move() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::move (const Vector2f & offset)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

object.setPosition(object.getPosition() + offset);
+
sf::Transformable::getPosition
const Vector2f & getPosition() const
get the position of the object
+
Parameters
+ + +
offsetOffset
+
+
+
See also
setPosition
+ +
+
+ +

◆ move() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::move (float offsetX,
float offsetY 
)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f pos = object.getPosition();
+
object.setPosition(pos.x + offsetX, pos.y + offsetY);
+ +
sf::Vector2::x
T x
X coordinate of the vector.
Definition: Vector2.hpp:75
+
sf::Vector2::y
T y
Y coordinate of the vector.
Definition: Vector2.hpp:76
+
Parameters
+ + + +
offsetXX offset
offsetYY offset
+
+
+
See also
setPosition
+ +
+
+ +

◆ rotate()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::rotate (float angle)
+ 		+inherited
+
+ +

Rotate the object.

+

This function adds to the current rotation of the object, unlike setRotation which overwrites it. Thus, it is equivalent to the following code:

object.setRotation(object.getRotation() + angle);
+
sf::Transformable::getRotation
float getRotation() const
get the orientation of the object
+
Parameters
+ + +
angleAngle of rotation, in degrees
+
+
+ +
+
+ +

◆ scale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::scale (const Vector2f & factor)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factor.x, scale.y * factor.y);
+
sf::Transformable::scale
void scale(float factorX, float factorY)
Scale the object.
+
Parameters
+ + +
factorScale factors
+
+
+
See also
setScale
+ +
+
+ +

◆ scale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::scale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factorX, scale.y * factorY);
+
Parameters
+ + + +
factorXHorizontal scale factor
factorYVertical scale factor
+
+
+
See also
setScale
+ +
+
+ +

◆ setFillColor()

+ +
+
+ + + + + + + + +
void sf::Shape::setFillColor (const Color & color)
+
+ +

Set the fill color of the shape.

+

This color is modulated (multiplied) with the shape's texture if any. It can be used to colorize the shape, or change its global opacity. You can use sf::Color::Transparent to make the inside of the shape transparent, and have the outline alone. By default, the shape's fill color is opaque white.

+
Parameters
+ + +
colorNew color of the shape
+
+
+
See also
getFillColor, setOutlineColor
+ +
+
+ +

◆ setOrigin() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setOrigin (const Vector2f & origin)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + +
originNew origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOrigin() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setOrigin (float x,
float y 
)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new origin
yY coordinate of the new origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOutlineColor()

+ +
+
+ + + + + + + + +
void sf::Shape::setOutlineColor (const Color & color)
+
+ +

Set the outline color of the shape.

+

By default, the shape's outline color is opaque white.

+
Parameters
+ + +
colorNew outline color of the shape
+
+
+
See also
getOutlineColor, setFillColor
+ +
+
+ +

◆ setOutlineThickness()

+ +
+
+ + + + + + + + +
void sf::Shape::setOutlineThickness (float thickness)
+
+ +

Set the thickness of the shape's outline.

+

Note that negative values are allowed (so that the outline expands towards the center of the shape), and using zero disables the outline. By default, the outline thickness is 0.

+
Parameters
+ + +
thicknessNew outline thickness
+
+
+
See also
getOutlineThickness
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setPosition (const Vector2f & position)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + +
positionNew position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setPosition (float x,
float y 
)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new position
yY coordinate of the new position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setRotation()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setRotation (float angle)
+ 		+inherited
+
+ +

set the orientation of the object

+

This function completely overwrites the previous rotation. See the rotate function to add an angle based on the previous rotation instead. The default rotation of a transformable object is 0.

+
Parameters
+ + +
angleNew rotation, in degrees
+
+
+
See also
rotate, getRotation
+ +
+
+ +

◆ setScale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setScale (const Vector2f & factors)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + +
factorsNew scale factors
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setScale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setScale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + + +
factorXNew horizontal scale factor
factorYNew vertical scale factor
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setTexture()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Shape::setTexture (const Texture * texture,
bool resetRect = false 
)
+
+ +

Change the source texture of the shape.

+

The texture argument refers to a texture that must exist as long as the shape uses it. Indeed, the shape doesn't store its own copy of the texture, but rather keeps a pointer to the one that you passed to this function. If the source texture is destroyed and the shape tries to use it, the behavior is undefined. texture can be NULL to disable texturing. If resetRect is true, the TextureRect property of the shape is automatically adjusted to the size of the new texture. If it is false, the texture rect is left unchanged.

+
Parameters
+ + + +
textureNew texture
resetRectShould the texture rect be reset to the size of the new texture?
+
+
+
See also
getTexture, setTextureRect
+ +
+
+ +

◆ setTextureRect()

+ +
+
+ + + + + + + + +
void sf::Shape::setTextureRect (const IntRect & rect)
+
+ +

Set the sub-rectangle of the texture that the shape will display.

+

The texture rect is useful when you don't want to display the whole texture, but rather a part of it. By default, the texture rect covers the entire texture.

+
Parameters
+ + +
rectRectangle defining the region of the texture to display
+
+
+
See also
getTextureRect, setTexture
+ +
+
+ +

◆ update()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Shape::update ()
+ 		+protected
+
+ +

Recompute the internal geometry of the shape.

+

This function must be called by the derived class everytime the shape's points change (i.e. the result of either getPointCount or getPoint is different).

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Shape.png b/Space-Invaders/sfml/doc/html/classsf_1_1Shape.png new file mode 100644 index 000000000..bfc5722b0 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Shape.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Socket-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Socket-members.html new file mode 100644 index 000000000..7b5d300d1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Socket-members.html @@ -0,0 +1,127 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Socket Member List
+
+
+ +

This is the complete list of members for sf::Socket, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
AnyPort enum valuesf::Socket
close()sf::Socketprotected
create()sf::Socketprotected
create(SocketHandle handle)sf::Socketprotected
Disconnected enum valuesf::Socket
Done enum valuesf::Socket
Error enum valuesf::Socket
getHandle() constsf::Socketprotected
isBlocking() constsf::Socket
NotReady enum valuesf::Socket
Partial enum valuesf::Socket
setBlocking(bool blocking)sf::Socket
Socket(Type type)sf::Socketprotected
SocketSelector (defined in sf::Socket)sf::Socketfriend
Status enum namesf::Socket
Tcp enum valuesf::Socketprotected
Type enum namesf::Socketprotected
Udp enum valuesf::Socketprotected
~Socket()sf::Socketvirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Socket.html b/Space-Invaders/sfml/doc/html/classsf_1_1Socket.html new file mode 100644 index 000000000..2ec0bc169 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Socket.html @@ -0,0 +1,547 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Protected Types | +Protected Member Functions | +Friends | +List of all members
+
sf::Socket Class Reference
Network module
+
+
+ +

Base class for all the socket types. + More...

+ +

#include <SFML/Network/Socket.hpp>

+
+Inheritance diagram for sf::Socket:
+
+
+ + +sf::NonCopyable +sf::TcpListener +sf::TcpSocket +sf::UdpSocket + +
+ + + + + + + + +

+Public Types

enum  Status {
+  Done +, NotReady +, Partial +, Disconnected +,
+  Error +
+ }
 Status codes that may be returned by socket functions. More...
 
enum  { AnyPort = 0 + }
 Some special values used by sockets. More...
 
+ + + + + + + + + + +

+Public Member Functions

virtual ~Socket ()
 Destructor.
 
void setBlocking (bool blocking)
 Set the blocking state of the socket.
 
bool isBlocking () const
 Tell whether the socket is in blocking or non-blocking mode.
 
+ + + + +

+Protected Types

enum  Type { Tcp +, Udp + }
 Types of protocols that the socket can use. More...
 
+ + + + + + + + + + + + + + + + +

+Protected Member Functions

 Socket (Type type)
 Default constructor.
 
SocketHandle getHandle () const
 Return the internal handle of the socket.
 
void create ()
 Create the internal representation of the socket.
 
void create (SocketHandle handle)
 Create the internal representation of the socket from a socket handle.
 
void close ()
 Close the socket gracefully.
 
+ + + +

+Friends

class SocketSelector
 
+

Detailed Description

+

Base class for all the socket types.

+

This class mainly defines internal stuff to be used by derived classes.

+

The only public features that it defines, and which is therefore common to all the socket classes, is the blocking state. All sockets can be set as blocking or non-blocking.

+

In blocking mode, socket functions will hang until the operation completes, which means that the entire program (well, in fact the current thread if you use multiple ones) will be stuck waiting for your socket operation to complete.

+

In non-blocking mode, all the socket functions will return immediately. If the socket is not ready to complete the requested operation, the function simply returns the proper status code (Socket::NotReady).

+

The default mode, which is blocking, is the one that is generally used, in combination with threads or selectors. The non-blocking mode is rather used in real-time applications that run an endless loop that can poll the socket often enough, and cannot afford blocking this loop.

+
See also
sf::TcpListener, sf::TcpSocket, sf::UdpSocket
+ +

Definition at line 45 of file Socket.hpp.

+

Member Enumeration Documentation

+ +

◆ anonymous enum

+ +
+
+ + + + +
anonymous enum
+
+ +

Some special values used by sockets.

+ + +
Enumerator
AnyPort 

Special value that tells the system to pick any available port.

+
+ +

Definition at line 66 of file Socket.hpp.

+ +
+
+ +

◆ Status

+ +
+
+ + + + +
enum sf::Socket::Status
+
+ +

Status codes that may be returned by socket functions.

+ + + + + + +
Enumerator
Done 

The socket has sent / received the data.

+
NotReady 

The socket is not ready to send / receive data yet.

+
Partial 

The socket sent a part of the data.

+
Disconnected 

The TCP socket has been disconnected.

+
Error 

An unexpected error happened.

+
+ +

Definition at line 53 of file Socket.hpp.

+ +
+
+ +

◆ Type

+ +
+
+ + + + + +
+ + + + +
enum sf::Socket::Type
+ 		+protected
+
+ +

Types of protocols that the socket can use.

+ + + +
Enumerator
Tcp 

TCP protocol.

+
Udp 

UDP protocol.

+
+ +

Definition at line 114 of file Socket.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ ~Socket()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::Socket::~Socket ()
+ 		+virtual
+
+ +

Destructor.

+ +
+
+ +

◆ Socket()

+ +
+
+ + + + + +
+ + + + + + + + +
sf::Socket::Socket (Type type)
+ 		+protected
+
+ +

Default constructor.

+

This constructor can only be accessed by derived classes.

+
Parameters
+ + +
typeType of the socket (TCP or UDP)
+
+
+ +
+
+

Member Function Documentation

+ +

◆ close()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Socket::close ()
+ 		+protected
+
+ +

Close the socket gracefully.

+

This function can only be accessed by derived classes.

+ +
+
+ +

◆ create() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Socket::create ()
+ 		+protected
+
+ +

Create the internal representation of the socket.

+

This function can only be accessed by derived classes.

+ +
+
+ +

◆ create() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Socket::create (SocketHandle handle)
+ 		+protected
+
+ +

Create the internal representation of the socket from a socket handle.

+

This function can only be accessed by derived classes.

+
Parameters
+ + +
handleOS-specific handle of the socket to wrap
+
+
+ +
+
+ +

◆ getHandle()

+ +
+
+ + + + + +
+ + + + + + + +
SocketHandle sf::Socket::getHandle () const
+ 		+protected
+
+ +

Return the internal handle of the socket.

+

The returned handle may be invalid if the socket was not created yet (or already destroyed). This function can only be accessed by derived classes.

+
Returns
The internal (OS-specific) handle of the socket
+ +
+
+ +

◆ isBlocking()

+ +
+
+ + + + + + + +
bool sf::Socket::isBlocking () const
+
+ +

Tell whether the socket is in blocking or non-blocking mode.

+
Returns
True if the socket is blocking, false otherwise
+
See also
setBlocking
+ +
+
+ +

◆ setBlocking()

+ +
+
+ + + + + + + + +
void sf::Socket::setBlocking (bool blocking)
+
+ +

Set the blocking state of the socket.

+

In blocking mode, calls will not return until they have completed their task. For example, a call to Receive in blocking mode won't return until some data was actually received. In non-blocking mode, calls will always return immediately, using the return code to signal whether there was data available or not. By default, all sockets are blocking.

+
Parameters
+ + +
blockingTrue to set the socket as blocking, false for non-blocking
+
+
+
See also
isBlocking
+ +
+
+

Friends And Related Function Documentation

+ +

◆ SocketSelector

+ +
+
+ + + + + +
+ + + + +
friend class SocketSelector
+ 		+friend
+
+ +

Definition at line 171 of file Socket.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Socket.png b/Space-Invaders/sfml/doc/html/classsf_1_1Socket.png new file mode 100644 index 000000000..ebae12664 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Socket.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SocketSelector-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1SocketSelector-members.html new file mode 100644 index 000000000..6a5ef25ee --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SocketSelector-members.html @@ -0,0 +1,117 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::SocketSelector Member List
+
+
+ +

This is the complete list of members for sf::SocketSelector, including all inherited members.

+ + + + + + + + + + +
add(Socket &socket)sf::SocketSelector
clear()sf::SocketSelector
isReady(Socket &socket) constsf::SocketSelector
operator=(const SocketSelector &right)sf::SocketSelector
remove(Socket &socket)sf::SocketSelector
SocketSelector()sf::SocketSelector
SocketSelector(const SocketSelector &copy)sf::SocketSelector
wait(Time timeout=Time::Zero)sf::SocketSelector
~SocketSelector()sf::SocketSelector
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SocketSelector.html b/Space-Invaders/sfml/doc/html/classsf_1_1SocketSelector.html new file mode 100644 index 000000000..ad80762c3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SocketSelector.html @@ -0,0 +1,462 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::SocketSelector Class Reference
Network module
+
+
+ +

Multiplexer that allows to read from multiple sockets. + More...

+ +

#include <SFML/Network/SocketSelector.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 SocketSelector ()
 Default constructor.
 
 SocketSelector (const SocketSelector &copy)
 Copy constructor.
 
 ~SocketSelector ()
 Destructor.
 
void add (Socket &socket)
 Add a new socket to the selector.
 
void remove (Socket &socket)
 Remove a socket from the selector.
 
void clear ()
 Remove all the sockets stored in the selector.
 
bool wait (Time timeout=Time::Zero)
 Wait until one or more sockets are ready to receive.
 
bool isReady (Socket &socket) const
 Test a socket to know if it is ready to receive data.
 
SocketSelector & operator= (const SocketSelector &right)
 Overload of assignment operator.
 
+

Detailed Description

+

Multiplexer that allows to read from multiple sockets.

+

Socket selectors provide a way to wait until some data is available on a set of sockets, instead of just one.

+

This is convenient when you have multiple sockets that may possibly receive data, but you don't know which one will be ready first. In particular, it avoids to use a thread for each socket; with selectors, a single thread can handle all the sockets.

+

All types of sockets can be used in a selector:

+

A selector doesn't store its own copies of the sockets (socket classes are not copyable anyway), it simply keeps a reference to the original sockets that you pass to the "add" function. Therefore, you can't use the selector as a socket container, you must store them outside and make sure that they are alive as long as they are used in the selector.

+

Using a selector is simple:

    +
  • populate the selector with all the sockets that you want to observe
    • +
  • make it wait until there is data available on any of the sockets
    • +
  • test each socket to find out which ones are ready
    • +
+

Usage example:

// Create a socket to listen to new connections
+
sf::TcpListener listener;
+
listener.listen(55001);
+
+
// Create a list to store the future clients
+
std::list<sf::TcpSocket*> clients;
+
+
// Create a selector
+
sf::SocketSelector selector;
+
+
// Add the listener to the selector
+
selector.add(listener);
+
+
// Endless loop that waits for new connections
+
while (running)
+
{
+
// Make the selector wait for data on any socket
+
if (selector.wait())
+
{
+
// Test the listener
+
if (selector.isReady(listener))
+
{
+
// The listener is ready: there is a pending connection
+
sf::TcpSocket* client = new sf::TcpSocket;
+
if (listener.accept(*client) == sf::Socket::Done)
+
{
+
// Add the new client to the clients list
+
clients.push_back(client);
+
+
// Add the new client to the selector so that we will
+
// be notified when he sends something
+
selector.add(*client);
+
}
+
else
+
{
+
// Error, we won't get a new connection, delete the socket
+
delete client;
+
}
+
}
+
else
+
{
+
// The listener socket is not ready, test all other sockets (the clients)
+
for (std::list<sf::TcpSocket*>::iterator it = clients.begin(); it != clients.end(); ++it)
+
{
+
sf::TcpSocket& client = **it;
+
if (selector.isReady(client))
+
{
+
// The client has sent some data, we can receive it
+
sf::Packet packet;
+
if (client.receive(packet) == sf::Socket::Done)
+
{
+
...
+
}
+
}
+
}
+
}
+
}
+
}
+
sf::Packet
Utility class to build blocks of data to transfer over the network.
Definition: Packet.hpp:48
+
sf::SocketSelector
Multiplexer that allows to read from multiple sockets.
Definition: SocketSelector.hpp:44
+
sf::SocketSelector::isReady
bool isReady(Socket &socket) const
Test a socket to know if it is ready to receive data.
+
sf::SocketSelector::wait
bool wait(Time timeout=Time::Zero)
Wait until one or more sockets are ready to receive.
+
sf::SocketSelector::add
void add(Socket &socket)
Add a new socket to the selector.
+
sf::Socket::Done
@ Done
The socket has sent / received the data.
Definition: Socket.hpp:55
+
sf::TcpListener
Socket that listens to new TCP connections.
Definition: TcpListener.hpp:45
+
sf::TcpListener::listen
Status listen(unsigned short port, const IpAddress &address=IpAddress::Any)
Start listening for incoming connection attempts.
+
sf::TcpListener::accept
Status accept(TcpSocket &socket)
Accept a new connection.
+
sf::TcpSocket
Specialized socket using the TCP protocol.
Definition: TcpSocket.hpp:47
+
sf::TcpSocket::receive
Status receive(void *data, std::size_t size, std::size_t &received)
Receive raw data from the remote peer.
+
See also
sf::Socket
+ +

Definition at line 43 of file SocketSelector.hpp.

+

Constructor & Destructor Documentation

+ +

◆ SocketSelector() [1/2]

+ +
+
+ + + + + + + +
sf::SocketSelector::SocketSelector ()
+
+ +

Default constructor.

+ +
+
+ +

◆ SocketSelector() [2/2]

+ +
+
+ + + + + + + + +
sf::SocketSelector::SocketSelector (const SocketSelector & copy)
+
+ +

Copy constructor.

+
Parameters
+ + +
copyInstance to copy
+
+
+ +
+
+ +

◆ ~SocketSelector()

+ +
+
+ + + + + + + +
sf::SocketSelector::~SocketSelector ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ add()

+ +
+
+ + + + + + + + +
void sf::SocketSelector::add (Socket & socket)
+
+ +

Add a new socket to the selector.

+

This function keeps a weak reference to the socket, so you have to make sure that the socket is not destroyed while it is stored in the selector. This function does nothing if the socket is not valid.

+
Parameters
+ + +
socketReference to the socket to add
+
+
+
See also
remove, clear
+ +
+
+ +

◆ clear()

+ +
+
+ + + + + + + +
void sf::SocketSelector::clear ()
+
+ +

Remove all the sockets stored in the selector.

+

This function doesn't destroy any instance, it simply removes all the references that the selector has to external sockets.

+
See also
add, remove
+ +
+
+ +

◆ isReady()

+ +
+
+ + + + + + + + +
bool sf::SocketSelector::isReady (Socket & socket) const
+
+ +

Test a socket to know if it is ready to receive data.

+

This function must be used after a call to Wait, to know which sockets are ready to receive data. If a socket is ready, a call to receive will never block because we know that there is data available to read. Note that if this function returns true for a TcpListener, this means that it is ready to accept a new connection.

+
Parameters
+ + +
socketSocket to test
+
+
+
Returns
True if the socket is ready to read, false otherwise
+
See also
isReady
+ +
+
+ +

◆ operator=()

+ +
+
+ + + + + + + + +
SocketSelector & sf::SocketSelector::operator= (const SocketSelector & right)
+
+ +

Overload of assignment operator.

+
Parameters
+ + +
rightInstance to assign
+
+
+
Returns
Reference to self
+ +
+
+ +

◆ remove()

+ +
+
+ + + + + + + + +
void sf::SocketSelector::remove (Socket & socket)
+
+ +

Remove a socket from the selector.

+

This function doesn't destroy the socket, it simply removes the reference that the selector has to it.

+
Parameters
+ + +
socketReference to the socket to remove
+
+
+
See also
add, clear
+ +
+
+ +

◆ wait()

+ +
+
+ + + + + + + + +
bool sf::SocketSelector::wait (Time timeout = Time::Zero)
+
+ +

Wait until one or more sockets are ready to receive.

+

This function returns as soon as at least one socket has some data available to be received. To know which sockets are ready, use the isReady function. If you use a timeout and no socket is ready before the timeout is over, the function returns false.

+
Parameters
+ + +
timeoutMaximum time to wait, (use Time::Zero for infinity)
+
+
+
Returns
True if there are sockets ready, false otherwise
+
See also
isReady
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Sound-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Sound-members.html new file mode 100644 index 000000000..5dc8e807b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Sound-members.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Sound Member List
+
+
+ +

This is the complete list of members for sf::Sound, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
getAttenuation() constsf::SoundSource
getBuffer() constsf::Sound
getLoop() constsf::Sound
getMinDistance() constsf::SoundSource
getPitch() constsf::SoundSource
getPlayingOffset() constsf::Sound
getPosition() constsf::SoundSource
getStatus() constsf::Soundvirtual
getVolume() constsf::SoundSource
isRelativeToListener() constsf::SoundSource
m_sourcesf::SoundSourceprotected
operator=(const Sound &right)sf::Sound
sf::SoundSource::operator=(const SoundSource &right)sf::SoundSource
pause()sf::Soundvirtual
Paused enum valuesf::SoundSource
play()sf::Soundvirtual
Playing enum valuesf::SoundSource
resetBuffer()sf::Sound
setAttenuation(float attenuation)sf::SoundSource
setBuffer(const SoundBuffer &buffer)sf::Sound
setLoop(bool loop)sf::Sound
setMinDistance(float distance)sf::SoundSource
setPitch(float pitch)sf::SoundSource
setPlayingOffset(Time timeOffset)sf::Sound
setPosition(float x, float y, float z)sf::SoundSource
setPosition(const Vector3f &position)sf::SoundSource
setRelativeToListener(bool relative)sf::SoundSource
setVolume(float volume)sf::SoundSource
Sound()sf::Sound
Sound(const SoundBuffer &buffer)sf::Soundexplicit
Sound(const Sound &copy)sf::Sound
SoundSource(const SoundSource &copy)sf::SoundSource
SoundSource()sf::SoundSourceprotected
Status enum namesf::SoundSource
stop()sf::Soundvirtual
Stopped enum valuesf::SoundSource
~Sound()sf::Sound
~SoundSource()sf::SoundSourcevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Sound.html b/Space-Invaders/sfml/doc/html/classsf_1_1Sound.html new file mode 100644 index 000000000..64a97739c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Sound.html @@ -0,0 +1,1181 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Protected Attributes | +List of all members
+
sf::Sound Class Reference
Audio module
+
+
+ +

Regular sound that can be played in the audio environment. + More...

+ +

#include <SFML/Audio/Sound.hpp>

+
+Inheritance diagram for sf::Sound:
+
+
+ + +sf::SoundSource +sf::AlResource + +
+ + + + + +

+Public Types

enum  Status { Stopped +, Paused +, Playing + }
 Enumeration of the sound source states. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Sound ()
 Default constructor.
 
 Sound (const SoundBuffer &buffer)
 Construct the sound with a buffer.
 
 Sound (const Sound &copy)
 Copy constructor.
 
 ~Sound ()
 Destructor.
 
void play ()
 Start or resume playing the sound.
 
void pause ()
 Pause the sound.
 
void stop ()
 stop playing the sound
 
void setBuffer (const SoundBuffer &buffer)
 Set the source buffer containing the audio data to play.
 
void setLoop (bool loop)
 Set whether or not the sound should loop after reaching the end.
 
void setPlayingOffset (Time timeOffset)
 Change the current playing position of the sound.
 
const SoundBuffer * getBuffer () const
 Get the audio buffer attached to the sound.
 
bool getLoop () const
 Tell whether or not the sound is in loop mode.
 
Time getPlayingOffset () const
 Get the current playing position of the sound.
 
Status getStatus () const
 Get the current status of the sound (stopped, paused, playing)
 
Sound & operator= (const Sound &right)
 Overload of assignment operator.
 
void resetBuffer ()
 Reset the internal buffer of the sound.
 
void setPitch (float pitch)
 Set the pitch of the sound.
 
void setVolume (float volume)
 Set the volume of the sound.
 
void setPosition (float x, float y, float z)
 Set the 3D position of the sound in the audio scene.
 
void setPosition (const Vector3f &position)
 Set the 3D position of the sound in the audio scene.
 
void setRelativeToListener (bool relative)
 Make the sound's position relative to the listener or absolute.
 
void setMinDistance (float distance)
 Set the minimum distance of the sound.
 
void setAttenuation (float attenuation)
 Set the attenuation factor of the sound.
 
float getPitch () const
 Get the pitch of the sound.
 
float getVolume () const
 Get the volume of the sound.
 
Vector3f getPosition () const
 Get the 3D position of the sound in the audio scene.
 
bool isRelativeToListener () const
 Tell whether the sound's position is relative to the listener or is absolute.
 
float getMinDistance () const
 Get the minimum distance of the sound.
 
float getAttenuation () const
 Get the attenuation factor of the sound.
 
+ + + + +

+Protected Attributes

unsigned int m_source
 OpenAL source identifier.
 
+

Detailed Description

+

Regular sound that can be played in the audio environment.

+

sf::Sound is the class to use to play sounds.

+

It provides:

    +
  • Control (play, pause, stop)
    • +
  • Ability to modify output parameters in real-time (pitch, volume, ...)
    • +
  • 3D spatial features (position, attenuation, ...).
    • +
+

sf::Sound is perfect for playing short sounds that can fit in memory and require no latency, like foot steps or gun shots. For longer sounds, like background musics or long speeches, rather see sf::Music (which is based on streaming).

+

In order to work, a sound must be given a buffer of audio data to play. Audio data (samples) is stored in sf::SoundBuffer, and attached to a sound with the setBuffer() function. The buffer object attached to a sound must remain alive as long as the sound uses it. Note that multiple sounds can use the same sound buffer at the same time.

+

Usage example:

sf::SoundBuffer buffer;
+
buffer.loadFromFile("sound.wav");
+
+
sf::Sound sound;
+
sound.setBuffer(buffer);
+
sound.play();
+
sf::SoundBuffer
Storage for audio samples defining a sound.
Definition: SoundBuffer.hpp:50
+
sf::SoundBuffer::loadFromFile
bool loadFromFile(const std::string &filename)
Load the sound buffer from a file.
+
sf::Sound
Regular sound that can be played in the audio environment.
Definition: Sound.hpp:46
+
sf::Sound::play
void play()
Start or resume playing the sound.
+
sf::Sound::setBuffer
void setBuffer(const SoundBuffer &buffer)
Set the source buffer containing the audio data to play.
+
See also
sf::SoundBuffer, sf::Music
+ +

Definition at line 45 of file Sound.hpp.

+

Member Enumeration Documentation

+ +

◆ Status

+ +
+
+ + + + + +
+ + + + +
enum sf::SoundSource::Status
+ 		+inherited
+
+ +

Enumeration of the sound source states.

+ + + + +
Enumerator
Stopped 

Sound is not playing.

+
Paused 

Sound is paused.

+
Playing 

Sound is playing.

+
+ +

Definition at line 50 of file SoundSource.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Sound() [1/3]

+ +
+
+ + + + + + + +
sf::Sound::Sound ()
+
+ +

Default constructor.

+ +
+
+ +

◆ Sound() [2/3]

+ +
+
+ + + + + +
+ + + + + + + + +
sf::Sound::Sound (const SoundBuffer & buffer)
+ 		+explicit
+
+ +

Construct the sound with a buffer.

+
Parameters
+ + +
bufferSound buffer containing the audio data to play with the sound
+
+
+ +
+
+ +

◆ Sound() [3/3]

+ +
+
+ + + + + + + + +
sf::Sound::Sound (const Sound & copy)
+
+ +

Copy constructor.

+
Parameters
+ + +
copyInstance to copy
+
+
+ +
+
+ +

◆ ~Sound()

+ +
+
+ + + + + + + +
sf::Sound::~Sound ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ getAttenuation()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getAttenuation () const
+ 		+inherited
+
+ +

Get the attenuation factor of the sound.

+
Returns
Attenuation factor of the sound
+
See also
setAttenuation, getMinDistance
+ +
+
+ +

◆ getBuffer()

+ +
+
+ + + + + + + +
const SoundBuffer * sf::Sound::getBuffer () const
+
+ +

Get the audio buffer attached to the sound.

+
Returns
Sound buffer attached to the sound (can be NULL)
+ +
+
+ +

◆ getLoop()

+ +
+
+ + + + + + + +
bool sf::Sound::getLoop () const
+
+ +

Tell whether or not the sound is in loop mode.

+
Returns
True if the sound is looping, false otherwise
+
See also
setLoop
+ +
+
+ +

◆ getMinDistance()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getMinDistance () const
+ 		+inherited
+
+ +

Get the minimum distance of the sound.

+
Returns
Minimum distance of the sound
+
See also
setMinDistance, getAttenuation
+ +
+
+ +

◆ getPitch()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getPitch () const
+ 		+inherited
+
+ +

Get the pitch of the sound.

+
Returns
Pitch of the sound
+
See also
setPitch
+ +
+
+ +

◆ getPlayingOffset()

+ +
+
+ + + + + + + +
Time sf::Sound::getPlayingOffset () const
+
+ +

Get the current playing position of the sound.

+
Returns
Current playing position, from the beginning of the sound
+
See also
setPlayingOffset
+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
Vector3f sf::SoundSource::getPosition () const
+ 		+inherited
+
+ +

Get the 3D position of the sound in the audio scene.

+
Returns
Position of the sound
+
See also
setPosition
+ +
+
+ +

◆ getStatus()

+ +
+
+ + + + + +
+ + + + + + + +
Status sf::Sound::getStatus () const
+ 		+virtual
+
+ +

Get the current status of the sound (stopped, paused, playing)

+
Returns
Current status of the sound
+ +

Reimplemented from sf::SoundSource.

+ +
+
+ +

◆ getVolume()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getVolume () const
+ 		+inherited
+
+ +

Get the volume of the sound.

+
Returns
Volume of the sound, in the range [0, 100]
+
See also
setVolume
+ +
+
+ +

◆ isRelativeToListener()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::SoundSource::isRelativeToListener () const
+ 		+inherited
+
+ +

Tell whether the sound's position is relative to the listener or is absolute.

+
Returns
True if the position is relative, false if it's absolute
+
See also
setRelativeToListener
+ +
+
+ +

◆ operator=()

+ +
+
+ + + + + + + + +
Sound & sf::Sound::operator= (const Sound & right)
+
+ +

Overload of assignment operator.

+
Parameters
+ + +
rightInstance to assign
+
+
+
Returns
Reference to self
+ +
+
+ +

◆ pause()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Sound::pause ()
+ 		+virtual
+
+ +

Pause the sound.

+

This function pauses the sound if it was playing, otherwise (sound already paused or stopped) it has no effect.

+
See also
play, stop
+ +

Implements sf::SoundSource.

+ +
+
+ +

◆ play()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Sound::play ()
+ 		+virtual
+
+ +

Start or resume playing the sound.

+

This function starts the stream if it was stopped, resumes it if it was paused, and restarts it from beginning if it was it already playing. This function uses its own thread so that it doesn't block the rest of the program while the sound is played.

+
See also
pause, stop
+ +

Implements sf::SoundSource.

+ +
+
+ +

◆ resetBuffer()

+ +
+
+ + + + + + + +
void sf::Sound::resetBuffer ()
+
+ +

Reset the internal buffer of the sound.

+

This function is for internal use only, you don't have to use it. It is called by the sf::SoundBuffer that this sound uses, when it is destroyed in order to prevent the sound from using a dead buffer.

+ +
+
+ +

◆ setAttenuation()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setAttenuation (float attenuation)
+ 		+inherited
+
+ +

Set the attenuation factor of the sound.

+

The attenuation is a multiplicative factor which makes the sound more or less loud according to its distance from the listener. An attenuation of 0 will produce a non-attenuated sound, i.e. its volume will always be the same whether it is heard from near or from far. On the other hand, an attenuation value such as 100 will make the sound fade out very quickly as it gets further from the listener. The default value of the attenuation is 1.

+
Parameters
+ + +
attenuationNew attenuation factor of the sound
+
+
+
See also
getAttenuation, setMinDistance
+ +
+
+ +

◆ setBuffer()

+ +
+
+ + + + + + + + +
void sf::Sound::setBuffer (const SoundBuffer & buffer)
+
+ +

Set the source buffer containing the audio data to play.

+

It is important to note that the sound buffer is not copied, thus the sf::SoundBuffer instance must remain alive as long as it is attached to the sound.

+
Parameters
+ + +
bufferSound buffer to attach to the sound
+
+
+
See also
getBuffer
+ +
+
+ +

◆ setLoop()

+ +
+
+ + + + + + + + +
void sf::Sound::setLoop (bool loop)
+
+ +

Set whether or not the sound should loop after reaching the end.

+

If set, the sound will restart from beginning after reaching the end and so on, until it is stopped or setLoop(false) is called. The default looping state for sound is false.

+
Parameters
+ + +
loopTrue to play in loop, false to play once
+
+
+
See also
getLoop
+ +
+
+ +

◆ setMinDistance()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setMinDistance (float distance)
+ 		+inherited
+
+ +

Set the minimum distance of the sound.

+

The "minimum distance" of a sound is the maximum distance at which it is heard at its maximum volume. Further than the minimum distance, it will start to fade out according to its attenuation factor. A value of 0 ("inside the head +of the listener") is an invalid value and is forbidden. The default value of the minimum distance is 1.

+
Parameters
+ + +
distanceNew minimum distance of the sound
+
+
+
See also
getMinDistance, setAttenuation
+ +
+
+ +

◆ setPitch()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setPitch (float pitch)
+ 		+inherited
+
+ +

Set the pitch of the sound.

+

The pitch represents the perceived fundamental frequency of a sound; thus you can make a sound more acute or grave by changing its pitch. A side effect of changing the pitch is to modify the playing speed of the sound as well. The default value for the pitch is 1.

+
Parameters
+ + +
pitchNew pitch to apply to the sound
+
+
+
See also
getPitch
+ +
+
+ +

◆ setPlayingOffset()

+ +
+
+ + + + + + + + +
void sf::Sound::setPlayingOffset (Time timeOffset)
+
+ +

Change the current playing position of the sound.

+

The playing position can be changed when the sound is either paused or playing. Changing the playing position when the sound is stopped has no effect, since playing the sound will reset its position.

+
Parameters
+ + +
timeOffsetNew playing position, from the beginning of the sound
+
+
+
See also
getPlayingOffset
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setPosition (const Vector3f & position)
+ 		+inherited
+
+ +

Set the 3D position of the sound in the audio scene.

+

Only sounds with one channel (mono sounds) can be spatialized. The default position of a sound is (0, 0, 0).

+
Parameters
+ + +
positionPosition of the sound in the scene
+
+
+
See also
getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::SoundSource::setPosition (float x,
float y,
float z 
)
+ 		+inherited
+
+ +

Set the 3D position of the sound in the audio scene.

+

Only sounds with one channel (mono sounds) can be spatialized. The default position of a sound is (0, 0, 0).

+
Parameters
+ + + + +
xX coordinate of the position of the sound in the scene
yY coordinate of the position of the sound in the scene
zZ coordinate of the position of the sound in the scene
+
+
+
See also
getPosition
+ +
+
+ +

◆ setRelativeToListener()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setRelativeToListener (bool relative)
+ 		+inherited
+
+ +

Make the sound's position relative to the listener or absolute.

+

Making a sound relative to the listener will ensure that it will always be played the same way regardless of the position of the listener. This can be useful for non-spatialized sounds, sounds that are produced by the listener, or sounds attached to it. The default value is false (position is absolute).

+
Parameters
+ + +
relativeTrue to set the position relative, false to set it absolute
+
+
+
See also
isRelativeToListener
+ +
+
+ +

◆ setVolume()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setVolume (float volume)
+ 		+inherited
+
+ +

Set the volume of the sound.

+

The volume is a value between 0 (mute) and 100 (full volume). The default value for the volume is 100.

+
Parameters
+ + +
volumeVolume of the sound
+
+
+
See also
getVolume
+ +
+
+ +

◆ stop()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Sound::stop ()
+ 		+virtual
+
+ +

stop playing the sound

+

This function stops the sound if it was playing or paused, and does nothing if it was already stopped. It also resets the playing position (unlike pause()).

+
See also
play, pause
+ +

Implements sf::SoundSource.

+ +
+
+

Member Data Documentation

+ +

◆ m_source

+ +
+
+ + + + + +
+ + + + +
unsigned int sf::SoundSource::m_source
+ 		+protectedinherited
+
+ +

OpenAL source identifier.

+ +

Definition at line 309 of file SoundSource.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Sound.png b/Space-Invaders/sfml/doc/html/classsf_1_1Sound.png new file mode 100644 index 000000000..85834398e Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Sound.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundBuffer-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBuffer-members.html new file mode 100644 index 000000000..ec4f3b6f6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBuffer-members.html @@ -0,0 +1,123 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::SoundBuffer Member List
+
+
+ +

This is the complete list of members for sf::SoundBuffer, including all inherited members.

+ + + + + + + + + + + + + + + + +
getChannelCount() constsf::SoundBuffer
getDuration() constsf::SoundBuffer
getSampleCount() constsf::SoundBuffer
getSampleRate() constsf::SoundBuffer
getSamples() constsf::SoundBuffer
loadFromFile(const std::string &filename)sf::SoundBuffer
loadFromMemory(const void *data, std::size_t sizeInBytes)sf::SoundBuffer
loadFromSamples(const Int16 *samples, Uint64 sampleCount, unsigned int channelCount, unsigned int sampleRate)sf::SoundBuffer
loadFromStream(InputStream &stream)sf::SoundBuffer
operator=(const SoundBuffer &right)sf::SoundBuffer
saveToFile(const std::string &filename) constsf::SoundBuffer
Sound (defined in sf::SoundBuffer)sf::SoundBufferfriend
SoundBuffer()sf::SoundBuffer
SoundBuffer(const SoundBuffer &copy)sf::SoundBuffer
~SoundBuffer()sf::SoundBuffer
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundBuffer.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBuffer.html new file mode 100644 index 000000000..6d00afed3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBuffer.html @@ -0,0 +1,624 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Friends | +List of all members
+
sf::SoundBuffer Class Reference
Audio module
+
+
+ +

Storage for audio samples defining a sound. + More...

+ +

#include <SFML/Audio/SoundBuffer.hpp>

+
+Inheritance diagram for sf::SoundBuffer:
+
+
+ + +sf::AlResource + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 SoundBuffer ()
 Default constructor.
 
 SoundBuffer (const SoundBuffer &copy)
 Copy constructor.
 
 ~SoundBuffer ()
 Destructor.
 
bool loadFromFile (const std::string &filename)
 Load the sound buffer from a file.
 
bool loadFromMemory (const void *data, std::size_t sizeInBytes)
 Load the sound buffer from a file in memory.
 
bool loadFromStream (InputStream &stream)
 Load the sound buffer from a custom stream.
 
bool loadFromSamples (const Int16 *samples, Uint64 sampleCount, unsigned int channelCount, unsigned int sampleRate)
 Load the sound buffer from an array of audio samples.
 
bool saveToFile (const std::string &filename) const
 Save the sound buffer to an audio file.
 
const Int16 * getSamples () const
 Get the array of audio samples stored in the buffer.
 
Uint64 getSampleCount () const
 Get the number of samples stored in the buffer.
 
unsigned int getSampleRate () const
 Get the sample rate of the sound.
 
unsigned int getChannelCount () const
 Get the number of channels used by the sound.
 
Time getDuration () const
 Get the total duration of the sound.
 
SoundBuffer & operator= (const SoundBuffer &right)
 Overload of assignment operator.
 
+ + + +

+Friends

class Sound
 
+

Detailed Description

+

Storage for audio samples defining a sound.

+

A sound buffer holds the data of a sound, which is an array of audio samples.

+

A sample is a 16 bits signed integer that defines the amplitude of the sound at a given time. The sound is then reconstituted by playing these samples at a high rate (for example, 44100 samples per second is the standard rate used for playing CDs). In short, audio samples are like texture pixels, and a sf::SoundBuffer is similar to a sf::Texture.

+

A sound buffer can be loaded from a file (see loadFromFile() for the complete list of supported formats), from memory, from a custom stream (see sf::InputStream) or directly from an array of samples. It can also be saved back to a file.

+

Sound buffers alone are not very useful: they hold the audio data but cannot be played. To do so, you need to use the sf::Sound class, which provides functions to play/pause/stop the sound as well as changing the way it is outputted (volume, pitch, 3D position, ...). This separation allows more flexibility and better performances: indeed a sf::SoundBuffer is a heavy resource, and any operation on it is slow (often too slow for real-time applications). On the other side, a sf::Sound is a lightweight object, which can use the audio data of a sound buffer and change the way it is played without actually modifying that data. Note that it is also possible to bind several sf::Sound instances to the same sf::SoundBuffer.

+

It is important to note that the sf::Sound instance doesn't copy the buffer that it uses, it only keeps a reference to it. Thus, a sf::SoundBuffer must not be destructed while it is used by a sf::Sound (i.e. never write a function that uses a local sf::SoundBuffer instance for loading a sound).

+

Usage example:

// Declare a new sound buffer
+
sf::SoundBuffer buffer;
+
+
// Load it from a file
+
if (!buffer.loadFromFile("sound.wav"))
+
{
+
// error...
+
}
+
+
// Create a sound source and bind it to the buffer
+
sf::Sound sound1;
+
sound1.setBuffer(buffer);
+
+
// Play the sound
+
sound1.play();
+
+
// Create another sound source bound to the same buffer
+
sf::Sound sound2;
+
sound2.setBuffer(buffer);
+
+
// Play it with a higher pitch -- the first sound remains unchanged
+
sound2.setPitch(2);
+
sound2.play();
+
sf::SoundBuffer
Storage for audio samples defining a sound.
Definition: SoundBuffer.hpp:50
+
sf::SoundBuffer::loadFromFile
bool loadFromFile(const std::string &filename)
Load the sound buffer from a file.
+
sf::SoundSource::setPitch
void setPitch(float pitch)
Set the pitch of the sound.
+
sf::Sound
Regular sound that can be played in the audio environment.
Definition: Sound.hpp:46
+
sf::Sound::play
void play()
Start or resume playing the sound.
+
sf::Sound::setBuffer
void setBuffer(const SoundBuffer &buffer)
Set the source buffer containing the audio data to play.
+
See also
sf::Sound, sf::SoundBufferRecorder
+ +

Definition at line 49 of file SoundBuffer.hpp.

+

Constructor & Destructor Documentation

+ +

◆ SoundBuffer() [1/2]

+ +
+
+ + + + + + + +
sf::SoundBuffer::SoundBuffer ()
+
+ +

Default constructor.

+ +
+
+ +

◆ SoundBuffer() [2/2]

+ +
+
+ + + + + + + + +
sf::SoundBuffer::SoundBuffer (const SoundBuffer & copy)
+
+ +

Copy constructor.

+
Parameters
+ + +
copyInstance to copy
+
+
+ +
+
+ +

◆ ~SoundBuffer()

+ +
+
+ + + + + + + +
sf::SoundBuffer::~SoundBuffer ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ getChannelCount()

+ +
+
+ + + + + + + +
unsigned int sf::SoundBuffer::getChannelCount () const
+
+ +

Get the number of channels used by the sound.

+

If the sound is mono then the number of channels will be 1, 2 for stereo, etc.

+
Returns
Number of channels
+
See also
getSampleRate, getDuration
+ +
+
+ +

◆ getDuration()

+ +
+
+ + + + + + + +
Time sf::SoundBuffer::getDuration () const
+
+ +

Get the total duration of the sound.

+
Returns
Sound duration
+
See also
getSampleRate, getChannelCount
+ +
+
+ +

◆ getSampleCount()

+ +
+
+ + + + + + + +
Uint64 sf::SoundBuffer::getSampleCount () const
+
+ +

Get the number of samples stored in the buffer.

+

The array of samples can be accessed with the getSamples() function.

+
Returns
Number of samples
+
See also
getSamples
+ +
+
+ +

◆ getSampleRate()

+ +
+
+ + + + + + + +
unsigned int sf::SoundBuffer::getSampleRate () const
+
+ +

Get the sample rate of the sound.

+

The sample rate is the number of samples played per second. The higher, the better the quality (for example, 44100 samples/s is CD quality).

+
Returns
Sample rate (number of samples per second)
+
See also
getChannelCount, getDuration
+ +
+
+ +

◆ getSamples()

+ +
+
+ + + + + + + +
const Int16 * sf::SoundBuffer::getSamples () const
+
+ +

Get the array of audio samples stored in the buffer.

+

The format of the returned samples is 16 bits signed integer (sf::Int16). The total number of samples in this array is given by the getSampleCount() function.

+
Returns
Read-only pointer to the array of sound samples
+
See also
getSampleCount
+ +
+
+ +

◆ loadFromFile()

+ +
+
+ + + + + + + + +
bool sf::SoundBuffer::loadFromFile (const std::string & filename)
+
+ +

Load the sound buffer from a file.

+

See the documentation of sf::InputSoundFile for the list of supported formats.

+
Parameters
+ + +
filenamePath of the sound file to load
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromMemory, loadFromStream, loadFromSamples, saveToFile
+ +
+
+ +

◆ loadFromMemory()

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::SoundBuffer::loadFromMemory (const void * data,
std::size_t sizeInBytes 
)
+
+ +

Load the sound buffer from a file in memory.

+

See the documentation of sf::InputSoundFile for the list of supported formats.

+
Parameters
+ + + +
dataPointer to the file data in memory
sizeInBytesSize of the data to load, in bytes
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromStream, loadFromSamples
+ +
+
+ +

◆ loadFromSamples()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::SoundBuffer::loadFromSamples (const Int16 * samples,
Uint64 sampleCount,
unsigned int channelCount,
unsigned int sampleRate 
)
+
+ +

Load the sound buffer from an array of audio samples.

+

The assumed format of the audio samples is 16 bits signed integer (sf::Int16).

+
Parameters
+ + + + + +
samplesPointer to the array of samples in memory
sampleCountNumber of samples in the array
channelCountNumber of channels (1 = mono, 2 = stereo, ...)
sampleRateSample rate (number of samples to play per second)
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromMemory, saveToFile
+ +
+
+ +

◆ loadFromStream()

+ +
+
+ + + + + + + + +
bool sf::SoundBuffer::loadFromStream (InputStream & stream)
+
+ +

Load the sound buffer from a custom stream.

+

See the documentation of sf::InputSoundFile for the list of supported formats.

+
Parameters
+ + +
streamSource stream to read from
+
+
+
Returns
True if loading succeeded, false if it failed
+
See also
loadFromFile, loadFromMemory, loadFromSamples
+ +
+
+ +

◆ operator=()

+ +
+
+ + + + + + + + +
SoundBuffer & sf::SoundBuffer::operator= (const SoundBuffer & right)
+
+ +

Overload of assignment operator.

+
Parameters
+ + +
rightInstance to assign
+
+
+
Returns
Reference to self
+ +
+
+ +

◆ saveToFile()

+ +
+
+ + + + + + + + +
bool sf::SoundBuffer::saveToFile (const std::string & filename) const
+
+ +

Save the sound buffer to an audio file.

+

See the documentation of sf::OutputSoundFile for the list of supported formats.

+
Parameters
+ + +
filenamePath of the sound file to write
+
+
+
Returns
True if saving succeeded, false if it failed
+
See also
loadFromFile, loadFromMemory, loadFromSamples
+ +
+
+

Friends And Related Function Documentation

+ +

◆ Sound

+ +
+
+ + + + + +
+ + + + +
friend class Sound
+ 		+friend
+
+ +

Definition at line 228 of file SoundBuffer.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundBuffer.png b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBuffer.png new file mode 100644 index 000000000..b6d1b46c6 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBuffer.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundBufferRecorder-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBufferRecorder-members.html new file mode 100644 index 000000000..8dbab4686 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBufferRecorder-members.html @@ -0,0 +1,126 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::SoundBufferRecorder Member List
+
+
+ +

This is the complete list of members for sf::SoundBufferRecorder, including all inherited members.

+ + + + + + + + + + + + + + + + + + + +
getAvailableDevices()sf::SoundRecorderstatic
getBuffer() constsf::SoundBufferRecorder
getChannelCount() constsf::SoundRecorder
getDefaultDevice()sf::SoundRecorderstatic
getDevice() constsf::SoundRecorder
getSampleRate() constsf::SoundRecorder
isAvailable()sf::SoundRecorderstatic
onProcessSamples(const Int16 *samples, std::size_t sampleCount)sf::SoundBufferRecorderprotectedvirtual
onStart()sf::SoundBufferRecorderprotectedvirtual
onStop()sf::SoundBufferRecorderprotectedvirtual
setChannelCount(unsigned int channelCount)sf::SoundRecorder
setDevice(const std::string &name)sf::SoundRecorder
setProcessingInterval(Time interval)sf::SoundRecorderprotected
SoundRecorder()sf::SoundRecorderprotected
start(unsigned int sampleRate=44100)sf::SoundRecorder
stop()sf::SoundRecorder
~SoundBufferRecorder()sf::SoundBufferRecorder
~SoundRecorder()sf::SoundRecordervirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundBufferRecorder.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBufferRecorder.html new file mode 100644 index 000000000..1cec604d3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBufferRecorder.html @@ -0,0 +1,713 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Static Public Member Functions | +Protected Member Functions | +List of all members
+
sf::SoundBufferRecorder Class Reference
Audio module
+
+
+ +

Specialized SoundRecorder which stores the captured audio data into a sound buffer. + More...

+ +

#include <SFML/Audio/SoundBufferRecorder.hpp>

+
+Inheritance diagram for sf::SoundBufferRecorder:
+
+
+ + +sf::SoundRecorder +sf::AlResource + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 ~SoundBufferRecorder ()
 destructor
 
const SoundBuffer & getBuffer () const
 Get the sound buffer containing the captured audio data.
 
bool start (unsigned int sampleRate=44100)
 Start the capture.
 
void stop ()
 Stop the capture.
 
unsigned int getSampleRate () const
 Get the sample rate.
 
bool setDevice (const std::string &name)
 Set the audio capture device.
 
const std::string & getDevice () const
 Get the name of the current audio capture device.
 
void setChannelCount (unsigned int channelCount)
 Set the channel count of the audio capture device.
 
unsigned int getChannelCount () const
 Get the number of channels used by this recorder.
 
+ + + + + + + + + + +

+Static Public Member Functions

static std::vector< std::string > getAvailableDevices ()
 Get a list of the names of all available audio capture devices.
 
static std::string getDefaultDevice ()
 Get the name of the default audio capture device.
 
static bool isAvailable ()
 Check if the system supports audio capture.
 
+ + + + + + + + + + + + + +

+Protected Member Functions

virtual bool onStart ()
 Start capturing audio data.
 
virtual bool onProcessSamples (const Int16 *samples, std::size_t sampleCount)
 Process a new chunk of recorded samples.
 
virtual void onStop ()
 Stop capturing audio data.
 
void setProcessingInterval (Time interval)
 Set the processing interval.
 
+

Detailed Description

+

Specialized SoundRecorder which stores the captured audio data into a sound buffer.

+

sf::SoundBufferRecorder allows to access a recorded sound through a sf::SoundBuffer, so that it can be played, saved to a file, etc.

+

It has the same simple interface as its base class (start(), stop()) and adds a function to retrieve the recorded sound buffer (getBuffer()).

+

As usual, don't forget to call the isAvailable() function before using this class (see sf::SoundRecorder for more details about this).

+

Usage example:

if (sf::SoundBufferRecorder::isAvailable())
+
{
+
// Record some audio data
+
sf::SoundBufferRecorder recorder;
+
recorder.start();
+
...
+
recorder.stop();
+
+
// Get the buffer containing the captured audio data
+
const sf::SoundBuffer& buffer = recorder.getBuffer();
+
+
// Save it to a file (for example...)
+
buffer.saveToFile("my_record.ogg");
+
}
+
sf::SoundBufferRecorder
Specialized SoundRecorder which stores the captured audio data into a sound buffer.
Definition: SoundBufferRecorder.hpp:45
+
sf::SoundBufferRecorder::getBuffer
const SoundBuffer & getBuffer() const
Get the sound buffer containing the captured audio data.
+
sf::SoundBuffer
Storage for audio samples defining a sound.
Definition: SoundBuffer.hpp:50
+
sf::SoundBuffer::saveToFile
bool saveToFile(const std::string &filename) const
Save the sound buffer to an audio file.
+
sf::SoundRecorder::start
bool start(unsigned int sampleRate=44100)
Start the capture.
+
sf::SoundRecorder::stop
void stop()
Stop the capture.
+
sf::SoundRecorder::isAvailable
static bool isAvailable()
Check if the system supports audio capture.
+
See also
sf::SoundRecorder
+ +

Definition at line 44 of file SoundBufferRecorder.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ~SoundBufferRecorder()

+ +
+
+ + + + + + + +
sf::SoundBufferRecorder::~SoundBufferRecorder ()
+
+ +

destructor

+ +
+
+

Member Function Documentation

+ +

◆ getAvailableDevices()

+ +
+
+ + + + + +
+ + + + + + + +
static std::vector< std::string > sf::SoundRecorder::getAvailableDevices ()
+ 		+staticinherited
+
+ +

Get a list of the names of all available audio capture devices.

+

This function returns a vector of strings, containing the names of all available audio capture devices.

+
Returns
A vector of strings containing the names
+ +
+
+ +

◆ getBuffer()

+ +
+
+ + + + + + + +
const SoundBuffer & sf::SoundBufferRecorder::getBuffer () const
+
+ +

Get the sound buffer containing the captured audio data.

+

The sound buffer is valid only after the capture has ended. This function provides a read-only access to the internal sound buffer, but it can be copied if you need to make any modification to it.

+
Returns
Read-only access to the sound buffer
+ +
+
+ +

◆ getChannelCount()

+ +
+
+ + + + + +
+ + + + + + + +
unsigned int sf::SoundRecorder::getChannelCount () const
+ 		+inherited
+
+ +

Get the number of channels used by this recorder.

+

Currently only mono and stereo are supported, so the value is either 1 (for mono) or 2 (for stereo).

+
Returns
Number of channels
+
See also
setChannelCount
+ +
+
+ +

◆ getDefaultDevice()

+ +
+
+ + + + + +
+ + + + + + + +
static std::string sf::SoundRecorder::getDefaultDevice ()
+ 		+staticinherited
+
+ +

Get the name of the default audio capture device.

+

This function returns the name of the default audio capture device. If none is available, an empty string is returned.

+
Returns
The name of the default audio capture device
+ +
+
+ +

◆ getDevice()

+ +
+
+ + + + + +
+ + + + + + + +
const std::string & sf::SoundRecorder::getDevice () const
+ 		+inherited
+
+ +

Get the name of the current audio capture device.

+
Returns
The name of the current audio capture device
+ +
+
+ +

◆ getSampleRate()

+ +
+
+ + + + + +
+ + + + + + + +
unsigned int sf::SoundRecorder::getSampleRate () const
+ 		+inherited
+
+ +

Get the sample rate.

+

The sample rate defines the number of audio samples captured per second. The higher, the better the quality (for example, 44100 samples/sec is CD quality).

+
Returns
Sample rate, in samples per second
+ +
+
+ +

◆ isAvailable()

+ +
+
+ + + + + +
+ + + + + + + +
static bool sf::SoundRecorder::isAvailable ()
+ 		+staticinherited
+
+ +

Check if the system supports audio capture.

+

This function should always be called before using the audio capture features. If it returns false, then any attempt to use sf::SoundRecorder or one of its derived classes will fail.

+
Returns
True if audio capture is supported, false otherwise
+ +
+
+ +

◆ onProcessSamples()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual bool sf::SoundBufferRecorder::onProcessSamples (const Int16 * samples,
std::size_t sampleCount 
)
+ 		+protectedvirtual
+
+ +

Process a new chunk of recorded samples.

+
Parameters
+ + + +
samplesPointer to the new chunk of recorded samples
sampleCountNumber of samples pointed by samples
+
+
+
Returns
True to continue the capture, or false to stop it
+ +

Implements sf::SoundRecorder.

+ +
+
+ +

◆ onStart()

+ +
+
+ + + + + +
+ + + + + + + +
virtual bool sf::SoundBufferRecorder::onStart ()
+ 		+protectedvirtual
+
+ +

Start capturing audio data.

+
Returns
True to start the capture, or false to abort it
+ +

Reimplemented from sf::SoundRecorder.

+ +
+
+ +

◆ onStop()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::SoundBufferRecorder::onStop ()
+ 		+protectedvirtual
+
+ +

Stop capturing audio data.

+ +

Reimplemented from sf::SoundRecorder.

+ +
+
+ +

◆ setChannelCount()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundRecorder::setChannelCount (unsigned int channelCount)
+ 		+inherited
+
+ +

Set the channel count of the audio capture device.

+

This method allows you to specify the number of channels used for recording. Currently only 16-bit mono and 16-bit stereo are supported.

+
Parameters
+ + +
channelCountNumber of channels. Currently only mono (1) and stereo (2) are supported.
+
+
+
See also
getChannelCount
+ +
+
+ +

◆ setDevice()

+ +
+
+ + + + + +
+ + + + + + + + +
bool sf::SoundRecorder::setDevice (const std::string & name)
+ 		+inherited
+
+ +

Set the audio capture device.

+

This function sets the audio capture device to the device with the given name. It can be called on the fly (i.e: while recording). If you do so while recording and opening the device fails, it stops the recording.

+
Parameters
+ + +
nameThe name of the audio capture device
+
+
+
Returns
True, if it was able to set the requested device
+
See also
getAvailableDevices, getDefaultDevice
+ +
+
+ +

◆ setProcessingInterval()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundRecorder::setProcessingInterval (Time interval)
+ 		+protectedinherited
+
+ +

Set the processing interval.

+

The processing interval controls the period between calls to the onProcessSamples function. You may want to use a small interval if you want to process the recorded data in real time, for example.

+

Note: this is only a hint, the actual period may vary. So don't rely on this parameter to implement precise timing.

+

The default processing interval is 100 ms.

+
Parameters
+ + +
intervalProcessing interval
+
+
+ +
+
+ +

◆ start()

+ +
+
+ + + + + +
+ + + + + + + + +
bool sf::SoundRecorder::start (unsigned int sampleRate = 44100)
+ 		+inherited
+
+ +

Start the capture.

+

The sampleRate parameter defines the number of audio samples captured per second. The higher, the better the quality (for example, 44100 samples/sec is CD quality). This function uses its own thread so that it doesn't block the rest of the program while the capture runs. Please note that only one capture can happen at the same time. You can select which capture device will be used, by passing the name to the setDevice() method. If none was selected before, the default capture device will be used. You can get a list of the names of all available capture devices by calling getAvailableDevices().

+
Parameters
+ + +
sampleRateDesired capture rate, in number of samples per second
+
+
+
Returns
True, if start of capture was successful
+
See also
stop, getAvailableDevices
+ +
+
+ +

◆ stop()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::SoundRecorder::stop ()
+ 		+inherited
+
+ +

Stop the capture.

+
See also
start
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundBufferRecorder.png b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBufferRecorder.png new file mode 100644 index 000000000..ad6bfe317 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1SoundBufferRecorder.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileFactory-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileFactory-members.html new file mode 100644 index 000000000..baf5c097e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileFactory-members.html @@ -0,0 +1,116 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::SoundFileFactory Member List
+
+
+ +

This is the complete list of members for sf::SoundFileFactory, including all inherited members.

+ + + + + + + + + +
createReaderFromFilename(const std::string &filename)sf::SoundFileFactorystatic
createReaderFromMemory(const void *data, std::size_t sizeInBytes)sf::SoundFileFactorystatic
createReaderFromStream(InputStream &stream)sf::SoundFileFactorystatic
createWriterFromFilename(const std::string &filename)sf::SoundFileFactorystatic
registerReader()sf::SoundFileFactorystatic
registerWriter()sf::SoundFileFactorystatic
unregisterReader()sf::SoundFileFactorystatic
unregisterWriter()sf::SoundFileFactorystatic
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileFactory.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileFactory.html new file mode 100644 index 000000000..f27730f01 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileFactory.html @@ -0,0 +1,438 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Static Public Member Functions | +List of all members
+
sf::SoundFileFactory Class Reference
Audio module
+
+
+ +

Manages and instantiates sound file readers and writers. + More...

+ +

#include <SFML/Audio/SoundFileFactory.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

template<typename T >
static void registerReader ()
 Register a new reader.
 
template<typename T >
static void unregisterReader ()
 Unregister a reader.
 
template<typename T >
static void registerWriter ()
 Register a new writer.
 
template<typename T >
static void unregisterWriter ()
 Unregister a writer.
 
static SoundFileReader * createReaderFromFilename (const std::string &filename)
 Instantiate the right reader for the given file on disk.
 
static SoundFileReader * createReaderFromMemory (const void *data, std::size_t sizeInBytes)
 Instantiate the right codec for the given file in memory.
 
static SoundFileReader * createReaderFromStream (InputStream &stream)
 Instantiate the right codec for the given file in stream.
 
static SoundFileWriter * createWriterFromFilename (const std::string &filename)
 Instantiate the right writer for the given file on disk.
 
+

Detailed Description

+

Manages and instantiates sound file readers and writers.

+

This class is where all the sound file readers and writers are registered.

+

You should normally only need to use its registration and unregistration functions; readers/writers creation and manipulation are wrapped into the higher-level classes sf::InputSoundFile and sf::OutputSoundFile.

+

To register a new reader (writer) use the sf::SoundFileFactory::registerReader (registerWriter) static function. You don't have to call the unregisterReader (unregisterWriter) function, unless you want to unregister a format before your application ends (typically, when a plugin is unloaded).

+

Usage example:

sf::SoundFileFactory::registerReader<MySoundFileReader>();
+
sf::SoundFileFactory::registerWriter<MySoundFileWriter>();
+
See also
sf::InputSoundFile, sf::OutputSoundFile, sf::SoundFileReader, sf::SoundFileWriter
+ +

Definition at line 46 of file SoundFileFactory.hpp.

+

Member Function Documentation

+ +

◆ createReaderFromFilename()

+ +
+
+ + + + + +
+ + + + + + + + +
static SoundFileReader * sf::SoundFileFactory::createReaderFromFilename (const std::string & filename)
+ 		+static
+
+ +

Instantiate the right reader for the given file on disk.

+

It's up to the caller to release the returned reader

+
Parameters
+ + +
filenamePath of the sound file
+
+
+
Returns
A new sound file reader that can read the given file, or null if no reader can handle it
+
See also
createReaderFromMemory, createReaderFromStream
+ +
+
+ +

◆ createReaderFromMemory()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static SoundFileReader * sf::SoundFileFactory::createReaderFromMemory (const void * data,
std::size_t sizeInBytes 
)
+ 		+static
+
+ +

Instantiate the right codec for the given file in memory.

+

It's up to the caller to release the returned reader

+
Parameters
+ + + +
dataPointer to the file data in memory
sizeInBytesTotal size of the file data, in bytes
+
+
+
Returns
A new sound file codec that can read the given file, or null if no codec can handle it
+
See also
createReaderFromFilename, createReaderFromStream
+ +
+
+ +

◆ createReaderFromStream()

+ +
+
+ + + + + +
+ + + + + + + + +
static SoundFileReader * sf::SoundFileFactory::createReaderFromStream (InputStream & stream)
+ 		+static
+
+ +

Instantiate the right codec for the given file in stream.

+

It's up to the caller to release the returned reader

+
Parameters
+ + +
streamSource stream to read from
+
+
+
Returns
A new sound file codec that can read the given file, or null if no codec can handle it
+
See also
createReaderFromFilename, createReaderFromMemory
+ +
+
+ +

◆ createWriterFromFilename()

+ +
+
+ + + + + +
+ + + + + + + + +
static SoundFileWriter * sf::SoundFileFactory::createWriterFromFilename (const std::string & filename)
+ 		+static
+
+ +

Instantiate the right writer for the given file on disk.

+

It's up to the caller to release the returned writer

+
Parameters
+ + +
filenamePath of the sound file
+
+
+
Returns
A new sound file writer that can write given file, or null if no writer can handle it
+ +
+
+ +

◆ registerReader()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + +
static void sf::SoundFileFactory::registerReader ()
+ 		+static
+
+ +

Register a new reader.

+
See also
unregisterReader
+ +
+
+ +

◆ registerWriter()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + +
static void sf::SoundFileFactory::registerWriter ()
+ 		+static
+
+ +

Register a new writer.

+
See also
unregisterWriter
+ +
+
+ +

◆ unregisterReader()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + +
static void sf::SoundFileFactory::unregisterReader ()
+ 		+static
+
+ +

Unregister a reader.

+
See also
registerReader
+ +
+
+ +

◆ unregisterWriter()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + +
static void sf::SoundFileFactory::unregisterWriter ()
+ 		+static
+
+ +

Unregister a writer.

+
See also
registerWriter
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileReader-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileReader-members.html new file mode 100644 index 000000000..beda39084 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileReader-members.html @@ -0,0 +1,112 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::SoundFileReader Member List
+
+
+ +

This is the complete list of members for sf::SoundFileReader, including all inherited members.

+ + + + + +
open(InputStream &stream, Info &info)=0sf::SoundFileReaderpure virtual
read(Int16 *samples, Uint64 maxCount)=0sf::SoundFileReaderpure virtual
seek(Uint64 sampleOffset)=0sf::SoundFileReaderpure virtual
~SoundFileReader()sf::SoundFileReaderinlinevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileReader.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileReader.html new file mode 100644 index 000000000..5a20ed8a3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileReader.html @@ -0,0 +1,340 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Member Functions | +List of all members
+
sf::SoundFileReader Class Referenceabstract
Audio module
+
+
+ +

Abstract base class for sound file decoding. + More...

+ +

#include <SFML/Audio/SoundFileReader.hpp>

+ + + + + +

+Classes

struct  Info
 Structure holding the audio properties of a sound file. More...
 
+ + + + + + + + + + + + + +

+Public Member Functions

virtual ~SoundFileReader ()
 Virtual destructor.
 
virtual bool open (InputStream &stream, Info &info)=0
 Open a sound file for reading.
 
virtual void seek (Uint64 sampleOffset)=0
 Change the current read position to the given sample offset.
 
virtual Uint64 read (Int16 *samples, Uint64 maxCount)=0
 Read audio samples from the open file.
 
+

Detailed Description

+

Abstract base class for sound file decoding.

+

This class allows users to read audio file formats not natively supported by SFML, and thus extend the set of supported readable audio formats.

+

A valid sound file reader must override the open, seek and write functions, as well as providing a static check function; the latter is used by SFML to find a suitable writer for a given input file.

+

To register a new reader, use the sf::SoundFileFactory::registerReader template function.

+

Usage example:

class MySoundFileReader : public sf::SoundFileReader
+
{
+
public:
+
+
static bool check(sf::InputStream& stream)
+
{
+
// typically, read the first few header bytes and check fields that identify the format
+
// return true if the reader can handle the format
+
}
+
+
virtual bool open(sf::InputStream& stream, Info& info)
+
{
+
// read the sound file header and fill the sound attributes
+
// (channel count, sample count and sample rate)
+
// return true on success
+
}
+
+
virtual void seek(sf::Uint64 sampleOffset)
+
{
+
// advance to the sampleOffset-th sample from the beginning of the sound
+
}
+
+
virtual sf::Uint64 read(sf::Int16* samples, sf::Uint64 maxCount)
+
{
+
// read up to 'maxCount' samples into the 'samples' array,
+
// convert them (for example from normalized float) if they are not stored
+
// as 16-bits signed integers in the file
+
// return the actual number of samples read
+
}
+
};
+
+
sf::SoundFileFactory::registerReader<MySoundFileReader>();
+
sf::InputStream
Abstract class for custom file input streams.
Definition: InputStream.hpp:42
+
sf::SoundFileReader
Abstract base class for sound file decoding.
Definition: SoundFileReader.hpp:44
+
See also
sf::InputSoundFile, sf::SoundFileFactory, sf::SoundFileWriter
+ +

Definition at line 43 of file SoundFileReader.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ~SoundFileReader()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::SoundFileReader::~SoundFileReader ()
+ 		+inlinevirtual
+
+ +

Virtual destructor.

+ +

Definition at line 62 of file SoundFileReader.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ open()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual bool sf::SoundFileReader::open (InputStream & stream,
Info & info 
)
+ 		+pure virtual
+
+ +

Open a sound file for reading.

+

The provided stream reference is valid as long as the SoundFileReader is alive, so it is safe to use/store it during the whole lifetime of the reader.

+
Parameters
+ + + +
streamSource stream to read from
infoStructure to fill with the properties of the loaded sound
+
+
+
Returns
True if the file was successfully opened
+ +
+
+ +

◆ read()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual Uint64 sf::SoundFileReader::read (Int16 * samples,
Uint64 maxCount 
)
+ 		+pure virtual
+
+ +

Read audio samples from the open file.

+
Parameters
+ + + +
samplesPointer to the sample array to fill
maxCountMaximum number of samples to read
+
+
+
Returns
Number of samples actually read (may be less than maxCount)
+ +
+
+ +

◆ seek()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual void sf::SoundFileReader::seek (Uint64 sampleOffset)
+ 		+pure virtual
+
+ +

Change the current read position to the given sample offset.

+

The sample offset takes the channels into account. If you have a time offset instead, you can easily find the corresponding sample offset with the following formula: timeInSeconds * sampleRate * channelCount If the given offset exceeds to total number of samples, this function must jump to the end of the file.

+
Parameters
+ + +
sampleOffsetIndex of the sample to jump to, relative to the beginning
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileWriter-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileWriter-members.html new file mode 100644 index 000000000..b5861a07e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileWriter-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::SoundFileWriter Member List
+
+
+ +

This is the complete list of members for sf::SoundFileWriter, including all inherited members.

+ + + + +
open(const std::string &filename, unsigned int sampleRate, unsigned int channelCount)=0sf::SoundFileWriterpure virtual
write(const Int16 *samples, Uint64 count)=0sf::SoundFileWriterpure virtual
~SoundFileWriter()sf::SoundFileWriterinlinevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileWriter.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileWriter.html new file mode 100644 index 000000000..8943790c7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundFileWriter.html @@ -0,0 +1,292 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::SoundFileWriter Class Referenceabstract
Audio module
+
+
+ +

Abstract base class for sound file encoding. + More...

+ +

#include <SFML/Audio/SoundFileWriter.hpp>

+ + + + + + + + + + + +

+Public Member Functions

virtual ~SoundFileWriter ()
 Virtual destructor.
 
virtual bool open (const std::string &filename, unsigned int sampleRate, unsigned int channelCount)=0
 Open a sound file for writing.
 
virtual void write (const Int16 *samples, Uint64 count)=0
 Write audio samples to the open file.
 
+

Detailed Description

+

Abstract base class for sound file encoding.

+

This class allows users to write audio file formats not natively supported by SFML, and thus extend the set of supported writable audio formats.

+

A valid sound file writer must override the open and write functions, as well as providing a static check function; the latter is used by SFML to find a suitable writer for a given filename.

+

To register a new writer, use the sf::SoundFileFactory::registerWriter template function.

+

Usage example:

class MySoundFileWriter : public sf::SoundFileWriter
+
{
+
public:
+
+
static bool check(const std::string& filename)
+
{
+
// typically, check the extension
+
// return true if the writer can handle the format
+
}
+
+
virtual bool open(const std::string& filename, unsigned int sampleRate, unsigned int channelCount)
+
{
+
// open the file 'filename' for writing,
+
// write the given sample rate and channel count to the file header
+
// return true on success
+
}
+
+
virtual void write(const sf::Int16* samples, sf::Uint64 count)
+
{
+
// write 'count' samples stored at address 'samples',
+
// convert them (for example to normalized float) if the format requires it
+
}
+
};
+
+
sf::SoundFileFactory::registerWriter<MySoundFileWriter>();
+
sf::SoundFileWriter
Abstract base class for sound file encoding.
Definition: SoundFileWriter.hpp:42
+
See also
sf::OutputSoundFile, sf::SoundFileFactory, sf::SoundFileReader
+ +

Definition at line 41 of file SoundFileWriter.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ~SoundFileWriter()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::SoundFileWriter::~SoundFileWriter ()
+ 		+inlinevirtual
+
+ +

Virtual destructor.

+ +

Definition at line 49 of file SoundFileWriter.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ open()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
virtual bool sf::SoundFileWriter::open (const std::string & filename,
unsigned int sampleRate,
unsigned int channelCount 
)
+ 		+pure virtual
+
+ +

Open a sound file for writing.

+
Parameters
+ + + + +
filenamePath of the file to open
sampleRateSample rate of the sound
channelCountNumber of channels of the sound
+
+
+
Returns
True if the file was successfully opened
+ +
+
+ +

◆ write()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual void sf::SoundFileWriter::write (const Int16 * samples,
Uint64 count 
)
+ 		+pure virtual
+
+ +

Write audio samples to the open file.

+
Parameters
+ + + +
samplesPointer to the sample array to write
countNumber of samples to write
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundRecorder-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundRecorder-members.html new file mode 100644 index 000000000..677ae058e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundRecorder-members.html @@ -0,0 +1,124 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::SoundRecorder Member List
+
+
+ +

This is the complete list of members for sf::SoundRecorder, including all inherited members.

+ + + + + + + + + + + + + + + + + +
getAvailableDevices()sf::SoundRecorderstatic
getChannelCount() constsf::SoundRecorder
getDefaultDevice()sf::SoundRecorderstatic
getDevice() constsf::SoundRecorder
getSampleRate() constsf::SoundRecorder
isAvailable()sf::SoundRecorderstatic
onProcessSamples(const Int16 *samples, std::size_t sampleCount)=0sf::SoundRecorderprotectedpure virtual
onStart()sf::SoundRecorderprotectedvirtual
onStop()sf::SoundRecorderprotectedvirtual
setChannelCount(unsigned int channelCount)sf::SoundRecorder
setDevice(const std::string &name)sf::SoundRecorder
setProcessingInterval(Time interval)sf::SoundRecorderprotected
SoundRecorder()sf::SoundRecorderprotected
start(unsigned int sampleRate=44100)sf::SoundRecorder
stop()sf::SoundRecorder
~SoundRecorder()sf::SoundRecordervirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundRecorder.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundRecorder.html new file mode 100644 index 000000000..f3f829872 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundRecorder.html @@ -0,0 +1,712 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Static Public Member Functions | +Protected Member Functions | +List of all members
+
sf::SoundRecorder Class Referenceabstract
Audio module
+
+
+ +

Abstract base class for capturing sound data. + More...

+ +

#include <SFML/Audio/SoundRecorder.hpp>

+
+Inheritance diagram for sf::SoundRecorder:
+
+
+ + +sf::AlResource +sf::SoundBufferRecorder + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

virtual ~SoundRecorder ()
 destructor
 
bool start (unsigned int sampleRate=44100)
 Start the capture.
 
void stop ()
 Stop the capture.
 
unsigned int getSampleRate () const
 Get the sample rate.
 
bool setDevice (const std::string &name)
 Set the audio capture device.
 
const std::string & getDevice () const
 Get the name of the current audio capture device.
 
void setChannelCount (unsigned int channelCount)
 Set the channel count of the audio capture device.
 
unsigned int getChannelCount () const
 Get the number of channels used by this recorder.
 
+ + + + + + + + + + +

+Static Public Member Functions

static std::vector< std::string > getAvailableDevices ()
 Get a list of the names of all available audio capture devices.
 
static std::string getDefaultDevice ()
 Get the name of the default audio capture device.
 
static bool isAvailable ()
 Check if the system supports audio capture.
 
+ + + + + + + + + + + + + + + + +

+Protected Member Functions

 SoundRecorder ()
 Default constructor.
 
void setProcessingInterval (Time interval)
 Set the processing interval.
 
virtual bool onStart ()
 Start capturing audio data.
 
virtual bool onProcessSamples (const Int16 *samples, std::size_t sampleCount)=0
 Process a new chunk of recorded samples.
 
virtual void onStop ()
 Stop capturing audio data.
 
+

Detailed Description

+

Abstract base class for capturing sound data.

+

sf::SoundBuffer provides a simple interface to access the audio recording capabilities of the computer (the microphone).

+

As an abstract base class, it only cares about capturing sound samples, the task of making something useful with them is left to the derived class. Note that SFML provides a built-in specialization for saving the captured data to a sound buffer (see sf::SoundBufferRecorder).

+

A derived class has only one virtual function to override:

    +
  • onProcessSamples provides the new chunks of audio samples while the capture happens
    • +
+

Moreover, two additional virtual functions can be overridden as well if necessary:

    +
  • onStart is called before the capture happens, to perform custom initializations
    • +
  • onStop is called after the capture ends, to perform custom cleanup
    • +
+

A derived class can also control the frequency of the onProcessSamples calls, with the setProcessingInterval protected function. The default interval is chosen so that recording thread doesn't consume too much CPU, but it can be changed to a smaller value if you need to process the recorded data in real time, for example.

+

The audio capture feature may not be supported or activated on every platform, thus it is recommended to check its availability with the isAvailable() function. If it returns false, then any attempt to use an audio recorder will fail.

+

If you have multiple sound input devices connected to your computer (for example: microphone, external soundcard, webcam mic, ...) you can get a list of all available devices through the getAvailableDevices() function. You can then select a device by calling setDevice() with the appropriate device. Otherwise the default capturing device will be used.

+

By default the recording is in 16-bit mono. Using the setChannelCount method you can change the number of channels used by the audio capture device to record. Note that you have to decide whether you want to record in mono or stereo before starting the recording.

+

It is important to note that the audio capture happens in a separate thread, so that it doesn't block the rest of the program. In particular, the onProcessSamples virtual function (but not onStart and not onStop) will be called from this separate thread. It is important to keep this in mind, because you may have to take care of synchronization issues if you share data between threads. Another thing to bear in mind is that you must call stop() in the destructor of your derived class, so that the recording thread finishes before your object is destroyed.

+

Usage example:

class CustomRecorder : public sf::SoundRecorder
+
{
+
public:
+
~CustomRecorder()
+
{
+
// Make sure to stop the recording thread
+
stop();
+
}
+
+
private:
+
virtual bool onStart() // optional
+
{
+
// Initialize whatever has to be done before the capture starts
+
...
+
+
// Return true to start playing
+
return true;
+
}
+
+
virtual bool onProcessSamples(const sf::Int16* samples, std::size_t sampleCount)
+
{
+
// Do something with the new chunk of samples (store them, send them, ...)
+
...
+
+
// Return true to continue playing
+
return true;
+
}
+
+
virtual void onStop() // optional
+
{
+
// Clean up whatever has to be done after the capture ends
+
...
+
}
+
};
+
+
// Usage
+
if (CustomRecorder::isAvailable())
+
{
+
CustomRecorder recorder;
+
+
if (!recorder.start())
+
return -1;
+
+
...
+
recorder.stop();
+
}
+
sf::SoundRecorder
Abstract base class for capturing sound data.
Definition: SoundRecorder.hpp:46
+
See also
sf::SoundBufferRecorder
+ +

Definition at line 45 of file SoundRecorder.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ~SoundRecorder()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::SoundRecorder::~SoundRecorder ()
+ 		+virtual
+
+ +

destructor

+ +
+
+ +

◆ SoundRecorder()

+ +
+
+ + + + + +
+ + + + + + + +
sf::SoundRecorder::SoundRecorder ()
+ 		+protected
+
+ +

Default constructor.

+

This constructor is only meant to be called by derived classes.

+ +
+
+

Member Function Documentation

+ +

◆ getAvailableDevices()

+ +
+
+ + + + + +
+ + + + + + + +
static std::vector< std::string > sf::SoundRecorder::getAvailableDevices ()
+ 		+static
+
+ +

Get a list of the names of all available audio capture devices.

+

This function returns a vector of strings, containing the names of all available audio capture devices.

+
Returns
A vector of strings containing the names
+ +
+
+ +

◆ getChannelCount()

+ +
+
+ + + + + + + +
unsigned int sf::SoundRecorder::getChannelCount () const
+
+ +

Get the number of channels used by this recorder.

+

Currently only mono and stereo are supported, so the value is either 1 (for mono) or 2 (for stereo).

+
Returns
Number of channels
+
See also
setChannelCount
+ +
+
+ +

◆ getDefaultDevice()

+ +
+
+ + + + + +
+ + + + + + + +
static std::string sf::SoundRecorder::getDefaultDevice ()
+ 		+static
+
+ +

Get the name of the default audio capture device.

+

This function returns the name of the default audio capture device. If none is available, an empty string is returned.

+
Returns
The name of the default audio capture device
+ +
+
+ +

◆ getDevice()

+ +
+
+ + + + + + + +
const std::string & sf::SoundRecorder::getDevice () const
+
+ +

Get the name of the current audio capture device.

+
Returns
The name of the current audio capture device
+ +
+
+ +

◆ getSampleRate()

+ +
+
+ + + + + + + +
unsigned int sf::SoundRecorder::getSampleRate () const
+
+ +

Get the sample rate.

+

The sample rate defines the number of audio samples captured per second. The higher, the better the quality (for example, 44100 samples/sec is CD quality).

+
Returns
Sample rate, in samples per second
+ +
+
+ +

◆ isAvailable()

+ +
+
+ + + + + +
+ + + + + + + +
static bool sf::SoundRecorder::isAvailable ()
+ 		+static
+
+ +

Check if the system supports audio capture.

+

This function should always be called before using the audio capture features. If it returns false, then any attempt to use sf::SoundRecorder or one of its derived classes will fail.

+
Returns
True if audio capture is supported, false otherwise
+ +
+
+ +

◆ onProcessSamples()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual bool sf::SoundRecorder::onProcessSamples (const Int16 * samples,
std::size_t sampleCount 
)
+ 		+protectedpure virtual
+
+ +

Process a new chunk of recorded samples.

+

This virtual function is called every time a new chunk of recorded data is available. The derived class can then do whatever it wants with it (storing it, playing it, sending it over the network, etc.).

+
Parameters
+ + + +
samplesPointer to the new chunk of recorded samples
sampleCountNumber of samples pointed by samples
+
+
+
Returns
True to continue the capture, or false to stop it
+ +

Implemented in sf::SoundBufferRecorder.

+ +
+
+ +

◆ onStart()

+ +
+
+ + + + + +
+ + + + + + + +
virtual bool sf::SoundRecorder::onStart ()
+ 		+protectedvirtual
+
+ +

Start capturing audio data.

+

This virtual function may be overridden by a derived class if something has to be done every time a new capture starts. If not, this function can be ignored; the default implementation does nothing.

+
Returns
True to start the capture, or false to abort it
+ +

Reimplemented in sf::SoundBufferRecorder.

+ +
+
+ +

◆ onStop()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::SoundRecorder::onStop ()
+ 		+protectedvirtual
+
+ +

Stop capturing audio data.

+

This virtual function may be overridden by a derived class if something has to be done every time the capture ends. If not, this function can be ignored; the default implementation does nothing.

+ +

Reimplemented in sf::SoundBufferRecorder.

+ +
+
+ +

◆ setChannelCount()

+ +
+
+ + + + + + + + +
void sf::SoundRecorder::setChannelCount (unsigned int channelCount)
+
+ +

Set the channel count of the audio capture device.

+

This method allows you to specify the number of channels used for recording. Currently only 16-bit mono and 16-bit stereo are supported.

+
Parameters
+ + +
channelCountNumber of channels. Currently only mono (1) and stereo (2) are supported.
+
+
+
See also
getChannelCount
+ +
+
+ +

◆ setDevice()

+ +
+
+ + + + + + + + +
bool sf::SoundRecorder::setDevice (const std::string & name)
+
+ +

Set the audio capture device.

+

This function sets the audio capture device to the device with the given name. It can be called on the fly (i.e: while recording). If you do so while recording and opening the device fails, it stops the recording.

+
Parameters
+ + +
nameThe name of the audio capture device
+
+
+
Returns
True, if it was able to set the requested device
+
See also
getAvailableDevices, getDefaultDevice
+ +
+
+ +

◆ setProcessingInterval()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundRecorder::setProcessingInterval (Time interval)
+ 		+protected
+
+ +

Set the processing interval.

+

The processing interval controls the period between calls to the onProcessSamples function. You may want to use a small interval if you want to process the recorded data in real time, for example.

+

Note: this is only a hint, the actual period may vary. So don't rely on this parameter to implement precise timing.

+

The default processing interval is 100 ms.

+
Parameters
+ + +
intervalProcessing interval
+
+
+ +
+
+ +

◆ start()

+ +
+
+ + + + + + + + +
bool sf::SoundRecorder::start (unsigned int sampleRate = 44100)
+
+ +

Start the capture.

+

The sampleRate parameter defines the number of audio samples captured per second. The higher, the better the quality (for example, 44100 samples/sec is CD quality). This function uses its own thread so that it doesn't block the rest of the program while the capture runs. Please note that only one capture can happen at the same time. You can select which capture device will be used, by passing the name to the setDevice() method. If none was selected before, the default capture device will be used. You can get a list of the names of all available capture devices by calling getAvailableDevices().

+
Parameters
+ + +
sampleRateDesired capture rate, in number of samples per second
+
+
+
Returns
True, if start of capture was successful
+
See also
stop, getAvailableDevices
+ +
+
+ +

◆ stop()

+ +
+
+ + + + + + + +
void sf::SoundRecorder::stop ()
+
+ +

Stop the capture.

+
See also
start
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundRecorder.png b/Space-Invaders/sfml/doc/html/classsf_1_1SoundRecorder.png new file mode 100644 index 000000000..0a5086c3e Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1SoundRecorder.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundSource-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundSource-members.html new file mode 100644 index 000000000..bfcd3e4fe --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundSource-members.html @@ -0,0 +1,134 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::SoundSource Member List
+
+
+ +

This is the complete list of members for sf::SoundSource, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
getAttenuation() constsf::SoundSource
getMinDistance() constsf::SoundSource
getPitch() constsf::SoundSource
getPosition() constsf::SoundSource
getStatus() constsf::SoundSourcevirtual
getVolume() constsf::SoundSource
isRelativeToListener() constsf::SoundSource
m_sourcesf::SoundSourceprotected
operator=(const SoundSource &right)sf::SoundSource
pause()=0sf::SoundSourcepure virtual
Paused enum valuesf::SoundSource
play()=0sf::SoundSourcepure virtual
Playing enum valuesf::SoundSource
setAttenuation(float attenuation)sf::SoundSource
setMinDistance(float distance)sf::SoundSource
setPitch(float pitch)sf::SoundSource
setPosition(float x, float y, float z)sf::SoundSource
setPosition(const Vector3f &position)sf::SoundSource
setRelativeToListener(bool relative)sf::SoundSource
setVolume(float volume)sf::SoundSource
SoundSource(const SoundSource &copy)sf::SoundSource
SoundSource()sf::SoundSourceprotected
Status enum namesf::SoundSource
stop()=0sf::SoundSourcepure virtual
Stopped enum valuesf::SoundSource
~SoundSource()sf::SoundSourcevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundSource.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundSource.html new file mode 100644 index 000000000..8626fb952 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundSource.html @@ -0,0 +1,851 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Protected Member Functions | +Protected Attributes | +List of all members
+
sf::SoundSource Class Referenceabstract
Audio module
+
+
+ +

Base class defining a sound's properties. + More...

+ +

#include <SFML/Audio/SoundSource.hpp>

+
+Inheritance diagram for sf::SoundSource:
+
+
+ + +sf::AlResource +sf::Sound +sf::SoundStream +sf::Music + +
+ + + + + +

+Public Types

enum  Status { Stopped +, Paused +, Playing + }
 Enumeration of the sound source states. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 SoundSource (const SoundSource &copy)
 Copy constructor.
 
virtual ~SoundSource ()
 Destructor.
 
void setPitch (float pitch)
 Set the pitch of the sound.
 
void setVolume (float volume)
 Set the volume of the sound.
 
void setPosition (float x, float y, float z)
 Set the 3D position of the sound in the audio scene.
 
void setPosition (const Vector3f &position)
 Set the 3D position of the sound in the audio scene.
 
void setRelativeToListener (bool relative)
 Make the sound's position relative to the listener or absolute.
 
void setMinDistance (float distance)
 Set the minimum distance of the sound.
 
void setAttenuation (float attenuation)
 Set the attenuation factor of the sound.
 
float getPitch () const
 Get the pitch of the sound.
 
float getVolume () const
 Get the volume of the sound.
 
Vector3f getPosition () const
 Get the 3D position of the sound in the audio scene.
 
bool isRelativeToListener () const
 Tell whether the sound's position is relative to the listener or is absolute.
 
float getMinDistance () const
 Get the minimum distance of the sound.
 
float getAttenuation () const
 Get the attenuation factor of the sound.
 
SoundSource & operator= (const SoundSource &right)
 Overload of assignment operator.
 
virtual void play ()=0
 Start or resume playing the sound source.
 
virtual void pause ()=0
 Pause the sound source.
 
virtual void stop ()=0
 Stop playing the sound source.
 
virtual Status getStatus () const
 Get the current status of the sound (stopped, paused, playing)
 
+ + + + +

+Protected Member Functions

 SoundSource ()
 Default constructor.
 
+ + + + +

+Protected Attributes

unsigned int m_source
 OpenAL source identifier.
 
+

Detailed Description

+

Base class defining a sound's properties.

+

sf::SoundSource is not meant to be used directly, it only serves as a common base for all audio objects that can live in the audio environment.

+

It defines several properties for the sound: pitch, volume, position, attenuation, etc. All of them can be changed at any time with no impact on performances.

+
See also
sf::Sound, sf::SoundStream
+ +

Definition at line 42 of file SoundSource.hpp.

+

Member Enumeration Documentation

+ +

◆ Status

+ +
+
+ + + + +
enum sf::SoundSource::Status
+
+ +

Enumeration of the sound source states.

+ + + + +
Enumerator
Stopped 

Sound is not playing.

+
Paused 

Sound is paused.

+
Playing 

Sound is playing.

+
+ +

Definition at line 50 of file SoundSource.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ SoundSource() [1/2]

+ +
+
+ + + + + + + + +
sf::SoundSource::SoundSource (const SoundSource & copy)
+
+ +

Copy constructor.

+
Parameters
+ + +
copyInstance to copy
+
+
+ +
+
+ +

◆ ~SoundSource()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::SoundSource::~SoundSource ()
+ 		+virtual
+
+ +

Destructor.

+ +
+
+ +

◆ SoundSource() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
sf::SoundSource::SoundSource ()
+ 		+protected
+
+ +

Default constructor.

+

This constructor is meant to be called by derived classes only.

+ +
+
+

Member Function Documentation

+ +

◆ getAttenuation()

+ +
+
+ + + + + + + +
float sf::SoundSource::getAttenuation () const
+
+ +

Get the attenuation factor of the sound.

+
Returns
Attenuation factor of the sound
+
See also
setAttenuation, getMinDistance
+ +
+
+ +

◆ getMinDistance()

+ +
+
+ + + + + + + +
float sf::SoundSource::getMinDistance () const
+
+ +

Get the minimum distance of the sound.

+
Returns
Minimum distance of the sound
+
See also
setMinDistance, getAttenuation
+ +
+
+ +

◆ getPitch()

+ +
+
+ + + + + + + +
float sf::SoundSource::getPitch () const
+
+ +

Get the pitch of the sound.

+
Returns
Pitch of the sound
+
See also
setPitch
+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + + + +
Vector3f sf::SoundSource::getPosition () const
+
+ +

Get the 3D position of the sound in the audio scene.

+
Returns
Position of the sound
+
See also
setPosition
+ +
+
+ +

◆ getStatus()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Status sf::SoundSource::getStatus () const
+ 		+virtual
+
+ +

Get the current status of the sound (stopped, paused, playing)

+
Returns
Current status of the sound
+ +

Reimplemented in sf::Sound, and sf::SoundStream.

+ +
+
+ +

◆ getVolume()

+ +
+
+ + + + + + + +
float sf::SoundSource::getVolume () const
+
+ +

Get the volume of the sound.

+
Returns
Volume of the sound, in the range [0, 100]
+
See also
setVolume
+ +
+
+ +

◆ isRelativeToListener()

+ +
+
+ + + + + + + +
bool sf::SoundSource::isRelativeToListener () const
+
+ +

Tell whether the sound's position is relative to the listener or is absolute.

+
Returns
True if the position is relative, false if it's absolute
+
See also
setRelativeToListener
+ +
+
+ +

◆ operator=()

+ +
+
+ + + + + + + + +
SoundSource & sf::SoundSource::operator= (const SoundSource & right)
+
+ +

Overload of assignment operator.

+
Parameters
+ + +
rightInstance to assign
+
+
+
Returns
Reference to self
+ +
+
+ +

◆ pause()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::SoundSource::pause ()
+ 		+pure virtual
+
+ +

Pause the sound source.

+

This function pauses the source if it was playing, otherwise (source already paused or stopped) it has no effect.

+
See also
play, stop
+ +

Implemented in sf::Sound, and sf::SoundStream.

+ +
+
+ +

◆ play()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::SoundSource::play ()
+ 		+pure virtual
+
+ +

Start or resume playing the sound source.

+

This function starts the source if it was stopped, resumes it if it was paused, and restarts it from the beginning if it was already playing.

+
See also
pause, stop
+ +

Implemented in sf::Sound, and sf::SoundStream.

+ +
+
+ +

◆ setAttenuation()

+ +
+
+ + + + + + + + +
void sf::SoundSource::setAttenuation (float attenuation)
+
+ +

Set the attenuation factor of the sound.

+

The attenuation is a multiplicative factor which makes the sound more or less loud according to its distance from the listener. An attenuation of 0 will produce a non-attenuated sound, i.e. its volume will always be the same whether it is heard from near or from far. On the other hand, an attenuation value such as 100 will make the sound fade out very quickly as it gets further from the listener. The default value of the attenuation is 1.

+
Parameters
+ + +
attenuationNew attenuation factor of the sound
+
+
+
See also
getAttenuation, setMinDistance
+ +
+
+ +

◆ setMinDistance()

+ +
+
+ + + + + + + + +
void sf::SoundSource::setMinDistance (float distance)
+
+ +

Set the minimum distance of the sound.

+

The "minimum distance" of a sound is the maximum distance at which it is heard at its maximum volume. Further than the minimum distance, it will start to fade out according to its attenuation factor. A value of 0 ("inside the head +of the listener") is an invalid value and is forbidden. The default value of the minimum distance is 1.

+
Parameters
+ + +
distanceNew minimum distance of the sound
+
+
+
See also
getMinDistance, setAttenuation
+ +
+
+ +

◆ setPitch()

+ +
+
+ + + + + + + + +
void sf::SoundSource::setPitch (float pitch)
+
+ +

Set the pitch of the sound.

+

The pitch represents the perceived fundamental frequency of a sound; thus you can make a sound more acute or grave by changing its pitch. A side effect of changing the pitch is to modify the playing speed of the sound as well. The default value for the pitch is 1.

+
Parameters
+ + +
pitchNew pitch to apply to the sound
+
+
+
See also
getPitch
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + + + + +
void sf::SoundSource::setPosition (const Vector3f & position)
+
+ +

Set the 3D position of the sound in the audio scene.

+

Only sounds with one channel (mono sounds) can be spatialized. The default position of a sound is (0, 0, 0).

+
Parameters
+ + +
positionPosition of the sound in the scene
+
+
+
See also
getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::SoundSource::setPosition (float x,
float y,
float z 
)
+
+ +

Set the 3D position of the sound in the audio scene.

+

Only sounds with one channel (mono sounds) can be spatialized. The default position of a sound is (0, 0, 0).

+
Parameters
+ + + + +
xX coordinate of the position of the sound in the scene
yY coordinate of the position of the sound in the scene
zZ coordinate of the position of the sound in the scene
+
+
+
See also
getPosition
+ +
+
+ +

◆ setRelativeToListener()

+ +
+
+ + + + + + + + +
void sf::SoundSource::setRelativeToListener (bool relative)
+
+ +

Make the sound's position relative to the listener or absolute.

+

Making a sound relative to the listener will ensure that it will always be played the same way regardless of the position of the listener. This can be useful for non-spatialized sounds, sounds that are produced by the listener, or sounds attached to it. The default value is false (position is absolute).

+
Parameters
+ + +
relativeTrue to set the position relative, false to set it absolute
+
+
+
See also
isRelativeToListener
+ +
+
+ +

◆ setVolume()

+ +
+
+ + + + + + + + +
void sf::SoundSource::setVolume (float volume)
+
+ +

Set the volume of the sound.

+

The volume is a value between 0 (mute) and 100 (full volume). The default value for the volume is 100.

+
Parameters
+ + +
volumeVolume of the sound
+
+
+
See also
getVolume
+ +
+
+ +

◆ stop()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::SoundSource::stop ()
+ 		+pure virtual
+
+ +

Stop playing the sound source.

+

This function stops the source if it was playing or paused, and does nothing if it was already stopped. It also resets the playing position (unlike pause()).

+
See also
play, pause
+ +

Implemented in sf::Sound, and sf::SoundStream.

+ +
+
+

Member Data Documentation

+ +

◆ m_source

+ +
+
+ + + + + +
+ + + + +
unsigned int sf::SoundSource::m_source
+ 		+protected
+
+ +

OpenAL source identifier.

+ +

Definition at line 309 of file SoundSource.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundSource.png b/Space-Invaders/sfml/doc/html/classsf_1_1SoundSource.png new file mode 100644 index 000000000..40793e112 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1SoundSource.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundStream-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundStream-members.html new file mode 100644 index 000000000..768a2f140 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundStream-members.html @@ -0,0 +1,148 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::SoundStream Member List
+
+
+ +

This is the complete list of members for sf::SoundStream, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
getAttenuation() constsf::SoundSource
getChannelCount() constsf::SoundStream
getLoop() constsf::SoundStream
getMinDistance() constsf::SoundSource
getPitch() constsf::SoundSource
getPlayingOffset() constsf::SoundStream
getPosition() constsf::SoundSource
getSampleRate() constsf::SoundStream
getStatus() constsf::SoundStreamvirtual
getVolume() constsf::SoundSource
initialize(unsigned int channelCount, unsigned int sampleRate)sf::SoundStreamprotected
isRelativeToListener() constsf::SoundSource
m_sourcesf::SoundSourceprotected
NoLoop enum valuesf::SoundStreamprotected
onGetData(Chunk &data)=0sf::SoundStreamprotectedpure virtual
onLoop()sf::SoundStreamprotectedvirtual
onSeek(Time timeOffset)=0sf::SoundStreamprotectedpure virtual
operator=(const SoundSource &right)sf::SoundSource
pause()sf::SoundStreamvirtual
Paused enum valuesf::SoundSource
play()sf::SoundStreamvirtual
Playing enum valuesf::SoundSource
setAttenuation(float attenuation)sf::SoundSource
setLoop(bool loop)sf::SoundStream
setMinDistance(float distance)sf::SoundSource
setPitch(float pitch)sf::SoundSource
setPlayingOffset(Time timeOffset)sf::SoundStream
setPosition(float x, float y, float z)sf::SoundSource
setPosition(const Vector3f &position)sf::SoundSource
setProcessingInterval(Time interval)sf::SoundStreamprotected
setRelativeToListener(bool relative)sf::SoundSource
setVolume(float volume)sf::SoundSource
SoundSource(const SoundSource &copy)sf::SoundSource
SoundSource()sf::SoundSourceprotected
SoundStream()sf::SoundStreamprotected
Status enum namesf::SoundSource
stop()sf::SoundStreamvirtual
Stopped enum valuesf::SoundSource
~SoundSource()sf::SoundSourcevirtual
~SoundStream()sf::SoundStreamvirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundStream.html b/Space-Invaders/sfml/doc/html/classsf_1_1SoundStream.html new file mode 100644 index 000000000..7865c7d3a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1SoundStream.html @@ -0,0 +1,1353 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +Protected Types | +Protected Member Functions | +Protected Attributes | +List of all members
+
sf::SoundStream Class Referenceabstract
Audio module
+
+
+ +

Abstract base class for streamed audio sources. + More...

+ +

#include <SFML/Audio/SoundStream.hpp>

+
+Inheritance diagram for sf::SoundStream:
+
+
+ + +sf::SoundSource +sf::AlResource +sf::Music + +
+ + + + + +

+Classes

struct  Chunk
 Structure defining a chunk of audio data to stream. More...
 
+ + + + +

+Public Types

enum  Status { Stopped +, Paused +, Playing + }
 Enumeration of the sound source states. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

virtual ~SoundStream ()
 Destructor.
 
void play ()
 Start or resume playing the audio stream.
 
void pause ()
 Pause the audio stream.
 
void stop ()
 Stop playing the audio stream.
 
unsigned int getChannelCount () const
 Return the number of channels of the stream.
 
unsigned int getSampleRate () const
 Get the stream sample rate of the stream.
 
Status getStatus () const
 Get the current status of the stream (stopped, paused, playing)
 
void setPlayingOffset (Time timeOffset)
 Change the current playing position of the stream.
 
Time getPlayingOffset () const
 Get the current playing position of the stream.
 
void setLoop (bool loop)
 Set whether or not the stream should loop after reaching the end.
 
bool getLoop () const
 Tell whether or not the stream is in loop mode.
 
void setPitch (float pitch)
 Set the pitch of the sound.
 
void setVolume (float volume)
 Set the volume of the sound.
 
void setPosition (float x, float y, float z)
 Set the 3D position of the sound in the audio scene.
 
void setPosition (const Vector3f &position)
 Set the 3D position of the sound in the audio scene.
 
void setRelativeToListener (bool relative)
 Make the sound's position relative to the listener or absolute.
 
void setMinDistance (float distance)
 Set the minimum distance of the sound.
 
void setAttenuation (float attenuation)
 Set the attenuation factor of the sound.
 
float getPitch () const
 Get the pitch of the sound.
 
float getVolume () const
 Get the volume of the sound.
 
Vector3f getPosition () const
 Get the 3D position of the sound in the audio scene.
 
bool isRelativeToListener () const
 Tell whether the sound's position is relative to the listener or is absolute.
 
float getMinDistance () const
 Get the minimum distance of the sound.
 
float getAttenuation () const
 Get the attenuation factor of the sound.
 
+ + + +

+Protected Types

enum  { NoLoop = -1 + }
 
+ + + + + + + + + + + + + + + + + + + +

+Protected Member Functions

 SoundStream ()
 Default constructor.
 
void initialize (unsigned int channelCount, unsigned int sampleRate)
 Define the audio stream parameters.
 
virtual bool onGetData (Chunk &data)=0
 Request a new chunk of audio samples from the stream source.
 
virtual void onSeek (Time timeOffset)=0
 Change the current playing position in the stream source.
 
virtual Int64 onLoop ()
 Change the current playing position in the stream source to the beginning of the loop.
 
void setProcessingInterval (Time interval)
 Set the processing interval.
 
+ + + + +

+Protected Attributes

unsigned int m_source
 OpenAL source identifier.
 
+

Detailed Description

+

Abstract base class for streamed audio sources.

+

Unlike audio buffers (see sf::SoundBuffer), audio streams are never completely loaded in memory.

+

Instead, the audio data is acquired continuously while the stream is playing. This behavior allows to play a sound with no loading delay, and keeps the memory consumption very low.

+

Sound sources that need to be streamed are usually big files (compressed audio musics that would eat hundreds of MB in memory) or files that would take a lot of time to be received (sounds played over the network).

+

sf::SoundStream is a base class that doesn't care about the stream source, which is left to the derived class. SFML provides a built-in specialization for big files (see sf::Music). No network stream source is provided, but you can write your own by combining this class with the network module.

+

A derived class has to override two virtual functions:

    +
  • onGetData fills a new chunk of audio data to be played
    • +
  • onSeek changes the current playing position in the source
    • +
+

It is important to note that each SoundStream is played in its own separate thread, so that the streaming loop doesn't block the rest of the program. In particular, the OnGetData and OnSeek virtual functions may sometimes be called from this separate thread. It is important to keep this in mind, because you may have to take care of synchronization issues if you share data between threads.

+

Usage example:

class CustomStream : public sf::SoundStream
+
{
+
public:
+
+
bool open(const std::string& location)
+
{
+
// Open the source and get audio settings
+
...
+
unsigned int channelCount = ...;
+
unsigned int sampleRate = ...;
+
+
// Initialize the stream -- important!
+
initialize(channelCount, sampleRate);
+
}
+
+
private:
+
+
virtual bool onGetData(Chunk& data)
+
{
+
// Fill the chunk with audio data from the stream source
+
// (note: must not be empty if you want to continue playing)
+
data.samples = ...;
+
data.sampleCount = ...;
+
+
// Return true to continue playing
+
return true;
+
}
+
+
virtual void onSeek(sf::Time timeOffset)
+
{
+
// Change the current position in the stream source
+
...
+
}
+
};
+
+
// Usage
+
CustomStream stream;
+
stream.open("path/to/stream");
+
stream.play();
+
sf::SoundStream
Abstract base class for streamed audio sources.
Definition: SoundStream.hpp:46
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
See also
sf::Music
+ +

Definition at line 45 of file SoundStream.hpp.

+

Member Enumeration Documentation

+ +

◆ anonymous enum

+ +
+
+ + + + + +
+ + + + +
anonymous enum
+ 		+protected
+
+ + +
Enumerator
NoLoop 

"Invalid" endSeeks value, telling us to continue uninterrupted

+
+ +

Definition at line 183 of file SoundStream.hpp.

+ +
+
+ +

◆ Status

+ +
+
+ + + + + +
+ + + + +
enum sf::SoundSource::Status
+ 		+inherited
+
+ +

Enumeration of the sound source states.

+ + + + +
Enumerator
Stopped 

Sound is not playing.

+
Paused 

Sound is paused.

+
Playing 

Sound is playing.

+
+ +

Definition at line 50 of file SoundSource.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ ~SoundStream()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::SoundStream::~SoundStream ()
+ 		+virtual
+
+ +

Destructor.

+ +
+
+ +

◆ SoundStream()

+ +
+
+ + + + + +
+ + + + + + + +
sf::SoundStream::SoundStream ()
+ 		+protected
+
+ +

Default constructor.

+

This constructor is only meant to be called by derived classes.

+ +
+
+

Member Function Documentation

+ +

◆ getAttenuation()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getAttenuation () const
+ 		+inherited
+
+ +

Get the attenuation factor of the sound.

+
Returns
Attenuation factor of the sound
+
See also
setAttenuation, getMinDistance
+ +
+
+ +

◆ getChannelCount()

+ +
+
+ + + + + + + +
unsigned int sf::SoundStream::getChannelCount () const
+
+ +

Return the number of channels of the stream.

+

1 channel means a mono sound, 2 means stereo, etc.

+
Returns
Number of channels
+ +
+
+ +

◆ getLoop()

+ +
+
+ + + + + + + +
bool sf::SoundStream::getLoop () const
+
+ +

Tell whether or not the stream is in loop mode.

+
Returns
True if the stream is looping, false otherwise
+
See also
setLoop
+ +
+
+ +

◆ getMinDistance()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getMinDistance () const
+ 		+inherited
+
+ +

Get the minimum distance of the sound.

+
Returns
Minimum distance of the sound
+
See also
setMinDistance, getAttenuation
+ +
+
+ +

◆ getPitch()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getPitch () const
+ 		+inherited
+
+ +

Get the pitch of the sound.

+
Returns
Pitch of the sound
+
See also
setPitch
+ +
+
+ +

◆ getPlayingOffset()

+ +
+
+ + + + + + + +
Time sf::SoundStream::getPlayingOffset () const
+
+ +

Get the current playing position of the stream.

+
Returns
Current playing position, from the beginning of the stream
+
See also
setPlayingOffset
+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
Vector3f sf::SoundSource::getPosition () const
+ 		+inherited
+
+ +

Get the 3D position of the sound in the audio scene.

+
Returns
Position of the sound
+
See also
setPosition
+ +
+
+ +

◆ getSampleRate()

+ +
+
+ + + + + + + +
unsigned int sf::SoundStream::getSampleRate () const
+
+ +

Get the stream sample rate of the stream.

+

The sample rate is the number of audio samples played per second. The higher, the better the quality.

+
Returns
Sample rate, in number of samples per second
+ +
+
+ +

◆ getStatus()

+ +
+
+ + + + + +
+ + + + + + + +
Status sf::SoundStream::getStatus () const
+ 		+virtual
+
+ +

Get the current status of the stream (stopped, paused, playing)

+
Returns
Current status
+ +

Reimplemented from sf::SoundSource.

+ +
+
+ +

◆ getVolume()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::SoundSource::getVolume () const
+ 		+inherited
+
+ +

Get the volume of the sound.

+
Returns
Volume of the sound, in the range [0, 100]
+
See also
setVolume
+ +
+
+ +

◆ initialize()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::SoundStream::initialize (unsigned int channelCount,
unsigned int sampleRate 
)
+ 		+protected
+
+ +

Define the audio stream parameters.

+

This function must be called by derived classes as soon as they know the audio settings of the stream to play. Any attempt to manipulate the stream (play(), ...) before calling this function will fail. It can be called multiple times if the settings of the audio stream change, but only when the stream is stopped.

+
Parameters
+ + + +
channelCountNumber of channels of the stream
sampleRateSample rate, in samples per second
+
+
+ +
+
+ +

◆ isRelativeToListener()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::SoundSource::isRelativeToListener () const
+ 		+inherited
+
+ +

Tell whether the sound's position is relative to the listener or is absolute.

+
Returns
True if the position is relative, false if it's absolute
+
See also
setRelativeToListener
+ +
+
+ +

◆ onGetData()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual bool sf::SoundStream::onGetData (Chunk & data)
+ 		+protectedpure virtual
+
+ +

Request a new chunk of audio samples from the stream source.

+

This function must be overridden by derived classes to provide the audio samples to play. It is called continuously by the streaming loop, in a separate thread. The source can choose to stop the streaming loop at any time, by returning false to the caller. If you return true (i.e. continue streaming) it is important that the returned array of samples is not empty; this would stop the stream due to an internal limitation.

+
Parameters
+ + +
dataChunk of data to fill
+
+
+
Returns
True to continue playback, false to stop
+ +

Implemented in sf::Music.

+ +
+
+ +

◆ onLoop()

+ +
+
+ + + + + +
+ + + + + + + +
virtual Int64 sf::SoundStream::onLoop ()
+ 		+protectedvirtual
+
+ +

Change the current playing position in the stream source to the beginning of the loop.

+

This function can be overridden by derived classes to allow implementation of custom loop points. Otherwise, it just calls onSeek(Time::Zero) and returns 0.

+
Returns
The seek position after looping (or -1 if there's no loop)
+ +

Reimplemented in sf::Music.

+ +
+
+ +

◆ onSeek()

+ +
+
+ + + + + +
+ + + + + + + + +
virtual void sf::SoundStream::onSeek (Time timeOffset)
+ 		+protectedpure virtual
+
+ +

Change the current playing position in the stream source.

+

This function must be overridden by derived classes to allow random seeking into the stream source.

+
Parameters
+ + +
timeOffsetNew playing position, relative to the beginning of the stream
+
+
+ +

Implemented in sf::Music.

+ +
+
+ +

◆ pause()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::SoundStream::pause ()
+ 		+virtual
+
+ +

Pause the audio stream.

+

This function pauses the stream if it was playing, otherwise (stream already paused or stopped) it has no effect.

+
See also
play, stop
+ +

Implements sf::SoundSource.

+ +
+
+ +

◆ play()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::SoundStream::play ()
+ 		+virtual
+
+ +

Start or resume playing the audio stream.

+

This function starts the stream if it was stopped, resumes it if it was paused, and restarts it from the beginning if it was already playing. This function uses its own thread so that it doesn't block the rest of the program while the stream is played.

+
See also
pause, stop
+ +

Implements sf::SoundSource.

+ +
+
+ +

◆ setAttenuation()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setAttenuation (float attenuation)
+ 		+inherited
+
+ +

Set the attenuation factor of the sound.

+

The attenuation is a multiplicative factor which makes the sound more or less loud according to its distance from the listener. An attenuation of 0 will produce a non-attenuated sound, i.e. its volume will always be the same whether it is heard from near or from far. On the other hand, an attenuation value such as 100 will make the sound fade out very quickly as it gets further from the listener. The default value of the attenuation is 1.

+
Parameters
+ + +
attenuationNew attenuation factor of the sound
+
+
+
See also
getAttenuation, setMinDistance
+ +
+
+ +

◆ setLoop()

+ +
+
+ + + + + + + + +
void sf::SoundStream::setLoop (bool loop)
+
+ +

Set whether or not the stream should loop after reaching the end.

+

If set, the stream will restart from beginning after reaching the end and so on, until it is stopped or setLoop(false) is called. The default looping state for streams is false.

+
Parameters
+ + +
loopTrue to play in loop, false to play once
+
+
+
See also
getLoop
+ +
+
+ +

◆ setMinDistance()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setMinDistance (float distance)
+ 		+inherited
+
+ +

Set the minimum distance of the sound.

+

The "minimum distance" of a sound is the maximum distance at which it is heard at its maximum volume. Further than the minimum distance, it will start to fade out according to its attenuation factor. A value of 0 ("inside the head +of the listener") is an invalid value and is forbidden. The default value of the minimum distance is 1.

+
Parameters
+ + +
distanceNew minimum distance of the sound
+
+
+
See also
getMinDistance, setAttenuation
+ +
+
+ +

◆ setPitch()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setPitch (float pitch)
+ 		+inherited
+
+ +

Set the pitch of the sound.

+

The pitch represents the perceived fundamental frequency of a sound; thus you can make a sound more acute or grave by changing its pitch. A side effect of changing the pitch is to modify the playing speed of the sound as well. The default value for the pitch is 1.

+
Parameters
+ + +
pitchNew pitch to apply to the sound
+
+
+
See also
getPitch
+ +
+
+ +

◆ setPlayingOffset()

+ +
+
+ + + + + + + + +
void sf::SoundStream::setPlayingOffset (Time timeOffset)
+
+ +

Change the current playing position of the stream.

+

The playing position can be changed when the stream is either paused or playing. Changing the playing position when the stream is stopped has no effect, since playing the stream would reset its position.

+
Parameters
+ + +
timeOffsetNew playing position, from the beginning of the stream
+
+
+
See also
getPlayingOffset
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setPosition (const Vector3f & position)
+ 		+inherited
+
+ +

Set the 3D position of the sound in the audio scene.

+

Only sounds with one channel (mono sounds) can be spatialized. The default position of a sound is (0, 0, 0).

+
Parameters
+ + +
positionPosition of the sound in the scene
+
+
+
See also
getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::SoundSource::setPosition (float x,
float y,
float z 
)
+ 		+inherited
+
+ +

Set the 3D position of the sound in the audio scene.

+

Only sounds with one channel (mono sounds) can be spatialized. The default position of a sound is (0, 0, 0).

+
Parameters
+ + + + +
xX coordinate of the position of the sound in the scene
yY coordinate of the position of the sound in the scene
zZ coordinate of the position of the sound in the scene
+
+
+
See also
getPosition
+ +
+
+ +

◆ setProcessingInterval()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundStream::setProcessingInterval (Time interval)
+ 		+protected
+
+ +

Set the processing interval.

+

The processing interval controls the period at which the audio buffers are filled by calls to onGetData. A smaller interval may be useful for low-latency streams. Note that the given period is only a hint and the actual period may vary. The default processing interval is 10 ms.

+
Parameters
+ + +
intervalProcessing interval
+
+
+ +
+
+ +

◆ setRelativeToListener()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setRelativeToListener (bool relative)
+ 		+inherited
+
+ +

Make the sound's position relative to the listener or absolute.

+

Making a sound relative to the listener will ensure that it will always be played the same way regardless of the position of the listener. This can be useful for non-spatialized sounds, sounds that are produced by the listener, or sounds attached to it. The default value is false (position is absolute).

+
Parameters
+ + +
relativeTrue to set the position relative, false to set it absolute
+
+
+
See also
isRelativeToListener
+ +
+
+ +

◆ setVolume()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::SoundSource::setVolume (float volume)
+ 		+inherited
+
+ +

Set the volume of the sound.

+

The volume is a value between 0 (mute) and 100 (full volume). The default value for the volume is 100.

+
Parameters
+ + +
volumeVolume of the sound
+
+
+
See also
getVolume
+ +
+
+ +

◆ stop()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::SoundStream::stop ()
+ 		+virtual
+
+ +

Stop playing the audio stream.

+

This function stops the stream if it was playing or paused, and does nothing if it was already stopped. It also resets the playing position (unlike pause()).

+
See also
play, pause
+ +

Implements sf::SoundSource.

+ +
+
+

Member Data Documentation

+ +

◆ m_source

+ +
+
+ + + + + +
+ + + + +
unsigned int sf::SoundSource::m_source
+ 		+protectedinherited
+
+ +

OpenAL source identifier.

+ +

Definition at line 309 of file SoundSource.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1SoundStream.png b/Space-Invaders/sfml/doc/html/classsf_1_1SoundStream.png new file mode 100644 index 000000000..11618a560 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1SoundStream.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Sprite-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Sprite-members.html new file mode 100644 index 000000000..97fe377bd --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Sprite-members.html @@ -0,0 +1,140 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Sprite Member List
+
+
+ +

This is the complete list of members for sf::Sprite, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
getColor() constsf::Sprite
getGlobalBounds() constsf::Sprite
getInverseTransform() constsf::Transformable
getLocalBounds() constsf::Sprite
getOrigin() constsf::Transformable
getPosition() constsf::Transformable
getRotation() constsf::Transformable
getScale() constsf::Transformable
getTexture() constsf::Sprite
getTextureRect() constsf::Sprite
getTransform() constsf::Transformable
move(float offsetX, float offsetY)sf::Transformable
move(const Vector2f &offset)sf::Transformable
rotate(float angle)sf::Transformable
scale(float factorX, float factorY)sf::Transformable
scale(const Vector2f &factor)sf::Transformable
setColor(const Color &color)sf::Sprite
setOrigin(float x, float y)sf::Transformable
setOrigin(const Vector2f &origin)sf::Transformable
setPosition(float x, float y)sf::Transformable
setPosition(const Vector2f &position)sf::Transformable
setRotation(float angle)sf::Transformable
setScale(float factorX, float factorY)sf::Transformable
setScale(const Vector2f &factors)sf::Transformable
setTexture(const Texture &texture, bool resetRect=false)sf::Sprite
setTextureRect(const IntRect &rectangle)sf::Sprite
Sprite()sf::Sprite
Sprite(const Texture &texture)sf::Spriteexplicit
Sprite(const Texture &texture, const IntRect &rectangle)sf::Sprite
Transformable()sf::Transformable
~Drawable()sf::Drawableinlinevirtual
~Transformable()sf::Transformablevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Sprite.html b/Space-Invaders/sfml/doc/html/classsf_1_1Sprite.html new file mode 100644 index 000000000..0773c7ce7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Sprite.html @@ -0,0 +1,1216 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::Sprite Class Reference
Graphics module
+
+
+ +

Drawable representation of a texture, with its own transformations, color, etc. + More...

+ +

#include <SFML/Graphics/Sprite.hpp>

+
+Inheritance diagram for sf::Sprite:
+
+
+ + +sf::Drawable +sf::Transformable + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Sprite ()
 Default constructor.
 
 Sprite (const Texture &texture)
 Construct the sprite from a source texture.
 
 Sprite (const Texture &texture, const IntRect &rectangle)
 Construct the sprite from a sub-rectangle of a source texture.
 
void setTexture (const Texture &texture, bool resetRect=false)
 Change the source texture of the sprite.
 
void setTextureRect (const IntRect &rectangle)
 Set the sub-rectangle of the texture that the sprite will display.
 
void setColor (const Color &color)
 Set the global color of the sprite.
 
const Texture * getTexture () const
 Get the source texture of the sprite.
 
const IntRect & getTextureRect () const
 Get the sub-rectangle of the texture displayed by the sprite.
 
const Color & getColor () const
 Get the global color of the sprite.
 
FloatRect getLocalBounds () const
 Get the local bounding rectangle of the entity.
 
FloatRect getGlobalBounds () const
 Get the global bounding rectangle of the entity.
 
void setPosition (float x, float y)
 set the position of the object
 
void setPosition (const Vector2f &position)
 set the position of the object
 
void setRotation (float angle)
 set the orientation of the object
 
void setScale (float factorX, float factorY)
 set the scale factors of the object
 
void setScale (const Vector2f &factors)
 set the scale factors of the object
 
void setOrigin (float x, float y)
 set the local origin of the object
 
void setOrigin (const Vector2f &origin)
 set the local origin of the object
 
const Vector2f & getPosition () const
 get the position of the object
 
float getRotation () const
 get the orientation of the object
 
const Vector2f & getScale () const
 get the current scale of the object
 
const Vector2f & getOrigin () const
 get the local origin of the object
 
void move (float offsetX, float offsetY)
 Move the object by a given offset.
 
void move (const Vector2f &offset)
 Move the object by a given offset.
 
void rotate (float angle)
 Rotate the object.
 
void scale (float factorX, float factorY)
 Scale the object.
 
void scale (const Vector2f &factor)
 Scale the object.
 
const Transform & getTransform () const
 get the combined transform of the object
 
const Transform & getInverseTransform () const
 get the inverse of the combined transform of the object
 
+

Detailed Description

+

Drawable representation of a texture, with its own transformations, color, etc.

+

sf::Sprite is a drawable class that allows to easily display a texture (or a part of it) on a render target.

+

It inherits all the functions from sf::Transformable: position, rotation, scale, origin. It also adds sprite-specific properties such as the texture to use, the part of it to display, and some convenience functions to change the overall color of the sprite, or to get its bounding rectangle.

+

sf::Sprite works in combination with the sf::Texture class, which loads and provides the pixel data of a given texture.

+

The separation of sf::Sprite and sf::Texture allows more flexibility and better performances: indeed a sf::Texture is a heavy resource, and any operation on it is slow (often too slow for real-time applications). On the other side, a sf::Sprite is a lightweight object which can use the pixel data of a sf::Texture and draw it with its own transformation/color/blending attributes.

+

It is important to note that the sf::Sprite instance doesn't copy the texture that it uses, it only keeps a reference to it. Thus, a sf::Texture must not be destroyed while it is used by a sf::Sprite (i.e. never write a function that uses a local sf::Texture instance for creating a sprite).

+

See also the note on coordinates and undistorted rendering in sf::Transformable.

+

Usage example:

// Declare and load a texture
+
sf::Texture texture;
+
texture.loadFromFile("texture.png");
+
+
// Create a sprite
+
sf::Sprite sprite;
+
sprite.setTexture(texture);
+
sprite.setTextureRect(sf::IntRect(10, 10, 50, 30));
+
sprite.setColor(sf::Color(255, 255, 255, 200));
+
sprite.setPosition(100, 25);
+
+
// Draw it
+
window.draw(sprite);
+
sf::Color
Utility class for manipulating RGBA colors.
Definition: Color.hpp:41
+ +
sf::Sprite
Drawable representation of a texture, with its own transformations, color, etc.
Definition: Sprite.hpp:48
+
sf::Sprite::setColor
void setColor(const Color &color)
Set the global color of the sprite.
+
sf::Sprite::setTexture
void setTexture(const Texture &texture, bool resetRect=false)
Change the source texture of the sprite.
+
sf::Sprite::setTextureRect
void setTextureRect(const IntRect &rectangle)
Set the sub-rectangle of the texture that the sprite will display.
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Texture::loadFromFile
bool loadFromFile(const std::string &filename, const IntRect &area=IntRect())
Load the texture from a file on disk.
+
sf::Transformable::setPosition
void setPosition(float x, float y)
set the position of the object
+
See also
sf::Texture, sf::Transformable
+ +

Definition at line 47 of file Sprite.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Sprite() [1/3]

+ +
+
+ + + + + + + +
sf::Sprite::Sprite ()
+
+ +

Default constructor.

+

Creates an empty sprite with no source texture.

+ +
+
+ +

◆ Sprite() [2/3]

+ +
+
+ + + + + +
+ + + + + + + + +
sf::Sprite::Sprite (const Texture & texture)
+ 		+explicit
+
+ +

Construct the sprite from a source texture.

+
Parameters
+ + +
textureSource texture
+
+
+
See also
setTexture
+ +
+
+ +

◆ Sprite() [3/3]

+ +
+
+ + + + + + + + + + + + + + + + + + +
sf::Sprite::Sprite (const Texture & texture,
const IntRect & rectangle 
)
+
+ +

Construct the sprite from a sub-rectangle of a source texture.

+
Parameters
+ + + +
textureSource texture
rectangleSub-rectangle of the texture to assign to the sprite
+
+
+
See also
setTexture, setTextureRect
+ +
+
+

Member Function Documentation

+ +

◆ getColor()

+ +
+
+ + + + + + + +
const Color & sf::Sprite::getColor () const
+
+ +

Get the global color of the sprite.

+
Returns
Global color of the sprite
+
See also
setColor
+ +
+
+ +

◆ getGlobalBounds()

+ +
+
+ + + + + + + +
FloatRect sf::Sprite::getGlobalBounds () const
+
+ +

Get the global bounding rectangle of the entity.

+

The returned rectangle is in global coordinates, which means that it takes into account the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the sprite in the global 2D world's coordinate system.

+
Returns
Global bounding rectangle of the entity
+ +
+
+ +

◆ getInverseTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getInverseTransform () const
+ 		+inherited
+
+ +

get the inverse of the combined transform of the object

+
Returns
Inverse of the combined transformations applied to the object
+
See also
getTransform
+ +
+
+ +

◆ getLocalBounds()

+ +
+
+ + + + + + + +
FloatRect sf::Sprite::getLocalBounds () const
+
+ +

Get the local bounding rectangle of the entity.

+

The returned rectangle is in local coordinates, which means that it ignores the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the entity in the entity's coordinate system.

+
Returns
Local bounding rectangle of the entity
+ +
+
+ +

◆ getOrigin()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getOrigin () const
+ 		+inherited
+
+ +

get the local origin of the object

+
Returns
Current origin
+
See also
setOrigin
+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getPosition () const
+ 		+inherited
+
+ +

get the position of the object

+
Returns
Current position
+
See also
setPosition
+ +
+
+ +

◆ getRotation()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::Transformable::getRotation () const
+ 		+inherited
+
+ +

get the orientation of the object

+

The rotation is always in the range [0, 360].

+
Returns
Current rotation, in degrees
+
See also
setRotation
+ +
+
+ +

◆ getScale()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getScale () const
+ 		+inherited
+
+ +

get the current scale of the object

+
Returns
Current scale factors
+
See also
setScale
+ +
+
+ +

◆ getTexture()

+ +
+
+ + + + + + + +
const Texture * sf::Sprite::getTexture () const
+
+ +

Get the source texture of the sprite.

+

If the sprite has no source texture, a NULL pointer is returned. The returned pointer is const, which means that you can't modify the texture when you retrieve it with this function.

+
Returns
Pointer to the sprite's texture
+
See also
setTexture
+ +
+
+ +

◆ getTextureRect()

+ +
+
+ + + + + + + +
const IntRect & sf::Sprite::getTextureRect () const
+
+ +

Get the sub-rectangle of the texture displayed by the sprite.

+
Returns
Texture rectangle of the sprite
+
See also
setTextureRect
+ +
+
+ +

◆ getTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getTransform () const
+ 		+inherited
+
+ +

get the combined transform of the object

+
Returns
Transform combining the position/rotation/scale/origin of the object
+
See also
getInverseTransform
+ +
+
+ +

◆ move() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::move (const Vector2f & offset)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

object.setPosition(object.getPosition() + offset);
+
sf::Transformable::getPosition
const Vector2f & getPosition() const
get the position of the object
+
Parameters
+ + +
offsetOffset
+
+
+
See also
setPosition
+ +
+
+ +

◆ move() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::move (float offsetX,
float offsetY 
)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f pos = object.getPosition();
+
object.setPosition(pos.x + offsetX, pos.y + offsetY);
+ +
sf::Vector2::x
T x
X coordinate of the vector.
Definition: Vector2.hpp:75
+
sf::Vector2::y
T y
Y coordinate of the vector.
Definition: Vector2.hpp:76
+
Parameters
+ + + +
offsetXX offset
offsetYY offset
+
+
+
See also
setPosition
+ +
+
+ +

◆ rotate()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::rotate (float angle)
+ 		+inherited
+
+ +

Rotate the object.

+

This function adds to the current rotation of the object, unlike setRotation which overwrites it. Thus, it is equivalent to the following code:

object.setRotation(object.getRotation() + angle);
+
sf::Transformable::getRotation
float getRotation() const
get the orientation of the object
+
Parameters
+ + +
angleAngle of rotation, in degrees
+
+
+ +
+
+ +

◆ scale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::scale (const Vector2f & factor)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factor.x, scale.y * factor.y);
+
sf::Transformable::scale
void scale(float factorX, float factorY)
Scale the object.
+
Parameters
+ + +
factorScale factors
+
+
+
See also
setScale
+ +
+
+ +

◆ scale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::scale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factorX, scale.y * factorY);
+
Parameters
+ + + +
factorXHorizontal scale factor
factorYVertical scale factor
+
+
+
See also
setScale
+ +
+
+ +

◆ setColor()

+ +
+
+ + + + + + + + +
void sf::Sprite::setColor (const Color & color)
+
+ +

Set the global color of the sprite.

+

This color is modulated (multiplied) with the sprite's texture. It can be used to colorize the sprite, or change its global opacity. By default, the sprite's color is opaque white.

+
Parameters
+ + +
colorNew color of the sprite
+
+
+
See also
getColor
+ +
+
+ +

◆ setOrigin() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setOrigin (const Vector2f & origin)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + +
originNew origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOrigin() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setOrigin (float x,
float y 
)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new origin
yY coordinate of the new origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setPosition (const Vector2f & position)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + +
positionNew position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setPosition (float x,
float y 
)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new position
yY coordinate of the new position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setRotation()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setRotation (float angle)
+ 		+inherited
+
+ +

set the orientation of the object

+

This function completely overwrites the previous rotation. See the rotate function to add an angle based on the previous rotation instead. The default rotation of a transformable object is 0.

+
Parameters
+ + +
angleNew rotation, in degrees
+
+
+
See also
rotate, getRotation
+ +
+
+ +

◆ setScale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setScale (const Vector2f & factors)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + +
factorsNew scale factors
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setScale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setScale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + + +
factorXNew horizontal scale factor
factorYNew vertical scale factor
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setTexture()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Sprite::setTexture (const Texture & texture,
bool resetRect = false 
)
+
+ +

Change the source texture of the sprite.

+

The texture argument refers to a texture that must exist as long as the sprite uses it. Indeed, the sprite doesn't store its own copy of the texture, but rather keeps a pointer to the one that you passed to this function. If the source texture is destroyed and the sprite tries to use it, the behavior is undefined. If resetRect is true, the TextureRect property of the sprite is automatically adjusted to the size of the new texture. If it is false, the texture rect is left unchanged.

+
Parameters
+ + + +
textureNew texture
resetRectShould the texture rect be reset to the size of the new texture?
+
+
+
See also
getTexture, setTextureRect
+ +
+
+ +

◆ setTextureRect()

+ +
+
+ + + + + + + + +
void sf::Sprite::setTextureRect (const IntRect & rectangle)
+
+ +

Set the sub-rectangle of the texture that the sprite will display.

+

The texture rect is useful when you don't want to display the whole texture, but rather a part of it. By default, the texture rect covers the entire texture.

+
Parameters
+ + +
rectangleRectangle defining the region of the texture to display
+
+
+
See also
getTextureRect, setTexture
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Sprite.png b/Space-Invaders/sfml/doc/html/classsf_1_1Sprite.png new file mode 100644 index 000000000..55357f901 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Sprite.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1String-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1String-members.html new file mode 100644 index 000000000..76957c8c6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1String-members.html @@ -0,0 +1,159 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::String Member List
+
+
+ +

This is the complete list of members for sf::String, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
begin()sf::String
begin() constsf::String
clear()sf::String
ConstIterator typedefsf::String
end()sf::String
end() constsf::String
erase(std::size_t position, std::size_t count=1)sf::String
find(const String &str, std::size_t start=0) constsf::String
fromUtf16(T begin, T end)sf::Stringstatic
fromUtf32(T begin, T end)sf::Stringstatic
fromUtf8(T begin, T end)sf::Stringstatic
getData() constsf::String
getSize() constsf::String
insert(std::size_t position, const String &str)sf::String
InvalidPossf::Stringstatic
isEmpty() constsf::String
Iterator typedefsf::String
operator std::string() constsf::String
operator std::wstring() constsf::String
operator!=(const String &left, const String &right)sf::Stringrelated
operator+(const String &left, const String &right)sf::Stringrelated
operator+=(const String &right)sf::String
operator< (defined in sf::String)sf::Stringfriend
operator<(const String &left, const String &right)sf::Stringrelated
operator<=(const String &left, const String &right)sf::Stringrelated
operator=(const String &right)sf::String
operator== (defined in sf::String)sf::Stringfriend
operator==(const String &left, const String &right)sf::Stringrelated
operator>(const String &left, const String &right)sf::Stringrelated
operator>=(const String &left, const String &right)sf::Stringrelated
operator[](std::size_t index) constsf::String
operator[](std::size_t index)sf::String
replace(std::size_t position, std::size_t length, const String &replaceWith)sf::String
replace(const String &searchFor, const String &replaceWith)sf::String
String()sf::String
String(char ansiChar, const std::locale &locale=std::locale())sf::String
String(wchar_t wideChar)sf::String
String(Uint32 utf32Char)sf::String
String(const char *ansiString, const std::locale &locale=std::locale())sf::String
String(const std::string &ansiString, const std::locale &locale=std::locale())sf::String
String(const wchar_t *wideString)sf::String
String(const std::wstring &wideString)sf::String
String(const Uint32 *utf32String)sf::String
String(const std::basic_string< Uint32 > &utf32String)sf::String
String(const String &copy)sf::String
substring(std::size_t position, std::size_t length=InvalidPos) constsf::String
toAnsiString(const std::locale &locale=std::locale()) constsf::String
toUtf16() constsf::String
toUtf32() constsf::String
toUtf8() constsf::String
toWideString() constsf::String
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1String.html b/Space-Invaders/sfml/doc/html/classsf_1_1String.html new file mode 100644 index 000000000..a02db0f46 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1String.html @@ -0,0 +1,1851 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Static Public Member Functions | +Static Public Attributes | +Friends | +Related Functions | +List of all members
+
sf::String Class Reference
System module
+
+
+ +

Utility string class that automatically handles conversions between types and encodings. + More...

+ +

#include <SFML/System/String.hpp>

+ + + + + + + + +

+Public Types

typedef std::basic_string< Uint32 >::iterator Iterator
 Iterator type.
 
typedef std::basic_string< Uint32 >::const_iterator ConstIterator
 Read-only iterator type.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 String ()
 Default constructor.
 
 String (char ansiChar, const std::locale &locale=std::locale())
 Construct from a single ANSI character and a locale.
 
 String (wchar_t wideChar)
 Construct from single wide character.
 
 String (Uint32 utf32Char)
 Construct from single UTF-32 character.
 
 String (const char *ansiString, const std::locale &locale=std::locale())
 Construct from a null-terminated C-style ANSI string and a locale.
 
 String (const std::string &ansiString, const std::locale &locale=std::locale())
 Construct from an ANSI string and a locale.
 
 String (const wchar_t *wideString)
 Construct from null-terminated C-style wide string.
 
 String (const std::wstring &wideString)
 Construct from a wide string.
 
 String (const Uint32 *utf32String)
 Construct from a null-terminated C-style UTF-32 string.
 
 String (const std::basic_string< Uint32 > &utf32String)
 Construct from an UTF-32 string.
 
 String (const String &copy)
 Copy constructor.
 
 operator std::string () const
 Implicit conversion operator to std::string (ANSI string)
 
 operator std::wstring () const
 Implicit conversion operator to std::wstring (wide string)
 
std::string toAnsiString (const std::locale &locale=std::locale()) const
 Convert the Unicode string to an ANSI string.
 
std::wstring toWideString () const
 Convert the Unicode string to a wide string.
 
std::basic_string< Uint8 > toUtf8 () const
 Convert the Unicode string to a UTF-8 string.
 
std::basic_string< Uint16 > toUtf16 () const
 Convert the Unicode string to a UTF-16 string.
 
std::basic_string< Uint32 > toUtf32 () const
 Convert the Unicode string to a UTF-32 string.
 
String & operator= (const String &right)
 Overload of assignment operator.
 
String & operator+= (const String &right)
 Overload of += operator to append an UTF-32 string.
 
Uint32 operator[] (std::size_t index) const
 Overload of [] operator to access a character by its position.
 
Uint32 & operator[] (std::size_t index)
 Overload of [] operator to access a character by its position.
 
void clear ()
 Clear the string.
 
std::size_t getSize () const
 Get the size of the string.
 
bool isEmpty () const
 Check whether the string is empty or not.
 
void erase (std::size_t position, std::size_t count=1)
 Erase one or more characters from the string.
 
void insert (std::size_t position, const String &str)
 Insert one or more characters into the string.
 
std::size_t find (const String &str, std::size_t start=0) const
 Find a sequence of one or more characters in the string.
 
void replace (std::size_t position, std::size_t length, const String &replaceWith)
 Replace a substring with another string.
 
void replace (const String &searchFor, const String &replaceWith)
 Replace all occurrences of a substring with a replacement string.
 
String substring (std::size_t position, std::size_t length=InvalidPos) const
 Return a part of the string.
 
const Uint32 * getData () const
 Get a pointer to the C-style array of characters.
 
Iterator begin ()
 Return an iterator to the beginning of the string.
 
ConstIterator begin () const
 Return an iterator to the beginning of the string.
 
Iterator end ()
 Return an iterator to the end of the string.
 
ConstIterator end () const
 Return an iterator to the end of the string.
 
+ + + + + + + + + + + + + +

+Static Public Member Functions

template<typename T >
static String fromUtf8 (T begin, T end)
 Create a new sf::String from a UTF-8 encoded string.
 
template<typename T >
static String fromUtf16 (T begin, T end)
 Create a new sf::String from a UTF-16 encoded string.
 
template<typename T >
static String fromUtf32 (T begin, T end)
 Create a new sf::String from a UTF-32 encoded string.
 
+ + + + +

+Static Public Attributes

static const std::size_t InvalidPos
 Represents an invalid position in the string.
 
+ + + + + +

+Friends

+bool operator== (const String &left, const String &right)
 
+bool operator< (const String &left, const String &right)
 
+ + + + + + + + + + + + + + + + + + + + + + + +

+Related Functions

(Note that these are not member functions.)

+
bool operator== (const String &left, const String &right)
 Overload of == operator to compare two UTF-32 strings.
 
bool operator!= (const String &left, const String &right)
 Overload of != operator to compare two UTF-32 strings.
 
bool operator< (const String &left, const String &right)
 Overload of < operator to compare two UTF-32 strings.
 
bool operator> (const String &left, const String &right)
 Overload of > operator to compare two UTF-32 strings.
 
bool operator<= (const String &left, const String &right)
 Overload of <= operator to compare two UTF-32 strings.
 
bool operator>= (const String &left, const String &right)
 Overload of >= operator to compare two UTF-32 strings.
 
String operator+ (const String &left, const String &right)
 Overload of binary + operator to concatenate two strings.
 
+

Detailed Description

+

Utility string class that automatically handles conversions between types and encodings.

+

sf::String is a utility string class defined mainly for convenience.

+

It is a Unicode string (implemented using UTF-32), thus it can store any character in the world (European, Chinese, Arabic, Hebrew, etc.).

+

It automatically handles conversions from/to ANSI and wide strings, so that you can work with standard string classes and still be compatible with functions taking a sf::String.

+
sf::String s;
+
+
std::string s1 = s; // automatically converted to ANSI string
+
std::wstring s2 = s; // automatically converted to wide string
+
s = "hello"; // automatically converted from ANSI string
+
s = L"hello"; // automatically converted from wide string
+
s += 'a'; // automatically converted from ANSI string
+
s += L'a'; // automatically converted from wide string
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+

Conversions involving ANSI strings use the default user locale. However it is possible to use a custom locale if necessary:

std::locale locale;
+
sf::String s;
+
...
+
std::string s1 = s.toAnsiString(locale);
+
s = sf::String("hello", locale);
+
sf::String::toAnsiString
std::string toAnsiString(const std::locale &locale=std::locale()) const
Convert the Unicode string to an ANSI string.
+

sf::String defines the most important functions of the standard std::string class: removing, random access, iterating, appending, comparing, etc. However it is a simple class provided for convenience, and you may have to consider using a more optimized class if your program requires complex string handling. The automatic conversion functions will then take care of converting your string to sf::String whenever SFML requires it.

+

Please note that SFML also defines a low-level, generic interface for Unicode handling, see the sf::Utf classes.

+ +

Definition at line 45 of file String.hpp.

+

Member Typedef Documentation

+ +

◆ ConstIterator

+ +
+
+ + + + +
typedef std::basic_string<Uint32>::const_iterator sf::String::ConstIterator
+
+ +

Read-only iterator type.

+ +

Definition at line 53 of file String.hpp.

+ +
+
+ +

◆ Iterator

+ +
+
+ + + + +
typedef std::basic_string<Uint32>::iterator sf::String::Iterator
+
+ +

Iterator type.

+ +

Definition at line 52 of file String.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ String() [1/11]

+ +
+
+ + + + + + + +
sf::String::String ()
+
+ +

Default constructor.

+

This constructor creates an empty string.

+ +
+
+ +

◆ String() [2/11]

+ +
+
+ + + + + + + + + + + + + + + + + + +
sf::String::String (char ansiChar,
const std::locale & locale = std::locale() 
)
+
+ +

Construct from a single ANSI character and a locale.

+

The source character is converted to UTF-32 according to the given locale.

+
Parameters
+ + + +
ansiCharANSI character to convert
localeLocale to use for conversion
+
+
+ +
+
+ +

◆ String() [3/11]

+ +
+
+ + + + + + + + +
sf::String::String (wchar_t wideChar)
+
+ +

Construct from single wide character.

+
Parameters
+ + +
wideCharWide character to convert
+
+
+ +
+
+ +

◆ String() [4/11]

+ +
+
+ + + + + + + + +
sf::String::String (Uint32 utf32Char)
+
+ +

Construct from single UTF-32 character.

+
Parameters
+ + +
utf32CharUTF-32 character to convert
+
+
+ +
+
+ +

◆ String() [5/11]

+ +
+
+ + + + + + + + + + + + + + + + + + +
sf::String::String (const char * ansiString,
const std::locale & locale = std::locale() 
)
+
+ +

Construct from a null-terminated C-style ANSI string and a locale.

+

The source string is converted to UTF-32 according to the given locale.

+
Parameters
+ + + +
ansiStringANSI string to convert
localeLocale to use for conversion
+
+
+ +
+
+ +

◆ String() [6/11]

+ +
+
+ + + + + + + + + + + + + + + + + + +
sf::String::String (const std::string & ansiString,
const std::locale & locale = std::locale() 
)
+
+ +

Construct from an ANSI string and a locale.

+

The source string is converted to UTF-32 according to the given locale.

+
Parameters
+ + + +
ansiStringANSI string to convert
localeLocale to use for conversion
+
+
+ +
+
+ +

◆ String() [7/11]

+ +
+
+ + + + + + + + +
sf::String::String (const wchar_t * wideString)
+
+ +

Construct from null-terminated C-style wide string.

+
Parameters
+ + +
wideStringWide string to convert
+
+
+ +
+
+ +

◆ String() [8/11]

+ +
+
+ + + + + + + + +
sf::String::String (const std::wstring & wideString)
+
+ +

Construct from a wide string.

+
Parameters
+ + +
wideStringWide string to convert
+
+
+ +
+
+ +

◆ String() [9/11]

+ +
+
+ + + + + + + + +
sf::String::String (const Uint32 * utf32String)
+
+ +

Construct from a null-terminated C-style UTF-32 string.

+
Parameters
+ + +
utf32StringUTF-32 string to assign
+
+
+ +
+
+ +

◆ String() [10/11]

+ +
+
+ + + + + + + + +
sf::String::String (const std::basic_string< Uint32 > & utf32String)
+
+ +

Construct from an UTF-32 string.

+
Parameters
+ + +
utf32StringUTF-32 string to assign
+
+
+ +
+
+ +

◆ String() [11/11]

+ +
+
+ + + + + + + + +
sf::String::String (const String & copy)
+
+ +

Copy constructor.

+
Parameters
+ + +
copyInstance to copy
+
+
+ +
+
+

Member Function Documentation

+ +

◆ begin() [1/2]

+ +
+
+ + + + + + + +
Iterator sf::String::begin ()
+
+ +

Return an iterator to the beginning of the string.

+
Returns
Read-write iterator to the beginning of the string characters
+
See also
end
+ +
+
+ +

◆ begin() [2/2]

+ +
+
+ + + + + + + +
ConstIterator sf::String::begin () const
+
+ +

Return an iterator to the beginning of the string.

+
Returns
Read-only iterator to the beginning of the string characters
+
See also
end
+ +
+
+ +

◆ clear()

+ +
+
+ + + + + + + +
void sf::String::clear ()
+
+ +

Clear the string.

+

This function removes all the characters from the string.

+
See also
isEmpty, erase
+ +
+
+ +

◆ end() [1/2]

+ +
+
+ + + + + + + +
Iterator sf::String::end ()
+
+ +

Return an iterator to the end of the string.

+

The end iterator refers to 1 position past the last character; thus it represents an invalid character and should never be accessed.

+
Returns
Read-write iterator to the end of the string characters
+
See also
begin
+ +
+
+ +

◆ end() [2/2]

+ +
+
+ + + + + + + +
ConstIterator sf::String::end () const
+
+ +

Return an iterator to the end of the string.

+

The end iterator refers to 1 position past the last character; thus it represents an invalid character and should never be accessed.

+
Returns
Read-only iterator to the end of the string characters
+
See also
begin
+ +
+
+ +

◆ erase()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::String::erase (std::size_t position,
std::size_t count = 1 
)
+
+ +

Erase one or more characters from the string.

+

This function removes a sequence of count characters starting from position.

+
Parameters
+ + + +
positionPosition of the first character to erase
countNumber of characters to erase
+
+
+ +
+
+ +

◆ find()

+ +
+
+ + + + + + + + + + + + + + + + + + +
std::size_t sf::String::find (const String & str,
std::size_t start = 0 
) const
+
+ +

Find a sequence of one or more characters in the string.

+

This function searches for the characters of str in the string, starting from start.

+
Parameters
+ + + +
strCharacters to find
startWhere to begin searching
+
+
+
Returns
Position of str in the string, or String::InvalidPos if not found
+ +
+
+ +

◆ fromUtf16()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static String sf::String::fromUtf16 (T begin,
T end 
)
+ 		+static
+
+ +

Create a new sf::String from a UTF-16 encoded string.

+
Parameters
+ + + +
beginForward iterator to the beginning of the UTF-16 sequence
endForward iterator to the end of the UTF-16 sequence
+
+
+
Returns
A sf::String containing the source string
+
See also
fromUtf8, fromUtf32
+ +
+
+ +

◆ fromUtf32()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static String sf::String::fromUtf32 (T begin,
T end 
)
+ 		+static
+
+ +

Create a new sf::String from a UTF-32 encoded string.

+

This function is provided for consistency, it is equivalent to using the constructors that takes a const sf::Uint32* or a std::basic_string<sf::Uint32>.

+
Parameters
+ + + +
beginForward iterator to the beginning of the UTF-32 sequence
endForward iterator to the end of the UTF-32 sequence
+
+
+
Returns
A sf::String containing the source string
+
See also
fromUtf8, fromUtf16
+ +
+
+ +

◆ fromUtf8()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static String sf::String::fromUtf8 (T begin,
T end 
)
+ 		+static
+
+ +

Create a new sf::String from a UTF-8 encoded string.

+
Parameters
+ + + +
beginForward iterator to the beginning of the UTF-8 sequence
endForward iterator to the end of the UTF-8 sequence
+
+
+
Returns
A sf::String containing the source string
+
See also
fromUtf16, fromUtf32
+ +
+
+ +

◆ getData()

+ +
+
+ + + + + + + +
const Uint32 * sf::String::getData () const
+
+ +

Get a pointer to the C-style array of characters.

+

This functions provides a read-only access to a null-terminated C-style representation of the string. The returned pointer is temporary and is meant only for immediate use, thus it is not recommended to store it.

+
Returns
Read-only pointer to the array of characters
+ +
+
+ +

◆ getSize()

+ +
+
+ + + + + + + +
std::size_t sf::String::getSize () const
+
+ +

Get the size of the string.

+
Returns
Number of characters in the string
+
See also
isEmpty
+ +
+
+ +

◆ insert()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::String::insert (std::size_t position,
const String & str 
)
+
+ +

Insert one or more characters into the string.

+

This function inserts the characters of str into the string, starting from position.

+
Parameters
+ + + +
positionPosition of insertion
strCharacters to insert
+
+
+ +
+
+ +

◆ isEmpty()

+ +
+
+ + + + + + + +
bool sf::String::isEmpty () const
+
+ +

Check whether the string is empty or not.

+
Returns
True if the string is empty (i.e. contains no character)
+
See also
clear, getSize
+ +
+
+ +

◆ operator std::string()

+ +
+
+ + + + + + + +
sf::String::operator std::string () const
+
+ +

Implicit conversion operator to std::string (ANSI string)

+

The current global locale is used for conversion. If you want to explicitly specify a locale, see toAnsiString. Characters that do not fit in the target encoding are discarded from the returned string. This operator is defined for convenience, and is equivalent to calling toAnsiString().

+
Returns
Converted ANSI string
+
See also
toAnsiString, operator std::wstring
+ +
+
+ +

◆ operator std::wstring()

+ +
+
+ + + + + + + +
sf::String::operator std::wstring () const
+
+ +

Implicit conversion operator to std::wstring (wide string)

+

Characters that do not fit in the target encoding are discarded from the returned string. This operator is defined for convenience, and is equivalent to calling toWideString().

+
Returns
Converted wide string
+
See also
toWideString, operator std::string
+ +
+
+ +

◆ operator+=()

+ +
+
+ + + + + + + + +
String & sf::String::operator+= (const String & right)
+
+ +

Overload of += operator to append an UTF-32 string.

+
Parameters
+ + +
rightString to append
+
+
+
Returns
Reference to self
+ +
+
+ +

◆ operator=()

+ +
+
+ + + + + + + + +
String & sf::String::operator= (const String & right)
+
+ +

Overload of assignment operator.

+
Parameters
+ + +
rightInstance to assign
+
+
+
Returns
Reference to self
+ +
+
+ +

◆ operator[]() [1/2]

+ +
+
+ + + + + + + + +
Uint32 & sf::String::operator[] (std::size_t index)
+
+ +

Overload of [] operator to access a character by its position.

+

This function provides read and write access to characters. Note: the behavior is undefined if index is out of range.

+
Parameters
+ + +
indexIndex of the character to get
+
+
+
Returns
Reference to the character at position index
+ +
+
+ +

◆ operator[]() [2/2]

+ +
+
+ + + + + + + + +
Uint32 sf::String::operator[] (std::size_t index) const
+
+ +

Overload of [] operator to access a character by its position.

+

This function provides read-only access to characters. Note: the behavior is undefined if index is out of range.

+
Parameters
+ + +
indexIndex of the character to get
+
+
+
Returns
Character at position index
+ +
+
+ +

◆ replace() [1/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::String::replace (const String & searchFor,
const String & replaceWith 
)
+
+ +

Replace all occurrences of a substring with a replacement string.

+

This function replaces all occurrences of searchFor in this string with the string replaceWith.

+
Parameters
+ + + +
searchForThe value being searched for
replaceWithThe value that replaces found searchFor values
+
+
+ +
+
+ +

◆ replace() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::String::replace (std::size_t position,
std::size_t length,
const String & replaceWith 
)
+
+ +

Replace a substring with another string.

+

This function replaces the substring that starts at index position and spans length characters with the string replaceWith.

+
Parameters
+ + + + +
positionIndex of the first character to be replaced
lengthNumber of characters to replace. You can pass InvalidPos to replace all characters until the end of the string.
replaceWithString that replaces the given substring.
+
+
+ +
+
+ +

◆ substring()

+ +
+
+ + + + + + + + + + + + + + + + + + +
String sf::String::substring (std::size_t position,
std::size_t length = InvalidPos 
) const
+
+ +

Return a part of the string.

+

This function returns the substring that starts at index position and spans length characters.

+
Parameters
+ + + +
positionIndex of the first character
lengthNumber of characters to include in the substring (if the string is shorter, as many characters as possible are included). InvalidPos can be used to include all characters until the end of the string.
+
+
+
Returns
String object containing a substring of this object
+ +
+
+ +

◆ toAnsiString()

+ +
+
+ + + + + + + + +
std::string sf::String::toAnsiString (const std::locale & locale = std::locale()) const
+
+ +

Convert the Unicode string to an ANSI string.

+

The UTF-32 string is converted to an ANSI string in the encoding defined by locale. Characters that do not fit in the target encoding are discarded from the returned string.

+
Parameters
+ + +
localeLocale to use for conversion
+
+
+
Returns
Converted ANSI string
+
See also
toWideString, operator std::string
+ +
+
+ +

◆ toUtf16()

+ +
+
+ + + + + + + +
std::basic_string< Uint16 > sf::String::toUtf16 () const
+
+ +

Convert the Unicode string to a UTF-16 string.

+
Returns
Converted UTF-16 string
+
See also
toUtf8, toUtf32
+ +
+
+ +

◆ toUtf32()

+ +
+
+ + + + + + + +
std::basic_string< Uint32 > sf::String::toUtf32 () const
+
+ +

Convert the Unicode string to a UTF-32 string.

+

This function doesn't perform any conversion, since the string is already stored as UTF-32 internally.

+
Returns
Converted UTF-32 string
+
See also
toUtf8, toUtf16
+ +
+
+ +

◆ toUtf8()

+ +
+
+ + + + + + + +
std::basic_string< Uint8 > sf::String::toUtf8 () const
+
+ +

Convert the Unicode string to a UTF-8 string.

+
Returns
Converted UTF-8 string
+
See also
toUtf16, toUtf32
+ +
+
+ +

◆ toWideString()

+ +
+
+ + + + + + + +
std::wstring sf::String::toWideString () const
+
+ +

Convert the Unicode string to a wide string.

+

Characters that do not fit in the target encoding are discarded from the returned string.

+
Returns
Converted wide string
+
See also
toAnsiString, operator std::wstring
+ +
+
+

Friends And Related Function Documentation

+ +

◆ operator!=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (const String & left,
const String & right 
)
+ 		+related
+
+ +

Overload of != operator to compare two UTF-32 strings.

+
Parameters
+ + + +
leftLeft operand (a string)
rightRight operand (a string)
+
+
+
Returns
True if both strings are different
+ +
+
+ +

◆ operator+()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
String operator+ (const String & left,
const String & right 
)
+ 		+related
+
+ +

Overload of binary + operator to concatenate two strings.

+
Parameters
+ + + +
leftLeft operand (a string)
rightRight operand (a string)
+
+
+
Returns
Concatenated string
+ +
+
+ +

◆ operator<()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator< (const String & left,
const String & right 
)
+ 		+related
+
+ +

Overload of < operator to compare two UTF-32 strings.

+
Parameters
+ + + +
leftLeft operand (a string)
rightRight operand (a string)
+
+
+
Returns
True if left is lexicographically before right
+ +
+
+ +

◆ operator<=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator<= (const String & left,
const String & right 
)
+ 		+related
+
+ +

Overload of <= operator to compare two UTF-32 strings.

+
Parameters
+ + + +
leftLeft operand (a string)
rightRight operand (a string)
+
+
+
Returns
True if left is lexicographically before or equivalent to right
+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (const String & left,
const String & right 
)
+ 		+related
+
+ +

Overload of == operator to compare two UTF-32 strings.

+
Parameters
+ + + +
leftLeft operand (a string)
rightRight operand (a string)
+
+
+
Returns
True if both strings are equal
+ +
+
+ +

◆ operator>()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator> (const String & left,
const String & right 
)
+ 		+related
+
+ +

Overload of > operator to compare two UTF-32 strings.

+
Parameters
+ + + +
leftLeft operand (a string)
rightRight operand (a string)
+
+
+
Returns
True if left is lexicographically after right
+ +
+
+ +

◆ operator>=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator>= (const String & left,
const String & right 
)
+ 		+related
+
+ +

Overload of >= operator to compare two UTF-32 strings.

+
Parameters
+ + + +
leftLeft operand (a string)
rightRight operand (a string)
+
+
+
Returns
True if left is lexicographically after or equivalent to right
+ +
+
+

Member Data Documentation

+ +

◆ InvalidPos

+ +
+
+ + + + + +
+ + + + +
const std::size_t sf::String::InvalidPos
+ 		+static
+
+ +

Represents an invalid position in the string.

+ +

Definition at line 58 of file String.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1TcpListener-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1TcpListener-members.html new file mode 100644 index 000000000..4b52734e1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1TcpListener-members.html @@ -0,0 +1,130 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::TcpListener Member List
+
+
+ +

This is the complete list of members for sf::TcpListener, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + +
accept(TcpSocket &socket)sf::TcpListener
AnyPort enum valuesf::Socket
close()sf::TcpListener
create()sf::Socketprotected
create(SocketHandle handle)sf::Socketprotected
Disconnected enum valuesf::Socket
Done enum valuesf::Socket
Error enum valuesf::Socket
getHandle() constsf::Socketprotected
getLocalPort() constsf::TcpListener
isBlocking() constsf::Socket
listen(unsigned short port, const IpAddress &address=IpAddress::Any)sf::TcpListener
NotReady enum valuesf::Socket
Partial enum valuesf::Socket
setBlocking(bool blocking)sf::Socket
Socket(Type type)sf::Socketprotected
Status enum namesf::Socket
Tcp enum valuesf::Socketprotected
TcpListener()sf::TcpListener
Type enum namesf::Socketprotected
Udp enum valuesf::Socketprotected
~Socket()sf::Socketvirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1TcpListener.html b/Space-Invaders/sfml/doc/html/classsf_1_1TcpListener.html new file mode 100644 index 000000000..dc22da3b2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1TcpListener.html @@ -0,0 +1,617 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Protected Types | +Protected Member Functions | +List of all members
+
sf::TcpListener Class Reference
Network module
+
+
+ +

Socket that listens to new TCP connections. + More...

+ +

#include <SFML/Network/TcpListener.hpp>

+
+Inheritance diagram for sf::TcpListener:
+
+
+ + +sf::Socket +sf::NonCopyable + +
+ + + + + + + + +

+Public Types

enum  Status {
+  Done +, NotReady +, Partial +, Disconnected +,
+  Error +
+ }
 Status codes that may be returned by socket functions. More...
 
enum  { AnyPort = 0 + }
 Some special values used by sockets. More...
 
+ + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 TcpListener ()
 Default constructor.
 
unsigned short getLocalPort () const
 Get the port to which the socket is bound locally.
 
Status listen (unsigned short port, const IpAddress &address=IpAddress::Any)
 Start listening for incoming connection attempts.
 
void close ()
 Stop listening and close the socket.
 
Status accept (TcpSocket &socket)
 Accept a new connection.
 
void setBlocking (bool blocking)
 Set the blocking state of the socket.
 
bool isBlocking () const
 Tell whether the socket is in blocking or non-blocking mode.
 
+ + + + +

+Protected Types

enum  Type { Tcp +, Udp + }
 Types of protocols that the socket can use. More...
 
+ + + + + + + + + + +

+Protected Member Functions

SocketHandle getHandle () const
 Return the internal handle of the socket.
 
void create ()
 Create the internal representation of the socket.
 
void create (SocketHandle handle)
 Create the internal representation of the socket from a socket handle.
 
+

Detailed Description

+

Socket that listens to new TCP connections.

+

A listener socket is a special type of socket that listens to a given port and waits for connections on that port.

+

This is all it can do.

+

When a new connection is received, you must call accept and the listener returns a new instance of sf::TcpSocket that is properly initialized and can be used to communicate with the new client.

+

Listener sockets are specific to the TCP protocol, UDP sockets are connectionless and can therefore communicate directly. As a consequence, a listener socket will always return the new connections as sf::TcpSocket instances.

+

A listener is automatically closed on destruction, like all other types of socket. However if you want to stop listening before the socket is destroyed, you can call its close() function.

+

Usage example:

// Create a listener socket and make it wait for new
+
// connections on port 55001
+
sf::TcpListener listener;
+
listener.listen(55001);
+
+
// Endless loop that waits for new connections
+
while (running)
+
{
+
sf::TcpSocket client;
+
if (listener.accept(client) == sf::Socket::Done)
+
{
+
// A new client just connected!
+
std::cout << "New connection received from " << client.getRemoteAddress() << std::endl;
+
doSomethingWith(client);
+
}
+
}
+
sf::Socket::Done
@ Done
The socket has sent / received the data.
Definition: Socket.hpp:55
+
sf::TcpListener
Socket that listens to new TCP connections.
Definition: TcpListener.hpp:45
+
sf::TcpListener::listen
Status listen(unsigned short port, const IpAddress &address=IpAddress::Any)
Start listening for incoming connection attempts.
+
sf::TcpListener::accept
Status accept(TcpSocket &socket)
Accept a new connection.
+
sf::TcpSocket
Specialized socket using the TCP protocol.
Definition: TcpSocket.hpp:47
+
sf::TcpSocket::getRemoteAddress
IpAddress getRemoteAddress() const
Get the address of the connected peer.
+
See also
sf::TcpSocket, sf::Socket
+ +

Definition at line 44 of file TcpListener.hpp.

+

Member Enumeration Documentation

+ +

◆ anonymous enum

+ +
+
+ + + + + +
+ + + + +
anonymous enum
+ 		+inherited
+
+ +

Some special values used by sockets.

+ + +
Enumerator
AnyPort 

Special value that tells the system to pick any available port.

+
+ +

Definition at line 66 of file Socket.hpp.

+ +
+
+ +

◆ Status

+ +
+
+ + + + + +
+ + + + +
enum sf::Socket::Status
+ 		+inherited
+
+ +

Status codes that may be returned by socket functions.

+ + + + + + +
Enumerator
Done 

The socket has sent / received the data.

+
NotReady 

The socket is not ready to send / receive data yet.

+
Partial 

The socket sent a part of the data.

+
Disconnected 

The TCP socket has been disconnected.

+
Error 

An unexpected error happened.

+
+ +

Definition at line 53 of file Socket.hpp.

+ +
+
+ +

◆ Type

+ +
+
+ + + + + +
+ + + + +
enum sf::Socket::Type
+ 		+protectedinherited
+
+ +

Types of protocols that the socket can use.

+ + + +
Enumerator
Tcp 

TCP protocol.

+
Udp 

UDP protocol.

+
+ +

Definition at line 114 of file Socket.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ TcpListener()

+ +
+
+ + + + + + + +
sf::TcpListener::TcpListener ()
+
+ +

Default constructor.

+ +
+
+

Member Function Documentation

+ +

◆ accept()

+ +
+
+ + + + + + + + +
Status sf::TcpListener::accept (TcpSocket & socket)
+
+ +

Accept a new connection.

+

If the socket is in blocking mode, this function will not return until a connection is actually received.

+
Parameters
+ + +
socketSocket that will hold the new connection
+
+
+
Returns
Status code
+
See also
listen
+ +
+
+ +

◆ close()

+ +
+
+ + + + + + + +
void sf::TcpListener::close ()
+
+ +

Stop listening and close the socket.

+

This function gracefully stops the listener. If the socket is not listening, this function has no effect.

+
See also
listen
+ +
+
+ +

◆ create() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Socket::create ()
+ 		+protectedinherited
+
+ +

Create the internal representation of the socket.

+

This function can only be accessed by derived classes.

+ +
+
+ +

◆ create() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Socket::create (SocketHandle handle)
+ 		+protectedinherited
+
+ +

Create the internal representation of the socket from a socket handle.

+

This function can only be accessed by derived classes.

+
Parameters
+ + +
handleOS-specific handle of the socket to wrap
+
+
+ +
+
+ +

◆ getHandle()

+ +
+
+ + + + + +
+ + + + + + + +
SocketHandle sf::Socket::getHandle () const
+ 		+protectedinherited
+
+ +

Return the internal handle of the socket.

+

The returned handle may be invalid if the socket was not created yet (or already destroyed). This function can only be accessed by derived classes.

+
Returns
The internal (OS-specific) handle of the socket
+ +
+
+ +

◆ getLocalPort()

+ +
+
+ + + + + + + +
unsigned short sf::TcpListener::getLocalPort () const
+
+ +

Get the port to which the socket is bound locally.

+

If the socket is not listening to a port, this function returns 0.

+
Returns
Port to which the socket is bound
+
See also
listen
+ +
+
+ +

◆ isBlocking()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::Socket::isBlocking () const
+ 		+inherited
+
+ +

Tell whether the socket is in blocking or non-blocking mode.

+
Returns
True if the socket is blocking, false otherwise
+
See also
setBlocking
+ +
+
+ +

◆ listen()

+ +
+
+ + + + + + + + + + + + + + + + + + +
Status sf::TcpListener::listen (unsigned short port,
const IpAddress & address = IpAddress::Any 
)
+
+ +

Start listening for incoming connection attempts.

+

This function makes the socket start listening on the specified port, waiting for incoming connection attempts.

+

If the socket is already listening on a port when this function is called, it will stop listening on the old port before starting to listen on the new port.

+

When providing sf::Socket::AnyPort as port, the listener will request an available port from the system. The chosen port can be retrieved by calling getLocalPort().

+
Parameters
+ + + +
portPort to listen on for incoming connection attempts
addressAddress of the interface to listen on
+
+
+
Returns
Status code
+
See also
accept, close
+ +
+
+ +

◆ setBlocking()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Socket::setBlocking (bool blocking)
+ 		+inherited
+
+ +

Set the blocking state of the socket.

+

In blocking mode, calls will not return until they have completed their task. For example, a call to Receive in blocking mode won't return until some data was actually received. In non-blocking mode, calls will always return immediately, using the return code to signal whether there was data available or not. By default, all sockets are blocking.

+
Parameters
+ + +
blockingTrue to set the socket as blocking, false for non-blocking
+
+
+
See also
isBlocking
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1TcpListener.png b/Space-Invaders/sfml/doc/html/classsf_1_1TcpListener.png new file mode 100644 index 000000000..4aebc8bcc Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1TcpListener.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1TcpSocket-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1TcpSocket-members.html new file mode 100644 index 000000000..4053dc7aa --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1TcpSocket-members.html @@ -0,0 +1,138 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::TcpSocket Member List
+
+
+ +

This is the complete list of members for sf::TcpSocket, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AnyPort enum valuesf::Socket
close()sf::Socketprotected
connect(const IpAddress &remoteAddress, unsigned short remotePort, Time timeout=Time::Zero)sf::TcpSocket
create()sf::Socketprotected
create(SocketHandle handle)sf::Socketprotected
disconnect()sf::TcpSocket
Disconnected enum valuesf::Socket
Done enum valuesf::Socket
Error enum valuesf::Socket
getHandle() constsf::Socketprotected
getLocalPort() constsf::TcpSocket
getRemoteAddress() constsf::TcpSocket
getRemotePort() constsf::TcpSocket
isBlocking() constsf::Socket
NotReady enum valuesf::Socket
Partial enum valuesf::Socket
receive(void *data, std::size_t size, std::size_t &received)sf::TcpSocket
receive(Packet &packet)sf::TcpSocket
send(const void *data, std::size_t size)sf::TcpSocket
send(const void *data, std::size_t size, std::size_t &sent)sf::TcpSocket
send(Packet &packet)sf::TcpSocket
setBlocking(bool blocking)sf::Socket
Socket(Type type)sf::Socketprotected
Status enum namesf::Socket
Tcp enum valuesf::Socketprotected
TcpListener (defined in sf::TcpSocket)sf::TcpSocketfriend
TcpSocket()sf::TcpSocket
Type enum namesf::Socketprotected
Udp enum valuesf::Socketprotected
~Socket()sf::Socketvirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1TcpSocket.html b/Space-Invaders/sfml/doc/html/classsf_1_1TcpSocket.html new file mode 100644 index 000000000..69b116cb9 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1TcpSocket.html @@ -0,0 +1,934 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Classes | +Public Types | +Public Member Functions | +Protected Types | +Protected Member Functions | +Friends | +List of all members
+
sf::TcpSocket Class Reference
Network module
+
+
+ +

Specialized socket using the TCP protocol. + More...

+ +

#include <SFML/Network/TcpSocket.hpp>

+
+Inheritance diagram for sf::TcpSocket:
+
+
+ + +sf::Socket +sf::NonCopyable + +
+ + + + + + + + +

+Public Types

enum  Status {
+  Done +, NotReady +, Partial +, Disconnected +,
+  Error +
+ }
 Status codes that may be returned by socket functions. More...
 
enum  { AnyPort = 0 + }
 Some special values used by sockets. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 TcpSocket ()
 Default constructor.
 
unsigned short getLocalPort () const
 Get the port to which the socket is bound locally.
 
IpAddress getRemoteAddress () const
 Get the address of the connected peer.
 
unsigned short getRemotePort () const
 Get the port of the connected peer to which the socket is connected.
 
Status connect (const IpAddress &remoteAddress, unsigned short remotePort, Time timeout=Time::Zero)
 Connect the socket to a remote peer.
 
void disconnect ()
 Disconnect the socket from its remote peer.
 
Status send (const void *data, std::size_t size)
 Send raw data to the remote peer.
 
Status send (const void *data, std::size_t size, std::size_t &sent)
 Send raw data to the remote peer.
 
Status receive (void *data, std::size_t size, std::size_t &received)
 Receive raw data from the remote peer.
 
Status send (Packet &packet)
 Send a formatted packet of data to the remote peer.
 
Status receive (Packet &packet)
 Receive a formatted packet of data from the remote peer.
 
void setBlocking (bool blocking)
 Set the blocking state of the socket.
 
bool isBlocking () const
 Tell whether the socket is in blocking or non-blocking mode.
 
+ + + + +

+Protected Types

enum  Type { Tcp +, Udp + }
 Types of protocols that the socket can use. More...
 
+ + + + + + + + + + + + + +

+Protected Member Functions

SocketHandle getHandle () const
 Return the internal handle of the socket.
 
void create ()
 Create the internal representation of the socket.
 
void create (SocketHandle handle)
 Create the internal representation of the socket from a socket handle.
 
void close ()
 Close the socket gracefully.
 
+ + + +

+Friends

class TcpListener
 
+

Detailed Description

+

Specialized socket using the TCP protocol.

+

TCP is a connected protocol, which means that a TCP socket can only communicate with the host it is connected to.

+

It can't send or receive anything if it is not connected.

+

The TCP protocol is reliable but adds a slight overhead. It ensures that your data will always be received in order and without errors (no data corrupted, lost or duplicated).

+

When a socket is connected to a remote host, you can retrieve informations about this host with the getRemoteAddress and getRemotePort functions. You can also get the local port to which the socket is bound (which is automatically chosen when the socket is connected), with the getLocalPort function.

+

Sending and receiving data can use either the low-level or the high-level functions. The low-level functions process a raw sequence of bytes, and cannot ensure that one call to Send will exactly match one call to Receive at the other end of the socket.

+

The high-level interface uses packets (see sf::Packet), which are easier to use and provide more safety regarding the data that is exchanged. You can look at the sf::Packet class to get more details about how they work.

+

The socket is automatically disconnected when it is destroyed, but if you want to explicitly close the connection while the socket instance is still alive, you can call disconnect.

+

Usage example:

// ----- The client -----
+
+
// Create a socket and connect it to 192.168.1.50 on port 55001
+
sf::TcpSocket socket;
+
socket.connect("192.168.1.50", 55001);
+
+
// Send a message to the connected host
+
std::string message = "Hi, I am a client";
+
socket.send(message.c_str(), message.size() + 1);
+
+
// Receive an answer from the server
+
char buffer[1024];
+
std::size_t received = 0;
+
socket.receive(buffer, sizeof(buffer), received);
+
std::cout << "The server said: " << buffer << std::endl;
+
+
// ----- The server -----
+
+
// Create a listener to wait for incoming connections on port 55001
+
sf::TcpListener listener;
+
listener.listen(55001);
+
+
// Wait for a connection
+
sf::TcpSocket socket;
+
listener.accept(socket);
+
std::cout << "New client connected: " << socket.getRemoteAddress() << std::endl;
+
+
// Receive a message from the client
+
char buffer[1024];
+
std::size_t received = 0;
+
socket.receive(buffer, sizeof(buffer), received);
+
std::cout << "The client said: " << buffer << std::endl;
+
+
// Send an answer
+
std::string message = "Welcome, client";
+
socket.send(message.c_str(), message.size() + 1);
+
sf::TcpListener
Socket that listens to new TCP connections.
Definition: TcpListener.hpp:45
+
sf::TcpListener::listen
Status listen(unsigned short port, const IpAddress &address=IpAddress::Any)
Start listening for incoming connection attempts.
+
sf::TcpListener::accept
Status accept(TcpSocket &socket)
Accept a new connection.
+
sf::TcpSocket
Specialized socket using the TCP protocol.
Definition: TcpSocket.hpp:47
+
sf::TcpSocket::connect
Status connect(const IpAddress &remoteAddress, unsigned short remotePort, Time timeout=Time::Zero)
Connect the socket to a remote peer.
+
sf::TcpSocket::receive
Status receive(void *data, std::size_t size, std::size_t &received)
Receive raw data from the remote peer.
+
sf::TcpSocket::getRemoteAddress
IpAddress getRemoteAddress() const
Get the address of the connected peer.
+
sf::TcpSocket::send
Status send(const void *data, std::size_t size)
Send raw data to the remote peer.
+
See also
sf::Socket, sf::UdpSocket, sf::Packet
+ +

Definition at line 46 of file TcpSocket.hpp.

+

Member Enumeration Documentation

+ +

◆ anonymous enum

+ +
+
+ + + + + +
+ + + + +
anonymous enum
+ 		+inherited
+
+ +

Some special values used by sockets.

+ + +
Enumerator
AnyPort 

Special value that tells the system to pick any available port.

+
+ +

Definition at line 66 of file Socket.hpp.

+ +
+
+ +

◆ Status

+ +
+
+ + + + + +
+ + + + +
enum sf::Socket::Status
+ 		+inherited
+
+ +

Status codes that may be returned by socket functions.

+ + + + + + +
Enumerator
Done 

The socket has sent / received the data.

+
NotReady 

The socket is not ready to send / receive data yet.

+
Partial 

The socket sent a part of the data.

+
Disconnected 

The TCP socket has been disconnected.

+
Error 

An unexpected error happened.

+
+ +

Definition at line 53 of file Socket.hpp.

+ +
+
+ +

◆ Type

+ +
+
+ + + + + +
+ + + + +
enum sf::Socket::Type
+ 		+protectedinherited
+
+ +

Types of protocols that the socket can use.

+ + + +
Enumerator
Tcp 

TCP protocol.

+
Udp 

UDP protocol.

+
+ +

Definition at line 114 of file Socket.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ TcpSocket()

+ +
+
+ + + + + + + +
sf::TcpSocket::TcpSocket ()
+
+ +

Default constructor.

+ +
+
+

Member Function Documentation

+ +

◆ close()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Socket::close ()
+ 		+protectedinherited
+
+ +

Close the socket gracefully.

+

This function can only be accessed by derived classes.

+ +
+
+ +

◆ connect()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
Status sf::TcpSocket::connect (const IpAddress & remoteAddress,
unsigned short remotePort,
Time timeout = Time::Zero 
)
+
+ +

Connect the socket to a remote peer.

+

In blocking mode, this function may take a while, especially if the remote peer is not reachable. The last parameter allows you to stop trying to connect after a given timeout. If the socket is already connected, the connection is forcibly disconnected before attempting to connect again.

+
Parameters
+ + + + +
remoteAddressAddress of the remote peer
remotePortPort of the remote peer
timeoutOptional maximum time to wait
+
+
+
Returns
Status code
+
See also
disconnect
+ +
+
+ +

◆ create() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Socket::create ()
+ 		+protectedinherited
+
+ +

Create the internal representation of the socket.

+

This function can only be accessed by derived classes.

+ +
+
+ +

◆ create() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Socket::create (SocketHandle handle)
+ 		+protectedinherited
+
+ +

Create the internal representation of the socket from a socket handle.

+

This function can only be accessed by derived classes.

+
Parameters
+ + +
handleOS-specific handle of the socket to wrap
+
+
+ +
+
+ +

◆ disconnect()

+ +
+
+ + + + + + + +
void sf::TcpSocket::disconnect ()
+
+ +

Disconnect the socket from its remote peer.

+

This function gracefully closes the connection. If the socket is not connected, this function has no effect.

+
See also
connect
+ +
+
+ +

◆ getHandle()

+ +
+
+ + + + + +
+ + + + + + + +
SocketHandle sf::Socket::getHandle () const
+ 		+protectedinherited
+
+ +

Return the internal handle of the socket.

+

The returned handle may be invalid if the socket was not created yet (or already destroyed). This function can only be accessed by derived classes.

+
Returns
The internal (OS-specific) handle of the socket
+ +
+
+ +

◆ getLocalPort()

+ +
+
+ + + + + + + +
unsigned short sf::TcpSocket::getLocalPort () const
+
+ +

Get the port to which the socket is bound locally.

+

If the socket is not connected, this function returns 0.

+
Returns
Port to which the socket is bound
+
See also
connect, getRemotePort
+ +
+
+ +

◆ getRemoteAddress()

+ +
+
+ + + + + + + +
IpAddress sf::TcpSocket::getRemoteAddress () const
+
+ +

Get the address of the connected peer.

+

If the socket is not connected, this function returns sf::IpAddress::None.

+
Returns
Address of the remote peer
+
See also
getRemotePort
+ +
+
+ +

◆ getRemotePort()

+ +
+
+ + + + + + + +
unsigned short sf::TcpSocket::getRemotePort () const
+
+ +

Get the port of the connected peer to which the socket is connected.

+

If the socket is not connected, this function returns 0.

+
Returns
Remote port to which the socket is connected
+
See also
getRemoteAddress
+ +
+
+ +

◆ isBlocking()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::Socket::isBlocking () const
+ 		+inherited
+
+ +

Tell whether the socket is in blocking or non-blocking mode.

+
Returns
True if the socket is blocking, false otherwise
+
See also
setBlocking
+ +
+
+ +

◆ receive() [1/2]

+ +
+
+ + + + + + + + +
Status sf::TcpSocket::receive (Packet & packet)
+
+ +

Receive a formatted packet of data from the remote peer.

+

In blocking mode, this function will wait until the whole packet has been received. This function will fail if the socket is not connected.

+
Parameters
+ + +
packetPacket to fill with the received data
+
+
+
Returns
Status code
+
See also
send
+ +
+
+ +

◆ receive() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
Status sf::TcpSocket::receive (void * data,
std::size_t size,
std::size_t & received 
)
+
+ +

Receive raw data from the remote peer.

+

In blocking mode, this function will wait until some bytes are actually received. This function will fail if the socket is not connected.

+
Parameters
+ + + + +
dataPointer to the array to fill with the received bytes
sizeMaximum number of bytes that can be received
receivedThis variable is filled with the actual number of bytes received
+
+
+
Returns
Status code
+
See also
send
+ +
+
+ +

◆ send() [1/3]

+ +
+
+ + + + + + + + + + + + + + + + + + +
Status sf::TcpSocket::send (const void * data,
std::size_t size 
)
+
+ +

Send raw data to the remote peer.

+

To be able to handle partial sends over non-blocking sockets, use the send(const void*, std::size_t, std::size_t&) overload instead. This function will fail if the socket is not connected.

+
Parameters
+ + + +
dataPointer to the sequence of bytes to send
sizeNumber of bytes to send
+
+
+
Returns
Status code
+
See also
receive
+ +
+
+ +

◆ send() [2/3]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
Status sf::TcpSocket::send (const void * data,
std::size_t size,
std::size_t & sent 
)
+
+ +

Send raw data to the remote peer.

+

This function will fail if the socket is not connected.

+
Parameters
+ + + + +
dataPointer to the sequence of bytes to send
sizeNumber of bytes to send
sentThe number of bytes sent will be written here
+
+
+
Returns
Status code
+
See also
receive
+ +
+
+ +

◆ send() [3/3]

+ +
+
+ + + + + + + + +
Status sf::TcpSocket::send (Packet & packet)
+
+ +

Send a formatted packet of data to the remote peer.

+

In non-blocking mode, if this function returns sf::Socket::Partial, you must retry sending the same unmodified packet before sending anything else in order to guarantee the packet arrives at the remote peer uncorrupted. This function will fail if the socket is not connected.

+
Parameters
+ + +
packetPacket to send
+
+
+
Returns
Status code
+
See also
receive
+ +
+
+ +

◆ setBlocking()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Socket::setBlocking (bool blocking)
+ 		+inherited
+
+ +

Set the blocking state of the socket.

+

In blocking mode, calls will not return until they have completed their task. For example, a call to Receive in blocking mode won't return until some data was actually received. In non-blocking mode, calls will always return immediately, using the return code to signal whether there was data available or not. By default, all sockets are blocking.

+
Parameters
+ + +
blockingTrue to set the socket as blocking, false for non-blocking
+
+
+
See also
isBlocking
+ +
+
+

Friends And Related Function Documentation

+ +

◆ TcpListener

+ +
+
+ + + + + +
+ + + + +
friend class TcpListener
+ 		+friend
+
+ +

Definition at line 213 of file TcpSocket.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1TcpSocket.png b/Space-Invaders/sfml/doc/html/classsf_1_1TcpSocket.png new file mode 100644 index 000000000..215a8f04a Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1TcpSocket.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Text-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Text-members.html new file mode 100644 index 000000000..876ca93b4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Text-members.html @@ -0,0 +1,160 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Text Member List
+
+
+ +

This is the complete list of members for sf::Text, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Bold enum valuesf::Text
findCharacterPos(std::size_t index) constsf::Text
getCharacterSize() constsf::Text
getColor() constsf::Text
getFillColor() constsf::Text
getFont() constsf::Text
getGlobalBounds() constsf::Text
getInverseTransform() constsf::Transformable
getLetterSpacing() constsf::Text
getLineSpacing() constsf::Text
getLocalBounds() constsf::Text
getOrigin() constsf::Transformable
getOutlineColor() constsf::Text
getOutlineThickness() constsf::Text
getPosition() constsf::Transformable
getRotation() constsf::Transformable
getScale() constsf::Transformable
getString() constsf::Text
getStyle() constsf::Text
getTransform() constsf::Transformable
Italic enum valuesf::Text
move(float offsetX, float offsetY)sf::Transformable
move(const Vector2f &offset)sf::Transformable
Regular enum valuesf::Text
rotate(float angle)sf::Transformable
scale(float factorX, float factorY)sf::Transformable
scale(const Vector2f &factor)sf::Transformable
setCharacterSize(unsigned int size)sf::Text
setColor(const Color &color)sf::Text
setFillColor(const Color &color)sf::Text
setFont(const Font &font)sf::Text
setLetterSpacing(float spacingFactor)sf::Text
setLineSpacing(float spacingFactor)sf::Text
setOrigin(float x, float y)sf::Transformable
setOrigin(const Vector2f &origin)sf::Transformable
setOutlineColor(const Color &color)sf::Text
setOutlineThickness(float thickness)sf::Text
setPosition(float x, float y)sf::Transformable
setPosition(const Vector2f &position)sf::Transformable
setRotation(float angle)sf::Transformable
setScale(float factorX, float factorY)sf::Transformable
setScale(const Vector2f &factors)sf::Transformable
setString(const String &string)sf::Text
setStyle(Uint32 style)sf::Text
StrikeThrough enum valuesf::Text
Style enum namesf::Text
Text()sf::Text
Text(const String &string, const Font &font, unsigned int characterSize=30)sf::Text
Transformable()sf::Transformable
Underlined enum valuesf::Text
~Drawable()sf::Drawableinlinevirtual
~Transformable()sf::Transformablevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Text.html b/Space-Invaders/sfml/doc/html/classsf_1_1Text.html new file mode 100644 index 000000000..730345f86 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Text.html @@ -0,0 +1,1643 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +List of all members
+
sf::Text Class Reference
Graphics module
+
+
+ +

Graphical text that can be drawn to a render target. + More...

+ +

#include <SFML/Graphics/Text.hpp>

+
+Inheritance diagram for sf::Text:
+
+
+ + +sf::Drawable +sf::Transformable + +
+ + + + + +

+Public Types

enum  Style {
+  Regular = 0 +, Bold = 1 << 0 +, Italic = 1 << 1 +, Underlined = 1 << 2 +,
+  StrikeThrough = 1 << 3 +
+ }
 Enumeration of the string drawing styles. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Text ()
 Default constructor.
 
 Text (const String &string, const Font &font, unsigned int characterSize=30)
 Construct the text from a string, font and size.
 
void setString (const String &string)
 Set the text's string.
 
void setFont (const Font &font)
 Set the text's font.
 
void setCharacterSize (unsigned int size)
 Set the character size.
 
void setLineSpacing (float spacingFactor)
 Set the line spacing factor.
 
void setLetterSpacing (float spacingFactor)
 Set the letter spacing factor.
 
void setStyle (Uint32 style)
 Set the text's style.
 
void setColor (const Color &color)
 Set the fill color of the text.
 
void setFillColor (const Color &color)
 Set the fill color of the text.
 
void setOutlineColor (const Color &color)
 Set the outline color of the text.
 
void setOutlineThickness (float thickness)
 Set the thickness of the text's outline.
 
const String & getString () const
 Get the text's string.
 
const Font * getFont () const
 Get the text's font.
 
unsigned int getCharacterSize () const
 Get the character size.
 
float getLetterSpacing () const
 Get the size of the letter spacing factor.
 
float getLineSpacing () const
 Get the size of the line spacing factor.
 
Uint32 getStyle () const
 Get the text's style.
 
const Color & getColor () const
 Get the fill color of the text.
 
const Color & getFillColor () const
 Get the fill color of the text.
 
const Color & getOutlineColor () const
 Get the outline color of the text.
 
float getOutlineThickness () const
 Get the outline thickness of the text.
 
Vector2f findCharacterPos (std::size_t index) const
 Return the position of the index-th character.
 
FloatRect getLocalBounds () const
 Get the local bounding rectangle of the entity.
 
FloatRect getGlobalBounds () const
 Get the global bounding rectangle of the entity.
 
void setPosition (float x, float y)
 set the position of the object
 
void setPosition (const Vector2f &position)
 set the position of the object
 
void setRotation (float angle)
 set the orientation of the object
 
void setScale (float factorX, float factorY)
 set the scale factors of the object
 
void setScale (const Vector2f &factors)
 set the scale factors of the object
 
void setOrigin (float x, float y)
 set the local origin of the object
 
void setOrigin (const Vector2f &origin)
 set the local origin of the object
 
const Vector2f & getPosition () const
 get the position of the object
 
float getRotation () const
 get the orientation of the object
 
const Vector2f & getScale () const
 get the current scale of the object
 
const Vector2f & getOrigin () const
 get the local origin of the object
 
void move (float offsetX, float offsetY)
 Move the object by a given offset.
 
void move (const Vector2f &offset)
 Move the object by a given offset.
 
void rotate (float angle)
 Rotate the object.
 
void scale (float factorX, float factorY)
 Scale the object.
 
void scale (const Vector2f &factor)
 Scale the object.
 
const Transform & getTransform () const
 get the combined transform of the object
 
const Transform & getInverseTransform () const
 get the inverse of the combined transform of the object
 
+

Detailed Description

+

Graphical text that can be drawn to a render target.

+

sf::Text is a drawable class that allows to easily display some text with custom style and color on a render target.

+

It inherits all the functions from sf::Transformable: position, rotation, scale, origin. It also adds text-specific properties such as the font to use, the character size, the font style (bold, italic, underlined and strike through), the text color, the outline thickness, the outline color, the character spacing, the line spacing and the text to display of course. It also provides convenience functions to calculate the graphical size of the text, or to get the global position of a given character.

+

sf::Text works in combination with the sf::Font class, which loads and provides the glyphs (visual characters) of a given font.

+

The separation of sf::Font and sf::Text allows more flexibility and better performances: indeed a sf::Font is a heavy resource, and any operation on it is slow (often too slow for real-time applications). On the other side, a sf::Text is a lightweight object which can combine the glyphs data and metrics of a sf::Font to display any text on a render target.

+

It is important to note that the sf::Text instance doesn't copy the font that it uses, it only keeps a reference to it. Thus, a sf::Font must not be destructed while it is used by a sf::Text (i.e. never write a function that uses a local sf::Font instance for creating a text).

+

See also the note on coordinates and undistorted rendering in sf::Transformable.

+

Usage example:

// Declare and load a font
+
sf::Font font;
+
font.loadFromFile("arial.ttf");
+
+
// Create a text
+
sf::Text text("hello", font);
+
text.setCharacterSize(30);
+
text.setStyle(sf::Text::Bold);
+
text.setFillColor(sf::Color::Red);
+
+
// Draw it
+
window.draw(text);
+
sf::Color::Red
static const Color Red
Red predefined color.
Definition: Color.hpp:85
+
sf::Font
Class for loading and manipulating character fonts.
Definition: Font.hpp:49
+
sf::Font::loadFromFile
bool loadFromFile(const std::string &filename)
Load the font from a file.
+
sf::Text
Graphical text that can be drawn to a render target.
Definition: Text.hpp:49
+
sf::Text::Bold
@ Bold
Bold characters.
Definition: Text.hpp:59
+
See also
sf::Font, sf::Transformable
+ +

Definition at line 48 of file Text.hpp.

+

Member Enumeration Documentation

+ +

◆ Style

+ +
+
+ + + + +
enum sf::Text::Style
+
+ +

Enumeration of the string drawing styles.

+ + + + + + +
Enumerator
Regular 

Regular characters, no style.

+
Bold 

Bold characters.

+
Italic 

Italic characters.

+
Underlined 

Underlined characters.

+
StrikeThrough 

Strike through characters.

+
+ +

Definition at line 56 of file Text.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Text() [1/2]

+ +
+
+ + + + + + + +
sf::Text::Text ()
+
+ +

Default constructor.

+

Creates an empty text.

+ +
+
+ +

◆ Text() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
sf::Text::Text (const String & string,
const Font & font,
unsigned int characterSize = 30 
)
+
+ +

Construct the text from a string, font and size.

+

Note that if the used font is a bitmap font, it is not scalable, thus not all requested sizes will be available to use. This needs to be taken into consideration when setting the character size. If you need to display text of a certain size, make sure the corresponding bitmap font that supports that size is used.

+
Parameters
+ + + + +
stringText assigned to the string
fontFont used to draw the string
characterSizeBase size of characters, in pixels
+
+
+ +
+
+

Member Function Documentation

+ +

◆ findCharacterPos()

+ +
+
+ + + + + + + + +
Vector2f sf::Text::findCharacterPos (std::size_t index) const
+
+ +

Return the position of the index-th character.

+

This function computes the visual position of a character from its index in the string. The returned position is in global coordinates (translation, rotation, scale and origin are applied). If index is out of range, the position of the end of the string is returned.

+
Parameters
+ + +
indexIndex of the character
+
+
+
Returns
Position of the character
+ +
+
+ +

◆ getCharacterSize()

+ +
+
+ + + + + + + +
unsigned int sf::Text::getCharacterSize () const
+
+ +

Get the character size.

+
Returns
Size of the characters, in pixels
+
See also
setCharacterSize
+ +
+
+ +

◆ getColor()

+ +
+
+ + + + + + + +
const Color & sf::Text::getColor () const
+
+ +

Get the fill color of the text.

+
Returns
Fill color of the text
+
See also
setFillColor
+
Deprecated:
There is now fill and outline colors instead of a single global color. Use getFillColor() or getOutlineColor() instead.
+ +
+
+ +

◆ getFillColor()

+ +
+
+ + + + + + + +
const Color & sf::Text::getFillColor () const
+
+ +

Get the fill color of the text.

+
Returns
Fill color of the text
+
See also
setFillColor
+ +
+
+ +

◆ getFont()

+ +
+
+ + + + + + + +
const Font * sf::Text::getFont () const
+
+ +

Get the text's font.

+

If the text has no font attached, a NULL pointer is returned. The returned pointer is const, which means that you cannot modify the font when you get it from this function.

+
Returns
Pointer to the text's font
+
See also
setFont
+ +
+
+ +

◆ getGlobalBounds()

+ +
+
+ + + + + + + +
FloatRect sf::Text::getGlobalBounds () const
+
+ +

Get the global bounding rectangle of the entity.

+

The returned rectangle is in global coordinates, which means that it takes into account the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the text in the global 2D world's coordinate system.

+
Returns
Global bounding rectangle of the entity
+ +
+
+ +

◆ getInverseTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getInverseTransform () const
+ 		+inherited
+
+ +

get the inverse of the combined transform of the object

+
Returns
Inverse of the combined transformations applied to the object
+
See also
getTransform
+ +
+
+ +

◆ getLetterSpacing()

+ +
+
+ + + + + + + +
float sf::Text::getLetterSpacing () const
+
+ +

Get the size of the letter spacing factor.

+
Returns
Size of the letter spacing factor
+
See also
setLetterSpacing
+ +
+
+ +

◆ getLineSpacing()

+ +
+
+ + + + + + + +
float sf::Text::getLineSpacing () const
+
+ +

Get the size of the line spacing factor.

+
Returns
Size of the line spacing factor
+
See also
setLineSpacing
+ +
+
+ +

◆ getLocalBounds()

+ +
+
+ + + + + + + +
FloatRect sf::Text::getLocalBounds () const
+
+ +

Get the local bounding rectangle of the entity.

+

The returned rectangle is in local coordinates, which means that it ignores the transformations (translation, rotation, scale, ...) that are applied to the entity. In other words, this function returns the bounds of the entity in the entity's coordinate system.

+
Returns
Local bounding rectangle of the entity
+ +
+
+ +

◆ getOrigin()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getOrigin () const
+ 		+inherited
+
+ +

get the local origin of the object

+
Returns
Current origin
+
See also
setOrigin
+ +
+
+ +

◆ getOutlineColor()

+ +
+
+ + + + + + + +
const Color & sf::Text::getOutlineColor () const
+
+ +

Get the outline color of the text.

+
Returns
Outline color of the text
+
See also
setOutlineColor
+ +
+
+ +

◆ getOutlineThickness()

+ +
+
+ + + + + + + +
float sf::Text::getOutlineThickness () const
+
+ +

Get the outline thickness of the text.

+
Returns
Outline thickness of the text, in pixels
+
See also
setOutlineThickness
+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getPosition () const
+ 		+inherited
+
+ +

get the position of the object

+
Returns
Current position
+
See also
setPosition
+ +
+
+ +

◆ getRotation()

+ +
+
+ + + + + +
+ + + + + + + +
float sf::Transformable::getRotation () const
+ 		+inherited
+
+ +

get the orientation of the object

+

The rotation is always in the range [0, 360].

+
Returns
Current rotation, in degrees
+
See also
setRotation
+ +
+
+ +

◆ getScale()

+ +
+
+ + + + + +
+ + + + + + + +
const Vector2f & sf::Transformable::getScale () const
+ 		+inherited
+
+ +

get the current scale of the object

+
Returns
Current scale factors
+
See also
setScale
+ +
+
+ +

◆ getString()

+ +
+
+ + + + + + + +
const String & sf::Text::getString () const
+
+ +

Get the text's string.

+

The returned string is a sf::String, which can automatically be converted to standard string types. So, the following lines of code are all valid:

sf::String s1 = text.getString();
+
std::string s2 = text.getString();
+
std::wstring s3 = text.getString();
+
sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition: String.hpp:46
+
Returns
Text's string
+
See also
setString
+ +
+
+ +

◆ getStyle()

+ +
+
+ + + + + + + +
Uint32 sf::Text::getStyle () const
+
+ +

Get the text's style.

+
Returns
Text's style
+
See also
setStyle
+ +
+
+ +

◆ getTransform()

+ +
+
+ + + + + +
+ + + + + + + +
const Transform & sf::Transformable::getTransform () const
+ 		+inherited
+
+ +

get the combined transform of the object

+
Returns
Transform combining the position/rotation/scale/origin of the object
+
See also
getInverseTransform
+ +
+
+ +

◆ move() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::move (const Vector2f & offset)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

object.setPosition(object.getPosition() + offset);
+
sf::Transformable::getPosition
const Vector2f & getPosition() const
get the position of the object
+
Parameters
+ + +
offsetOffset
+
+
+
See also
setPosition
+ +
+
+ +

◆ move() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::move (float offsetX,
float offsetY 
)
+ 		+inherited
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f pos = object.getPosition();
+
object.setPosition(pos.x + offsetX, pos.y + offsetY);
+ +
sf::Vector2::x
T x
X coordinate of the vector.
Definition: Vector2.hpp:75
+
sf::Vector2::y
T y
Y coordinate of the vector.
Definition: Vector2.hpp:76
+
Parameters
+ + + +
offsetXX offset
offsetYY offset
+
+
+
See also
setPosition
+ +
+
+ +

◆ rotate()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::rotate (float angle)
+ 		+inherited
+
+ +

Rotate the object.

+

This function adds to the current rotation of the object, unlike setRotation which overwrites it. Thus, it is equivalent to the following code:

object.setRotation(object.getRotation() + angle);
+
sf::Transformable::getRotation
float getRotation() const
get the orientation of the object
+
Parameters
+ + +
angleAngle of rotation, in degrees
+
+
+ +
+
+ +

◆ scale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::scale (const Vector2f & factor)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factor.x, scale.y * factor.y);
+
sf::Transformable::scale
void scale(float factorX, float factorY)
Scale the object.
+
Parameters
+ + +
factorScale factors
+
+
+
See also
setScale
+ +
+
+ +

◆ scale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::scale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factorX, scale.y * factorY);
+
Parameters
+ + + +
factorXHorizontal scale factor
factorYVertical scale factor
+
+
+
See also
setScale
+ +
+
+ +

◆ setCharacterSize()

+ +
+
+ + + + + + + + +
void sf::Text::setCharacterSize (unsigned int size)
+
+ +

Set the character size.

+

The default size is 30.

+

Note that if the used font is a bitmap font, it is not scalable, thus not all requested sizes will be available to use. This needs to be taken into consideration when setting the character size. If you need to display text of a certain size, make sure the corresponding bitmap font that supports that size is used.

+
Parameters
+ + +
sizeNew character size, in pixels
+
+
+
See also
getCharacterSize
+ +
+
+ +

◆ setColor()

+ +
+
+ + + + + + + + +
void sf::Text::setColor (const Color & color)
+
+ +

Set the fill color of the text.

+

By default, the text's fill color is opaque white. Setting the fill color to a transparent color with an outline will cause the outline to be displayed in the fill area of the text.

+
Parameters
+ + +
colorNew fill color of the text
+
+
+
See also
getFillColor
+
Deprecated:
There is now fill and outline colors instead of a single global color. Use setFillColor() or setOutlineColor() instead.
+ +
+
+ +

◆ setFillColor()

+ +
+
+ + + + + + + + +
void sf::Text::setFillColor (const Color & color)
+
+ +

Set the fill color of the text.

+

By default, the text's fill color is opaque white. Setting the fill color to a transparent color with an outline will cause the outline to be displayed in the fill area of the text.

+
Parameters
+ + +
colorNew fill color of the text
+
+
+
See also
getFillColor
+ +
+
+ +

◆ setFont()

+ +
+
+ + + + + + + + +
void sf::Text::setFont (const Font & font)
+
+ +

Set the text's font.

+

The font argument refers to a font that must exist as long as the text uses it. Indeed, the text doesn't store its own copy of the font, but rather keeps a pointer to the one that you passed to this function. If the font is destroyed and the text tries to use it, the behavior is undefined.

+
Parameters
+ + +
fontNew font
+
+
+
See also
getFont
+ +
+
+ +

◆ setLetterSpacing()

+ +
+
+ + + + + + + + +
void sf::Text::setLetterSpacing (float spacingFactor)
+
+ +

Set the letter spacing factor.

+

The default spacing between letters is defined by the font. This factor doesn't directly apply to the existing spacing between each character, it rather adds a fixed space between them which is calculated from the font metrics and the character size. Note that factors below 1 (including negative numbers) bring characters closer to each other. By default the letter spacing factor is 1.

+
Parameters
+ + +
spacingFactorNew letter spacing factor
+
+
+
See also
getLetterSpacing
+ +
+
+ +

◆ setLineSpacing()

+ +
+
+ + + + + + + + +
void sf::Text::setLineSpacing (float spacingFactor)
+
+ +

Set the line spacing factor.

+

The default spacing between lines is defined by the font. This method enables you to set a factor for the spacing between lines. By default the line spacing factor is 1.

+
Parameters
+ + +
spacingFactorNew line spacing factor
+
+
+
See also
getLineSpacing
+ +
+
+ +

◆ setOrigin() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setOrigin (const Vector2f & origin)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + +
originNew origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOrigin() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setOrigin (float x,
float y 
)
+ 		+inherited
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new origin
yY coordinate of the new origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOutlineColor()

+ +
+
+ + + + + + + + +
void sf::Text::setOutlineColor (const Color & color)
+
+ +

Set the outline color of the text.

+

By default, the text's outline color is opaque black.

+
Parameters
+ + +
colorNew outline color of the text
+
+
+
See also
getOutlineColor
+ +
+
+ +

◆ setOutlineThickness()

+ +
+
+ + + + + + + + +
void sf::Text::setOutlineThickness (float thickness)
+
+ +

Set the thickness of the text's outline.

+

By default, the outline thickness is 0.

+

Be aware that using a negative value for the outline thickness will cause distorted rendering.

+
Parameters
+ + +
thicknessNew outline thickness, in pixels
+
+
+
See also
getOutlineThickness
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setPosition (const Vector2f & position)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + +
positionNew position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setPosition (float x,
float y 
)
+ 		+inherited
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new position
yY coordinate of the new position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setRotation()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setRotation (float angle)
+ 		+inherited
+
+ +

set the orientation of the object

+

This function completely overwrites the previous rotation. See the rotate function to add an angle based on the previous rotation instead. The default rotation of a transformable object is 0.

+
Parameters
+ + +
angleNew rotation, in degrees
+
+
+
See also
rotate, getRotation
+ +
+
+ +

◆ setScale() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Transformable::setScale (const Vector2f & factors)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + +
factorsNew scale factors
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setScale() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setScale (float factorX,
float factorY 
)
+ 		+inherited
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + + +
factorXNew horizontal scale factor
factorYNew vertical scale factor
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setString()

+ +
+
+ + + + + + + + +
void sf::Text::setString (const String & string)
+
+ +

Set the text's string.

+

The string argument is a sf::String, which can automatically be constructed from standard string types. So, the following calls are all valid:

text.setString("hello");
+
text.setString(L"hello");
+
text.setString(std::string("hello"));
+
text.setString(std::wstring(L"hello"));
+

A text's string is empty by default.

+
Parameters
+ + +
stringNew string
+
+
+
See also
getString
+ +
+
+ +

◆ setStyle()

+ +
+
+ + + + + + + + +
void sf::Text::setStyle (Uint32 style)
+
+ +

Set the text's style.

+

You can pass a combination of one or more styles, for example sf::Text::Bold | sf::Text::Italic. The default style is sf::Text::Regular.

+
Parameters
+ + +
styleNew style
+
+
+
See also
getStyle
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Text.png b/Space-Invaders/sfml/doc/html/classsf_1_1Text.png new file mode 100644 index 000000000..7e2d1181f Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Text.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Texture-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Texture-members.html new file mode 100644 index 000000000..6b7b5f0a4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Texture-members.html @@ -0,0 +1,144 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Texture Member List
+
+
+ +

This is the complete list of members for sf::Texture, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bind(const Texture *texture, CoordinateType coordinateType=Normalized)sf::Texturestatic
CoordinateType enum namesf::Texture
copyToImage() constsf::Texture
create(unsigned int width, unsigned int height)sf::Texture
generateMipmap()sf::Texture
getMaximumSize()sf::Texturestatic
getNativeHandle() constsf::Texture
getSize() constsf::Texture
isRepeated() constsf::Texture
isSmooth() constsf::Texture
isSrgb() constsf::Texture
loadFromFile(const std::string &filename, const IntRect &area=IntRect())sf::Texture
loadFromImage(const Image &image, const IntRect &area=IntRect())sf::Texture
loadFromMemory(const void *data, std::size_t size, const IntRect &area=IntRect())sf::Texture
loadFromStream(InputStream &stream, const IntRect &area=IntRect())sf::Texture
Normalized enum valuesf::Texture
operator=(const Texture &right)sf::Texture
Pixels enum valuesf::Texture
RenderTarget (defined in sf::Texture)sf::Texturefriend
RenderTexture (defined in sf::Texture)sf::Texturefriend
setRepeated(bool repeated)sf::Texture
setSmooth(bool smooth)sf::Texture
setSrgb(bool sRgb)sf::Texture
swap(Texture &right)sf::Texture
Text (defined in sf::Texture)sf::Texturefriend
Texture()sf::Texture
Texture(const Texture &copy)sf::Texture
update(const Uint8 *pixels)sf::Texture
update(const Uint8 *pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y)sf::Texture
update(const Texture &texture)sf::Texture
update(const Texture &texture, unsigned int x, unsigned int y)sf::Texture
update(const Image &image)sf::Texture
update(const Image &image, unsigned int x, unsigned int y)sf::Texture
update(const Window &window)sf::Texture
update(const Window &window, unsigned int x, unsigned int y)sf::Texture
~Texture()sf::Texture
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Texture.html b/Space-Invaders/sfml/doc/html/classsf_1_1Texture.html new file mode 100644 index 000000000..ff6e4e25d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Texture.html @@ -0,0 +1,1380 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Static Public Member Functions | +Friends | +List of all members
+
sf::Texture Class Reference
Graphics module
+
+
+ +

Image living on the graphics card that can be used for drawing. + More...

+ +

#include <SFML/Graphics/Texture.hpp>

+
+Inheritance diagram for sf::Texture:
+
+
+ + +sf::GlResource + +
+ + + + + +

+Public Types

enum  CoordinateType { Normalized +, Pixels + }
 Types of texture coordinates that can be used for rendering. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Texture ()
 Default constructor.
 
 Texture (const Texture &copy)
 Copy constructor.
 
 ~Texture ()
 Destructor.
 
bool create (unsigned int width, unsigned int height)
 Create the texture.
 
bool loadFromFile (const std::string &filename, const IntRect &area=IntRect())
 Load the texture from a file on disk.
 
bool loadFromMemory (const void *data, std::size_t size, const IntRect &area=IntRect())
 Load the texture from a file in memory.
 
bool loadFromStream (InputStream &stream, const IntRect &area=IntRect())
 Load the texture from a custom stream.
 
bool loadFromImage (const Image &image, const IntRect &area=IntRect())
 Load the texture from an image.
 
Vector2u getSize () const
 Return the size of the texture.
 
Image copyToImage () const
 Copy the texture pixels to an image.
 
void update (const Uint8 *pixels)
 Update the whole texture from an array of pixels.
 
void update (const Uint8 *pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y)
 Update a part of the texture from an array of pixels.
 
void update (const Texture &texture)
 Update a part of this texture from another texture.
 
void update (const Texture &texture, unsigned int x, unsigned int y)
 Update a part of this texture from another texture.
 
void update (const Image &image)
 Update the texture from an image.
 
void update (const Image &image, unsigned int x, unsigned int y)
 Update a part of the texture from an image.
 
void update (const Window &window)
 Update the texture from the contents of a window.
 
void update (const Window &window, unsigned int x, unsigned int y)
 Update a part of the texture from the contents of a window.
 
void setSmooth (bool smooth)
 Enable or disable the smooth filter.
 
bool isSmooth () const
 Tell whether the smooth filter is enabled or not.
 
void setSrgb (bool sRgb)
 Enable or disable conversion from sRGB.
 
bool isSrgb () const
 Tell whether the texture source is converted from sRGB or not.
 
void setRepeated (bool repeated)
 Enable or disable repeating.
 
bool isRepeated () const
 Tell whether the texture is repeated or not.
 
bool generateMipmap ()
 Generate a mipmap using the current texture data.
 
Texture & operator= (const Texture &right)
 Overload of assignment operator.
 
void swap (Texture &right)
 Swap the contents of this texture with those of another.
 
unsigned int getNativeHandle () const
 Get the underlying OpenGL handle of the texture.
 
+ + + + + + + +

+Static Public Member Functions

static void bind (const Texture *texture, CoordinateType coordinateType=Normalized)
 Bind a texture for rendering.
 
static unsigned int getMaximumSize ()
 Get the maximum texture size allowed.
 
+ + + + + + + +

+Friends

class Text
 
class RenderTexture
 
class RenderTarget
 
+

Detailed Description

+

Image living on the graphics card that can be used for drawing.

+

sf::Texture stores pixels that can be drawn, with a sprite for example.

+

A texture lives in the graphics card memory, therefore it is very fast to draw a texture to a render target, or copy a render target to a texture (the graphics card can access both directly).

+

Being stored in the graphics card memory has some drawbacks. A texture cannot be manipulated as freely as a sf::Image, you need to prepare the pixels first and then upload them to the texture in a single operation (see Texture::update).

+

sf::Texture makes it easy to convert from/to sf::Image, but keep in mind that these calls require transfers between the graphics card and the central memory, therefore they are slow operations.

+

A texture can be loaded from an image, but also directly from a file/memory/stream. The necessary shortcuts are defined so that you don't need an image first for the most common cases. However, if you want to perform some modifications on the pixels before creating the final texture, you can load your file to a sf::Image, do whatever you need with the pixels, and then call Texture::loadFromImage.

+

Since they live in the graphics card memory, the pixels of a texture cannot be accessed without a slow copy first. And they cannot be accessed individually. Therefore, if you need to read the texture's pixels (like for pixel-perfect collisions), it is recommended to store the collision information separately, for example in an array of booleans.

+

Like sf::Image, sf::Texture can handle a unique internal representation of pixels, which is RGBA 32 bits. This means that a pixel must be composed of 8 bits red, green, blue and alpha channels – just like a sf::Color.

+

Usage example:

// This example shows the most common use of sf::Texture:
+
// drawing a sprite
+
+
// Load a texture from a file
+
sf::Texture texture;
+
if (!texture.loadFromFile("texture.png"))
+
return -1;
+
+
// Assign it to a sprite
+
sf::Sprite sprite;
+
sprite.setTexture(texture);
+
+
// Draw the textured sprite
+
window.draw(sprite);
+
sf::Sprite
Drawable representation of a texture, with its own transformations, color, etc.
Definition: Sprite.hpp:48
+
sf::Sprite::setTexture
void setTexture(const Texture &texture, bool resetRect=false)
Change the source texture of the sprite.
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Texture::loadFromFile
bool loadFromFile(const std::string &filename, const IntRect &area=IntRect())
Load the texture from a file on disk.
+
// This example shows another common use of sf::Texture:
+
// streaming real-time data, like video frames
+
+
// Create an empty texture
+
sf::Texture texture;
+
if (!texture.create(640, 480))
+
return -1;
+
+
// Create a sprite that will display the texture
+
sf::Sprite sprite(texture);
+
+
while (...) // the main loop
+
{
+
...
+
+
// update the texture
+
sf::Uint8* pixels = ...; // get a fresh chunk of pixels (the next frame of a movie, for example)
+
texture.update(pixels);
+
+
// draw it
+
window.draw(sprite);
+
+
...
+
}
+
sf::Texture::create
bool create(unsigned int width, unsigned int height)
Create the texture.
+
sf::Texture::update
void update(const Uint8 *pixels)
Update the whole texture from an array of pixels.
+

Like sf::Shader that can be used as a raw OpenGL shader, sf::Texture can also be used directly as a raw texture for custom OpenGL geometry.

sf::Texture::bind(&texture);
+
... render OpenGL geometry ...
+
sf::Texture::bind(NULL);
+
sf::Texture::bind
static void bind(const Texture *texture, CoordinateType coordinateType=Normalized)
Bind a texture for rendering.
+
See also
sf::Sprite, sf::Image, sf::RenderTexture
+ +

Definition at line 48 of file Texture.hpp.

+

Member Enumeration Documentation

+ +

◆ CoordinateType

+ +
+
+ + + + +
enum sf::Texture::CoordinateType
+
+ +

Types of texture coordinates that can be used for rendering.

+ + + +
Enumerator
Normalized 

Texture coordinates in range [0 .. 1].

+
Pixels 

Texture coordinates in range [0 .. size].

+
+ +

Definition at line 56 of file Texture.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ Texture() [1/2]

+ +
+
+ + + + + + + +
sf::Texture::Texture ()
+
+ +

Default constructor.

+

Creates an empty texture.

+ +
+
+ +

◆ Texture() [2/2]

+ +
+
+ + + + + + + + +
sf::Texture::Texture (const Texture & copy)
+
+ +

Copy constructor.

+
Parameters
+ + +
copyinstance to copy
+
+
+ +
+
+ +

◆ ~Texture()

+ +
+
+ + + + + + + +
sf::Texture::~Texture ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ bind()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static void sf::Texture::bind (const Texture * texture,
CoordinateType coordinateType = Normalized 
)
+ 		+static
+
+ +

Bind a texture for rendering.

+

This function is not part of the graphics API, it mustn't be used when drawing SFML entities. It must be used only if you mix sf::Texture with OpenGL code.

+
sf::Texture t1, t2;
+
...
+
sf::Texture::bind(&t1);
+
// draw OpenGL stuff that use t1...
+
sf::Texture::bind(&t2);
+
// draw OpenGL stuff that use t2...
+
sf::Texture::bind(NULL);
+
// draw OpenGL stuff that use no texture...
+

The coordinateType argument controls how texture coordinates will be interpreted. If Normalized (the default), they must be in range [0 .. 1], which is the default way of handling texture coordinates with OpenGL. If Pixels, they must be given in pixels (range [0 .. size]). This mode is used internally by the graphics classes of SFML, it makes the definition of texture coordinates more intuitive for the high-level API, users don't need to compute normalized values.

+
Parameters
+ + + +
texturePointer to the texture to bind, can be null to use no texture
coordinateTypeType of texture coordinates to use
+
+
+ +
+
+ +

◆ copyToImage()

+ +
+
+ + + + + + + +
Image sf::Texture::copyToImage () const
+
+ +

Copy the texture pixels to an image.

+

This function performs a slow operation that downloads the texture's pixels from the graphics card and copies them to a new image, potentially applying transformations to pixels if necessary (texture may be padded or flipped).

+
Returns
Image containing the texture's pixels
+
See also
loadFromImage
+ +
+
+ +

◆ create()

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Texture::create (unsigned int width,
unsigned int height 
)
+
+ +

Create the texture.

+

If this function fails, the texture is left unchanged.

+
Parameters
+ + + +
widthWidth of the texture
heightHeight of the texture
+
+
+
Returns
True if creation was successful
+ +
+
+ +

◆ generateMipmap()

+ +
+
+ + + + + + + +
bool sf::Texture::generateMipmap ()
+
+ +

Generate a mipmap using the current texture data.

+

Mipmaps are pre-computed chains of optimized textures. Each level of texture in a mipmap is generated by halving each of the previous level's dimensions. This is done until the final level has the size of 1x1. The textures generated in this process may make use of more advanced filters which might improve the visual quality of textures when they are applied to objects much smaller than they are. This is known as minification. Because fewer texels (texture elements) have to be sampled from when heavily minified, usage of mipmaps can also improve rendering performance in certain scenarios.

+

Mipmap generation relies on the necessary OpenGL extension being available. If it is unavailable or generation fails due to another reason, this function will return false. Mipmap data is only valid from the time it is generated until the next time the base level image is modified, at which point this function will have to be called again to regenerate it.

+
Returns
True if mipmap generation was successful, false if unsuccessful
+ +
+
+ +

◆ getMaximumSize()

+ +
+
+ + + + + +
+ + + + + + + +
static unsigned int sf::Texture::getMaximumSize ()
+ 		+static
+
+ +

Get the maximum texture size allowed.

+

This maximum size is defined by the graphics driver. You can expect a value of 512 pixels for low-end graphics card, and up to 8192 pixels or more for newer hardware.

+
Returns
Maximum size allowed for textures, in pixels
+ +
+
+ +

◆ getNativeHandle()

+ +
+
+ + + + + + + +
unsigned int sf::Texture::getNativeHandle () const
+
+ +

Get the underlying OpenGL handle of the texture.

+

You shouldn't need to use this function, unless you have very specific stuff to implement that SFML doesn't support, or implement a temporary workaround until a bug is fixed.

+
Returns
OpenGL handle of the texture or 0 if not yet created
+ +
+
+ +

◆ getSize()

+ +
+
+ + + + + + + +
Vector2u sf::Texture::getSize () const
+
+ +

Return the size of the texture.

+
Returns
Size in pixels
+ +
+
+ +

◆ isRepeated()

+ +
+
+ + + + + + + +
bool sf::Texture::isRepeated () const
+
+ +

Tell whether the texture is repeated or not.

+
Returns
True if repeat mode is enabled, false if it is disabled
+
See also
setRepeated
+ +
+
+ +

◆ isSmooth()

+ +
+
+ + + + + + + +
bool sf::Texture::isSmooth () const
+
+ +

Tell whether the smooth filter is enabled or not.

+
Returns
True if smoothing is enabled, false if it is disabled
+
See also
setSmooth
+ +
+
+ +

◆ isSrgb()

+ +
+
+ + + + + + + +
bool sf::Texture::isSrgb () const
+
+ +

Tell whether the texture source is converted from sRGB or not.

+
Returns
True if the texture source is converted from sRGB, false if not
+
See also
setSrgb
+ +
+
+ +

◆ loadFromFile()

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Texture::loadFromFile (const std::string & filename,
const IntRect & area = IntRect() 
)
+
+ +

Load the texture from a file on disk.

+

This function is a shortcut for the following code:

sf::Image image;
+
image.loadFromFile(filename);
+
texture.loadFromImage(image, area);
+
sf::Image
Class for loading, manipulating and saving images.
Definition: Image.hpp:47
+
sf::Image::loadFromFile
bool loadFromFile(const std::string &filename)
Load the image from a file on disk.
+

The area argument can be used to load only a sub-rectangle of the whole image. If you want the entire image then leave the default value (which is an empty IntRect). If the area rectangle crosses the bounds of the image, it is adjusted to fit the image size.

+

The maximum size for a texture depends on the graphics driver and can be retrieved with the getMaximumSize function.

+

If this function fails, the texture is left unchanged.

+
Parameters
+ + + +
filenamePath of the image file to load
areaArea of the image to load
+
+
+
Returns
True if loading was successful
+
See also
loadFromMemory, loadFromStream, loadFromImage
+ +
+
+ +

◆ loadFromImage()

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Texture::loadFromImage (const Image & image,
const IntRect & area = IntRect() 
)
+
+ +

Load the texture from an image.

+

The area argument can be used to load only a sub-rectangle of the whole image. If you want the entire image then leave the default value (which is an empty IntRect). If the area rectangle crosses the bounds of the image, it is adjusted to fit the image size.

+

The maximum size for a texture depends on the graphics driver and can be retrieved with the getMaximumSize function.

+

If this function fails, the texture is left unchanged.

+
Parameters
+ + + +
imageImage to load into the texture
areaArea of the image to load
+
+
+
Returns
True if loading was successful
+
See also
loadFromFile, loadFromMemory
+ +
+
+ +

◆ loadFromMemory()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::Texture::loadFromMemory (const void * data,
std::size_t size,
const IntRect & area = IntRect() 
)
+
+ +

Load the texture from a file in memory.

+

This function is a shortcut for the following code:

sf::Image image;
+
image.loadFromMemory(data, size);
+
texture.loadFromImage(image, area);
+
sf::Image::loadFromMemory
bool loadFromMemory(const void *data, std::size_t size)
Load the image from a file in memory.
+

The area argument can be used to load only a sub-rectangle of the whole image. If you want the entire image then leave the default value (which is an empty IntRect). If the area rectangle crosses the bounds of the image, it is adjusted to fit the image size.

+

The maximum size for a texture depends on the graphics driver and can be retrieved with the getMaximumSize function.

+

If this function fails, the texture is left unchanged.

+
Parameters
+ + + + +
dataPointer to the file data in memory
sizeSize of the data to load, in bytes
areaArea of the image to load
+
+
+
Returns
True if loading was successful
+
See also
loadFromFile, loadFromStream, loadFromImage
+ +
+
+ +

◆ loadFromStream()

+ +
+
+ + + + + + + + + + + + + + + + + + +
bool sf::Texture::loadFromStream (InputStream & stream,
const IntRect & area = IntRect() 
)
+
+ +

Load the texture from a custom stream.

+

This function is a shortcut for the following code:

sf::Image image;
+
image.loadFromStream(stream);
+
texture.loadFromImage(image, area);
+
sf::Image::loadFromStream
bool loadFromStream(InputStream &stream)
Load the image from a custom stream.
+

The area argument can be used to load only a sub-rectangle of the whole image. If you want the entire image then leave the default value (which is an empty IntRect). If the area rectangle crosses the bounds of the image, it is adjusted to fit the image size.

+

The maximum size for a texture depends on the graphics driver and can be retrieved with the getMaximumSize function.

+

If this function fails, the texture is left unchanged.

+
Parameters
+ + + +
streamSource stream to read from
areaArea of the image to load
+
+
+
Returns
True if loading was successful
+
See also
loadFromFile, loadFromMemory, loadFromImage
+ +
+
+ +

◆ operator=()

+ +
+
+ + + + + + + + +
Texture & sf::Texture::operator= (const Texture & right)
+
+ +

Overload of assignment operator.

+
Parameters
+ + +
rightInstance to assign
+
+
+
Returns
Reference to self
+ +
+
+ +

◆ setRepeated()

+ +
+
+ + + + + + + + +
void sf::Texture::setRepeated (bool repeated)
+
+ +

Enable or disable repeating.

+

Repeating is involved when using texture coordinates outside the texture rectangle [0, 0, width, height]. In this case, if repeat mode is enabled, the whole texture will be repeated as many times as needed to reach the coordinate (for example, if the X texture coordinate is 3 * width, the texture will be repeated 3 times). If repeat mode is disabled, the "extra space" will instead be filled with border pixels. Warning: on very old graphics cards, white pixels may appear when the texture is repeated. With such cards, repeat mode can be used reliably only if the texture has power-of-two dimensions (such as 256x128). Repeating is disabled by default.

+
Parameters
+ + +
repeatedTrue to repeat the texture, false to disable repeating
+
+
+
See also
isRepeated
+ +
+
+ +

◆ setSmooth()

+ +
+
+ + + + + + + + +
void sf::Texture::setSmooth (bool smooth)
+
+ +

Enable or disable the smooth filter.

+

When the filter is activated, the texture appears smoother so that pixels are less noticeable. However if you want the texture to look exactly the same as its source file, you should leave it disabled. The smooth filter is disabled by default.

+
Parameters
+ + +
smoothTrue to enable smoothing, false to disable it
+
+
+
See also
isSmooth
+ +
+
+ +

◆ setSrgb()

+ +
+
+ + + + + + + + +
void sf::Texture::setSrgb (bool sRgb)
+
+ +

Enable or disable conversion from sRGB.

+

When providing texture data from an image file or memory, it can either be stored in a linear color space or an sRGB color space. Most digital images account for gamma correction already, so they would need to be "uncorrected" back to linear color space before being processed by the hardware. The hardware can automatically convert it from the sRGB color space to a linear color space when it gets sampled. When the rendered image gets output to the final framebuffer, it gets converted back to sRGB.

+

After enabling or disabling sRGB conversion, make sure to reload the texture data in order for the setting to take effect.

+

This option is only useful in conjunction with an sRGB capable framebuffer. This can be requested during window creation.

+
Parameters
+ + +
sRgbTrue to enable sRGB conversion, false to disable it
+
+
+
See also
isSrgb
+ +
+
+ +

◆ swap()

+ +
+
+ + + + + + + + +
void sf::Texture::swap (Texture & right)
+
+ +

Swap the contents of this texture with those of another.

+
Parameters
+ + +
rightInstance to swap with
+
+
+ +
+
+ +

◆ update() [1/8]

+ +
+
+ + + + + + + + +
void sf::Texture::update (const Image & image)
+
+ +

Update the texture from an image.

+

Although the source image can be smaller than the texture, this function is usually used for updating the whole texture. The other overload, which has (x, y) additional arguments, is more convenient for updating a sub-area of the texture.

+

No additional check is performed on the size of the image, passing an image bigger than the texture will lead to an undefined behavior.

+

This function does nothing if the texture was not previously created.

+
Parameters
+ + +
imageImage to copy to the texture
+
+
+ +
+
+ +

◆ update() [2/8]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Texture::update (const Image & image,
unsigned int x,
unsigned int y 
)
+
+ +

Update a part of the texture from an image.

+

No additional check is performed on the size of the image, passing an invalid combination of image size and offset will lead to an undefined behavior.

+

This function does nothing if the texture was not previously created.

+
Parameters
+ + + + +
imageImage to copy to the texture
xX offset in the texture where to copy the source image
yY offset in the texture where to copy the source image
+
+
+ +
+
+ +

◆ update() [3/8]

+ +
+
+ + + + + + + + +
void sf::Texture::update (const Texture & texture)
+
+ +

Update a part of this texture from another texture.

+

Although the source texture can be smaller than this texture, this function is usually used for updating the whole texture. The other overload, which has (x, y) additional arguments, is more convenient for updating a sub-area of this texture.

+

No additional check is performed on the size of the passed texture, passing a texture bigger than this texture will lead to an undefined behavior.

+

This function does nothing if either texture was not previously created.

+
Parameters
+ + +
textureSource texture to copy to this texture
+
+
+ +
+
+ +

◆ update() [4/8]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Texture::update (const Texture & texture,
unsigned int x,
unsigned int y 
)
+
+ +

Update a part of this texture from another texture.

+

No additional check is performed on the size of the texture, passing an invalid combination of texture size and offset will lead to an undefined behavior.

+

This function does nothing if either texture was not previously created.

+
Parameters
+ + + + +
textureSource texture to copy to this texture
xX offset in this texture where to copy the source texture
yY offset in this texture where to copy the source texture
+
+
+ +
+
+ +

◆ update() [5/8]

+ +
+
+ + + + + + + + +
void sf::Texture::update (const Uint8 * pixels)
+
+ +

Update the whole texture from an array of pixels.

+

The pixel array is assumed to have the same size as the area rectangle, and to contain 32-bits RGBA pixels.

+

No additional check is performed on the size of the pixel array, passing invalid arguments will lead to an undefined behavior.

+

This function does nothing if pixels is null or if the texture was not previously created.

+
Parameters
+ + +
pixelsArray of pixels to copy to the texture
+
+
+ +
+
+ +

◆ update() [6/8]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Texture::update (const Uint8 * pixels,
unsigned int width,
unsigned int height,
unsigned int x,
unsigned int y 
)
+
+ +

Update a part of the texture from an array of pixels.

+

The size of the pixel array must match the width and height arguments, and it must contain 32-bits RGBA pixels.

+

No additional check is performed on the size of the pixel array or the bounds of the area to update, passing invalid arguments will lead to an undefined behavior.

+

This function does nothing if pixels is null or if the texture was not previously created.

+
Parameters
+ + + + + + +
pixelsArray of pixels to copy to the texture
widthWidth of the pixel region contained in pixels
heightHeight of the pixel region contained in pixels
xX offset in the texture where to copy the source pixels
yY offset in the texture where to copy the source pixels
+
+
+ +
+
+ +

◆ update() [7/8]

+ +
+
+ + + + + + + + +
void sf::Texture::update (const Window & window)
+
+ +

Update the texture from the contents of a window.

+

Although the source window can be smaller than the texture, this function is usually used for updating the whole texture. The other overload, which has (x, y) additional arguments, is more convenient for updating a sub-area of the texture.

+

No additional check is performed on the size of the window, passing a window bigger than the texture will lead to an undefined behavior.

+

This function does nothing if either the texture or the window was not previously created.

+
Parameters
+ + +
windowWindow to copy to the texture
+
+
+ +
+
+ +

◆ update() [8/8]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::Texture::update (const Window & window,
unsigned int x,
unsigned int y 
)
+
+ +

Update a part of the texture from the contents of a window.

+

No additional check is performed on the size of the window, passing an invalid combination of window size and offset will lead to an undefined behavior.

+

This function does nothing if either the texture or the window was not previously created.

+
Parameters
+ + + + +
windowWindow to copy to the texture
xX offset in the texture where to copy the source window
yY offset in the texture where to copy the source window
+
+
+ +
+
+

Friends And Related Function Documentation

+ +

◆ RenderTarget

+ +
+
+ + + + + +
+ + + + +
friend class RenderTarget
+ 		+friend
+
+ +

Definition at line 590 of file Texture.hpp.

+ +
+
+ +

◆ RenderTexture

+ +
+
+ + + + + +
+ + + + +
friend class RenderTexture
+ 		+friend
+
+ +

Definition at line 589 of file Texture.hpp.

+ +
+
+ +

◆ Text

+ +
+
+ + + + + +
+ + + + +
friend class Text
+ 		+friend
+
+ +

Definition at line 588 of file Texture.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Texture.png b/Space-Invaders/sfml/doc/html/classsf_1_1Texture.png new file mode 100644 index 000000000..273648dad Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Texture.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Thread-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Thread-members.html new file mode 100644 index 000000000..f16282e68 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Thread-members.html @@ -0,0 +1,115 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Thread Member List
+
+
+ +

This is the complete list of members for sf::Thread, including all inherited members.

+ + + + + + + + +
launch()sf::Thread
terminate()sf::Thread
Thread(F function)sf::Thread
Thread(F function, A argument)sf::Thread
Thread(void(C::*function)(), C *object)sf::Thread
wait()sf::Thread
~Thread()sf::Thread
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Thread.html b/Space-Invaders/sfml/doc/html/classsf_1_1Thread.html new file mode 100644 index 000000000..b0c563f74 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Thread.html @@ -0,0 +1,421 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::Thread Class Reference
System module
+
+
+ +

Utility class to manipulate threads. + More...

+ +

#include <SFML/System/Thread.hpp>

+
+Inheritance diagram for sf::Thread:
+
+
+ + +sf::NonCopyable + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<typename F >
 Thread (F function)
 Construct the thread from a functor with no argument.
 
template<typename F , typename A >
 Thread (F function, A argument)
 Construct the thread from a functor with an argument.
 
template<typename C >
 Thread (void(C::*function)(), C *object)
 Construct the thread from a member function and an object.
 
 ~Thread ()
 Destructor.
 
void launch ()
 Run the thread.
 
void wait ()
 Wait until the thread finishes.
 
void terminate ()
 Terminate the thread.
 
+

Detailed Description

+

Utility class to manipulate threads.

+

Threads provide a way to run multiple parts of the code in parallel.

+

When you launch a new thread, the execution is split and both the new thread and the caller run in parallel.

+

To use a sf::Thread, you construct it directly with the function to execute as the entry point of the thread. sf::Thread has multiple template constructors, which means that you can use several types of entry points:

    +
  • non-member functions with no argument
    • +
  • non-member functions with one argument of any type
    • +
  • functors with no argument (this one is particularly useful for compatibility with boost/std::bind)
    • +
  • functors with one argument of any type
    • +
  • member functions from any class with no argument
    • +
+

The function argument, if any, is copied in the sf::Thread instance, as well as the functor (if the corresponding constructor is used). Class instances, however, are passed by pointer so you must make sure that the object won't be destroyed while the thread is still using it.

+

The thread ends when its function is terminated. If the owner sf::Thread instance is destroyed before the thread is finished, the destructor will wait (see wait())

+

Usage examples:

// example 1: non member function with one argument
+
+
void threadFunc(int argument)
+
{
+
...
+
}
+
+
sf::Thread thread(&threadFunc, 5);
+
thread.launch(); // start the thread (internally calls threadFunc(5))
+
sf::Thread
Utility class to manipulate threads.
Definition: Thread.hpp:49
+
// example 2: member function
+
+
class Task
+
{
+
public:
+
void run()
+
{
+
...
+
}
+
};
+
+
Task task;
+
sf::Thread thread(&Task::run, &task);
+
thread.launch(); // start the thread (internally calls task.run())
+
// example 3: functor
+
+
struct Task
+
{
+
void operator()()
+
{
+
...
+
}
+
};
+
+
sf::Thread thread(Task());
+
thread.launch(); // start the thread (internally calls operator() on the Task instance)
+

Creating parallel threads of execution can be dangerous: all threads inside the same process share the same memory space, which means that you may end up accessing the same variable from multiple threads at the same time. To prevent this kind of situations, you can use mutexes (see sf::Mutex).

+
See also
sf::Mutex
+ +

Definition at line 48 of file Thread.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Thread() [1/3]

+ +
+
+
+template<typename F >
+ + + + + + + + +
sf::Thread::Thread (F function)
+
+ +

Construct the thread from a functor with no argument.

+

This constructor works for function objects, as well as free functions.

+

Use this constructor for this kind of function:

void function();
+
+
// --- or ----
+
+
struct Functor
+
{
+
void operator()();
+
};
+

Note: this does not run the thread, use launch().

+
Parameters
+ + +
functionFunctor or free function to use as the entry point of the thread
+
+
+ +
+
+ +

◆ Thread() [2/3]

+ +
+
+
+template<typename F , typename A >
+ + + + + + + + + + + + + + + + + + +
sf::Thread::Thread (F function,
A argument 
)
+
+ +

Construct the thread from a functor with an argument.

+

This constructor works for function objects, as well as free functions. It is a template, which means that the argument can have any type (int, std::string, void*, Toto, ...).

+

Use this constructor for this kind of function:

void function(int arg);
+
+
// --- or ----
+
+
struct Functor
+
{
+
void operator()(std::string arg);
+
};
+

Note: this does not run the thread, use launch().

+
Parameters
+ + + +
functionFunctor or free function to use as the entry point of the thread
argumentargument to forward to the function
+
+
+ +
+
+ +

◆ Thread() [3/3]

+ +
+
+
+template<typename C >
+ + + + + + + + + + + + + + + + + + +
sf::Thread::Thread (void(C::*)() function,
C * object 
)
+
+ +

Construct the thread from a member function and an object.

+

This constructor is a template, which means that you can use it with any class. Use this constructor for this kind of function:

class MyClass
+
{
+
public:
+
+
void function();
+
};
+

Note: this does not run the thread, use launch().

+
Parameters
+ + + +
functionEntry point of the thread
objectPointer to the object to use
+
+
+ +
+
+ +

◆ ~Thread()

+ +
+
+ + + + + + + +
sf::Thread::~Thread ()
+
+ +

Destructor.

+

This destructor calls wait(), so that the internal thread cannot survive after its sf::Thread instance is destroyed.

+ +
+
+

Member Function Documentation

+ +

◆ launch()

+ +
+
+ + + + + + + +
void sf::Thread::launch ()
+
+ +

Run the thread.

+

This function starts the entry point passed to the thread's constructor, and returns immediately. After this function returns, the thread's function is running in parallel to the calling code.

+ +
+
+ +

◆ terminate()

+ +
+
+ + + + + + + +
void sf::Thread::terminate ()
+
+ +

Terminate the thread.

+

This function immediately stops the thread, without waiting for its function to finish. Terminating a thread with this function is not safe, and can lead to local variables not being destroyed on some operating systems. You should rather try to make the thread function terminate by itself.

+ +
+
+ +

◆ wait()

+ +
+
+ + + + + + + +
void sf::Thread::wait ()
+
+ +

Wait until the thread finishes.

+

This function will block the execution until the thread's function ends. Warning: if the thread function never ends, the calling thread will block forever. If this function is called from its owner thread, it returns without doing anything.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Thread.png b/Space-Invaders/sfml/doc/html/classsf_1_1Thread.png new file mode 100644 index 000000000..214bcc32d Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Thread.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocal-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocal-members.html new file mode 100644 index 000000000..4d31e15d2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocal-members.html @@ -0,0 +1,112 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::ThreadLocal Member List
+
+
+ +

This is the complete list of members for sf::ThreadLocal, including all inherited members.

+ + + + + +
getValue() constsf::ThreadLocal
setValue(void *value)sf::ThreadLocal
ThreadLocal(void *value=NULL)sf::ThreadLocal
~ThreadLocal()sf::ThreadLocal
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocal.html b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocal.html new file mode 100644 index 000000000..232244899 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocal.html @@ -0,0 +1,241 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::ThreadLocal Class Reference
System module
+
+
+ +

Defines variables with thread-local storage. + More...

+ +

#include <SFML/System/ThreadLocal.hpp>

+
+Inheritance diagram for sf::ThreadLocal:
+
+
+ + +sf::NonCopyable +sf::ThreadLocalPtr< T > + +
+ + + + + + + + + + + + + + +

+Public Member Functions

 ThreadLocal (void *value=NULL)
 Default constructor.
 
 ~ThreadLocal ()
 Destructor.
 
void setValue (void *value)
 Set the thread-specific value of the variable.
 
void * getValue () const
 Retrieve the thread-specific value of the variable.
 
+

Detailed Description

+

Defines variables with thread-local storage.

+

This class manipulates void* parameters and thus is not appropriate for strongly-typed variables.

+

You should rather use the sf::ThreadLocalPtr template class.

+ +

Definition at line 47 of file ThreadLocal.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ThreadLocal()

+ +
+
+ + + + + + + + +
sf::ThreadLocal::ThreadLocal (void * value = NULL)
+
+ +

Default constructor.

+
Parameters
+ + +
valueOptional value to initialize the variable
+
+
+ +
+
+ +

◆ ~ThreadLocal()

+ +
+
+ + + + + + + +
sf::ThreadLocal::~ThreadLocal ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ getValue()

+ +
+
+ + + + + + + +
void * sf::ThreadLocal::getValue () const
+
+ +

Retrieve the thread-specific value of the variable.

+
Returns
Value of the variable for the current thread
+ +
+
+ +

◆ setValue()

+ +
+
+ + + + + + + + +
void sf::ThreadLocal::setValue (void * value)
+
+ +

Set the thread-specific value of the variable.

+
Parameters
+ + +
valueValue of the variable for the current thread
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocal.png b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocal.png new file mode 100644 index 000000000..e5d1c5b96 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocal.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocalPtr-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocalPtr-members.html new file mode 100644 index 000000000..6180942d1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocalPtr-members.html @@ -0,0 +1,114 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::ThreadLocalPtr< T > Member List
+
+
+ +

This is the complete list of members for sf::ThreadLocalPtr< T >, including all inherited members.

+ + + + + + + +
operator T*() constsf::ThreadLocalPtr< T >
operator*() constsf::ThreadLocalPtr< T >
operator->() constsf::ThreadLocalPtr< T >
operator=(T *value)sf::ThreadLocalPtr< T >
operator=(const ThreadLocalPtr< T > &right)sf::ThreadLocalPtr< T >
ThreadLocalPtr(T *value=NULL)sf::ThreadLocalPtr< T >
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocalPtr.html b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocalPtr.html new file mode 100644 index 000000000..e59fe96a4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocalPtr.html @@ -0,0 +1,340 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::ThreadLocalPtr< T > Class Template Reference
System module
+
+
+ +

Pointer to a thread-local variable. + More...

+ +

#include <SFML/System/ThreadLocalPtr.hpp>

+
+Inheritance diagram for sf::ThreadLocalPtr< T >:
+
+
+ + +sf::ThreadLocal + +
+ + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 ThreadLocalPtr (T *value=NULL)
 Default constructor.
 
T & operator* () const
 Overload of unary operator *.
 
T * operator-> () const
 Overload of operator ->
 
 operator T* () const
 Conversion operator to implicitly convert the pointer to its raw pointer type (T*)
 
ThreadLocalPtr< T > & operator= (T *value)
 Assignment operator for a raw pointer parameter.
 
ThreadLocalPtr< T > & operator= (const ThreadLocalPtr< T > &right)
 Assignment operator for a ThreadLocalPtr parameter.
 
+

Detailed Description

+
template<typename T>
+class sf::ThreadLocalPtr< T >

Pointer to a thread-local variable.

+

sf::ThreadLocalPtr is a type-safe wrapper for storing pointers to thread-local variables.

+

A thread-local variable holds a different value for each different thread, unlike normal variables that are shared.

+

Its usage is completely transparent, so that it is similar to manipulating the raw pointer directly (like any smart pointer).

+

Usage example:

MyClass object1;
+
MyClass object2;
+
sf::ThreadLocalPtr<MyClass> objectPtr;
+
+
void thread1()
+
{
+
objectPtr = &object1; // doesn't impact thread2
+
...
+
}
+
+
void thread2()
+
{
+
objectPtr = &object2; // doesn't impact thread1
+
...
+
}
+
+
int main()
+
{
+
// Create and launch the two threads
+
sf::Thread t1(&thread1);
+
sf::Thread t2(&thread2);
+
t1.launch();
+
t2.launch();
+
+
return 0;
+
}
+
sf::ThreadLocalPtr
Pointer to a thread-local variable.
Definition: ThreadLocalPtr.hpp:42
+
sf::Thread
Utility class to manipulate threads.
Definition: Thread.hpp:49
+

ThreadLocalPtr is designed for internal use; however you can use it if you feel like it fits well your implementation.

+ +

Definition at line 41 of file ThreadLocalPtr.hpp.

+

Constructor & Destructor Documentation

+ +

◆ ThreadLocalPtr()

+ +
+
+
+template<typename T >
+ + + + + + + + +
sf::ThreadLocalPtr< T >::ThreadLocalPtr (T * value = NULL)
+
+ +

Default constructor.

+
Parameters
+ + +
valueOptional value to initialize the variable
+
+
+ +
+
+

Member Function Documentation

+ +

◆ operator T*()

+ +
+
+
+template<typename T >
+ + + + + + + +
sf::ThreadLocalPtr< T >::operator T* () const
+
+ +

Conversion operator to implicitly convert the pointer to its raw pointer type (T*)

+
Returns
Pointer to the actual object
+ +
+
+ +

◆ operator*()

+ +
+
+
+template<typename T >
+ + + + + + + +
T & sf::ThreadLocalPtr< T >::operator* () const
+
+ +

Overload of unary operator *.

+

Like raw pointers, applying the * operator returns a reference to the pointed-to object.

+
Returns
Reference to the thread-local variable
+ +
+
+ +

◆ operator->()

+ +
+
+
+template<typename T >
+ + + + + + + +
T * sf::ThreadLocalPtr< T >::operator-> () const
+
+ +

Overload of operator ->

+

Similarly to raw pointers, applying the -> operator returns the pointed-to object.

+
Returns
Pointer to the thread-local variable
+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<typename T >
+ + + + + + + + +
ThreadLocalPtr< T > & sf::ThreadLocalPtr< T >::operator= (const ThreadLocalPtr< T > & right)
+
+ +

Assignment operator for a ThreadLocalPtr parameter.

+
Parameters
+ + +
rightThreadLocalPtr to assign
+
+
+
Returns
Reference to self
+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<typename T >
+ + + + + + + + +
ThreadLocalPtr< T > & sf::ThreadLocalPtr< T >::operator= (T * value)
+
+ +

Assignment operator for a raw pointer parameter.

+
Parameters
+ + +
valuePointer to assign
+
+
+
Returns
Reference to self
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocalPtr.png b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocalPtr.png new file mode 100644 index 000000000..783a9cced Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1ThreadLocalPtr.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Time-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Time-members.html new file mode 100644 index 000000000..3db679115 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Time-members.html @@ -0,0 +1,143 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Time Member List
+
+
+ +

This is the complete list of members for sf::Time, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
asMicroseconds() constsf::Time
asMilliseconds() constsf::Time
asSeconds() constsf::Time
microseconds (defined in sf::Time)sf::Timefriend
microseconds(Int64 amount)sf::Timerelated
milliseconds (defined in sf::Time)sf::Timefriend
milliseconds(Int32 amount)sf::Timerelated
operator!=(Time left, Time right)sf::Timerelated
operator%(Time left, Time right)sf::Timerelated
operator%=(Time &left, Time right)sf::Timerelated
operator*(Time left, float right)sf::Timerelated
operator*(Time left, Int64 right)sf::Timerelated
operator*(float left, Time right)sf::Timerelated
operator*(Int64 left, Time right)sf::Timerelated
operator*=(Time &left, float right)sf::Timerelated
operator*=(Time &left, Int64 right)sf::Timerelated
operator+(Time left, Time right)sf::Timerelated
operator+=(Time &left, Time right)sf::Timerelated
operator-(Time right)sf::Timerelated
operator-(Time left, Time right)sf::Timerelated
operator-=(Time &left, Time right)sf::Timerelated
operator/(Time left, float right)sf::Timerelated
operator/(Time left, Int64 right)sf::Timerelated
operator/(Time left, Time right)sf::Timerelated
operator/=(Time &left, float right)sf::Timerelated
operator/=(Time &left, Int64 right)sf::Timerelated
operator<(Time left, Time right)sf::Timerelated
operator<=(Time left, Time right)sf::Timerelated
operator==(Time left, Time right)sf::Timerelated
operator>(Time left, Time right)sf::Timerelated
operator>=(Time left, Time right)sf::Timerelated
seconds (defined in sf::Time)sf::Timefriend
seconds(float amount)sf::Timerelated
Time()sf::Time
Zerosf::Timestatic
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Time.html b/Space-Invaders/sfml/doc/html/classsf_1_1Time.html new file mode 100644 index 000000000..94b88f88c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Time.html @@ -0,0 +1,1581 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Static Public Attributes | +Friends | +Related Functions | +List of all members
+
sf::Time Class Reference
System module
+
+
+ +

Represents a time value. + More...

+ +

#include <SFML/System/Time.hpp>

+ + + + + + + + + + + + + + +

+Public Member Functions

 Time ()
 Default constructor.
 
float asSeconds () const
 Return the time value as a number of seconds.
 
Int32 asMilliseconds () const
 Return the time value as a number of milliseconds.
 
Int64 asMicroseconds () const
 Return the time value as a number of microseconds.
 
+ + + + +

+Static Public Attributes

static const Time Zero
 Predefined "zero" time value.
 
+ + + + + + + +

+Friends

+Time seconds (float)
 
+Time milliseconds (Int32)
 
+Time microseconds (Int64)
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Related Functions

(Note that these are not member functions.)

+
Time seconds (float amount)
 Construct a time value from a number of seconds.
 
Time milliseconds (Int32 amount)
 Construct a time value from a number of milliseconds.
 
Time microseconds (Int64 amount)
 Construct a time value from a number of microseconds.
 
bool operator== (Time left, Time right)
 Overload of == operator to compare two time values.
 
bool operator!= (Time left, Time right)
 Overload of != operator to compare two time values.
 
bool operator< (Time left, Time right)
 Overload of < operator to compare two time values.
 
bool operator> (Time left, Time right)
 Overload of > operator to compare two time values.
 
bool operator<= (Time left, Time right)
 Overload of <= operator to compare two time values.
 
bool operator>= (Time left, Time right)
 Overload of >= operator to compare two time values.
 
Time operator- (Time right)
 Overload of unary - operator to negate a time value.
 
Time operator+ (Time left, Time right)
 Overload of binary + operator to add two time values.
 
Time & operator+= (Time &left, Time right)
 Overload of binary += operator to add/assign two time values.
 
Time operator- (Time left, Time right)
 Overload of binary - operator to subtract two time values.
 
Time & operator-= (Time &left, Time right)
 Overload of binary -= operator to subtract/assign two time values.
 
Time operator* (Time left, float right)
 Overload of binary * operator to scale a time value.
 
Time operator* (Time left, Int64 right)
 Overload of binary * operator to scale a time value.
 
Time operator* (float left, Time right)
 Overload of binary * operator to scale a time value.
 
Time operator* (Int64 left, Time right)
 Overload of binary * operator to scale a time value.
 
Time & operator*= (Time &left, float right)
 Overload of binary *= operator to scale/assign a time value.
 
Time & operator*= (Time &left, Int64 right)
 Overload of binary *= operator to scale/assign a time value.
 
Time operator/ (Time left, float right)
 Overload of binary / operator to scale a time value.
 
Time operator/ (Time left, Int64 right)
 Overload of binary / operator to scale a time value.
 
Time & operator/= (Time &left, float right)
 Overload of binary /= operator to scale/assign a time value.
 
Time & operator/= (Time &left, Int64 right)
 Overload of binary /= operator to scale/assign a time value.
 
float operator/ (Time left, Time right)
 Overload of binary / operator to compute the ratio of two time values.
 
Time operator% (Time left, Time right)
 Overload of binary % operator to compute remainder of a time value.
 
Time & operator%= (Time &left, Time right)
 Overload of binary %= operator to compute/assign remainder of a time value.
 
+

Detailed Description

+

Represents a time value.

+

sf::Time encapsulates a time value in a flexible way.

+

It allows to define a time value either as a number of seconds, milliseconds or microseconds. It also works the other way round: you can read a time value as either a number of seconds, milliseconds or microseconds.

+

By using such a flexible interface, the API doesn't impose any fixed type or resolution for time values, and let the user choose its own favorite representation.

+

Time values support the usual mathematical operations: you can add or subtract two times, multiply or divide a time by a number, compare two times, etc.

+

Since they represent a time span and not an absolute time value, times can also be negative.

+

Usage example:

sf::Time t1 = sf::seconds(0.1f);
+
Int32 milli = t1.asMilliseconds(); // 100
+
+
sf::Time t2 = sf::milliseconds(30);
+
Int64 micro = t2.asMicroseconds(); // 30000
+
+
sf::Time t3 = sf::microseconds(-800000);
+
float sec = t3.asSeconds(); // -0.8
+
sf::Time
Represents a time value.
Definition: Time.hpp:41
+
sf::Time::asMicroseconds
Int64 asMicroseconds() const
Return the time value as a number of microseconds.
+
sf::Time::asMilliseconds
Int32 asMilliseconds() const
Return the time value as a number of milliseconds.
+
sf::Time::asSeconds
float asSeconds() const
Return the time value as a number of seconds.
+
void update(sf::Time elapsed)
+
{
+
position += speed * elapsed.asSeconds();
+
}
+
+
update(sf::milliseconds(100));
+
See also
sf::Clock
+ +

Definition at line 40 of file Time.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Time()

+ +
+
+ + + + + + + +
sf::Time::Time ()
+
+ +

Default constructor.

+

Sets the time value to zero.

+ +
+
+

Member Function Documentation

+ +

◆ asMicroseconds()

+ +
+
+ + + + + + + +
Int64 sf::Time::asMicroseconds () const
+
+ +

Return the time value as a number of microseconds.

+
Returns
Time in microseconds
+
See also
asSeconds, asMilliseconds
+ +
+
+ +

◆ asMilliseconds()

+ +
+
+ + + + + + + +
Int32 sf::Time::asMilliseconds () const
+
+ +

Return the time value as a number of milliseconds.

+
Returns
Time in milliseconds
+
See also
asSeconds, asMicroseconds
+ +
+
+ +

◆ asSeconds()

+ +
+
+ + + + + + + +
float sf::Time::asSeconds () const
+
+ +

Return the time value as a number of seconds.

+
Returns
Time in seconds
+
See also
asMilliseconds, asMicroseconds
+ +
+
+

Friends And Related Function Documentation

+ +

◆ microseconds()

+ +
+
+ + + + + +
+ + + + + + + + +
Time microseconds (Int64 amount)
+ 		+related
+
+ +

Construct a time value from a number of microseconds.

+
Parameters
+ + +
amountNumber of microseconds
+
+
+
Returns
Time value constructed from the amount of microseconds
+
See also
seconds, milliseconds
+ +
+
+ +

◆ milliseconds()

+ +
+
+ + + + + +
+ + + + + + + + +
Time milliseconds (Int32 amount)
+ 		+related
+
+ +

Construct a time value from a number of milliseconds.

+
Parameters
+ + +
amountNumber of milliseconds
+
+
+
Returns
Time value constructed from the amount of milliseconds
+
See also
seconds, microseconds
+ +
+
+ +

◆ operator!=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (Time left,
Time right 
)
+ 		+related
+
+ +

Overload of != operator to compare two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
True if both time values are different
+ +
+
+ +

◆ operator%()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time operator% (Time left,
Time right 
)
+ 		+related
+
+ +

Overload of binary % operator to compute remainder of a time value.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
left modulo right
+ +
+
+ +

◆ operator%=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time & operator%= (Time & left,
Time right 
)
+ 		+related
+
+ +

Overload of binary %= operator to compute/assign remainder of a time value.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
left modulo right
+ +
+
+ +

◆ operator*() [1/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time operator* (float left,
Time right 
)
+ 		+related
+
+ +

Overload of binary * operator to scale a time value.

+
Parameters
+ + + +
leftLeft operand (a number)
rightRight operand (a time)
+
+
+
Returns
left multiplied by right
+ +
+
+ +

◆ operator*() [2/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time operator* (Int64 left,
Time right 
)
+ 		+related
+
+ +

Overload of binary * operator to scale a time value.

+
Parameters
+ + + +
leftLeft operand (a number)
rightRight operand (a time)
+
+
+
Returns
left multiplied by right
+ +
+
+ +

◆ operator*() [3/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time operator* (Time left,
float right 
)
+ 		+related
+
+ +

Overload of binary * operator to scale a time value.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a number)
+
+
+
Returns
left multiplied by right
+ +
+
+ +

◆ operator*() [4/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time operator* (Time left,
Int64 right 
)
+ 		+related
+
+ +

Overload of binary * operator to scale a time value.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a number)
+
+
+
Returns
left multiplied by right
+ +
+
+ +

◆ operator*=() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time & operator*= (Time & left,
float right 
)
+ 		+related
+
+ +

Overload of binary *= operator to scale/assign a time value.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a number)
+
+
+
Returns
left multiplied by right
+ +
+
+ +

◆ operator*=() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time & operator*= (Time & left,
Int64 right 
)
+ 		+related
+
+ +

Overload of binary *= operator to scale/assign a time value.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a number)
+
+
+
Returns
left multiplied by right
+ +
+
+ +

◆ operator+()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time operator+ (Time left,
Time right 
)
+ 		+related
+
+ +

Overload of binary + operator to add two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
Sum of the two times values
+ +
+
+ +

◆ operator+=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time & operator+= (Time & left,
Time right 
)
+ 		+related
+
+ +

Overload of binary += operator to add/assign two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
Sum of the two times values
+ +
+
+ +

◆ operator-() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time operator- (Time left,
Time right 
)
+ 		+related
+
+ +

Overload of binary - operator to subtract two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
Difference of the two times values
+ +
+
+ +

◆ operator-() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
Time operator- (Time right)
+ 		+related
+
+ +

Overload of unary - operator to negate a time value.

+
Parameters
+ + +
rightRight operand (a time)
+
+
+
Returns
Opposite of the time value
+ +
+
+ +

◆ operator-=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time & operator-= (Time & left,
Time right 
)
+ 		+related
+
+ +

Overload of binary -= operator to subtract/assign two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
Difference of the two times values
+ +
+
+ +

◆ operator/() [1/3]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time operator/ (Time left,
float right 
)
+ 		+related
+
+ +

Overload of binary / operator to scale a time value.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a number)
+
+
+
Returns
left divided by right
+ +
+
+ +

◆ operator/() [2/3]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time operator/ (Time left,
Int64 right 
)
+ 		+related
+
+ +

Overload of binary / operator to scale a time value.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a number)
+
+
+
Returns
left divided by right
+ +
+
+ +

◆ operator/() [3/3]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
float operator/ (Time left,
Time right 
)
+ 		+related
+
+ +

Overload of binary / operator to compute the ratio of two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
left divided by right
+ +
+
+ +

◆ operator/=() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time & operator/= (Time & left,
float right 
)
+ 		+related
+
+ +

Overload of binary /= operator to scale/assign a time value.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a number)
+
+
+
Returns
left divided by right
+ +
+
+ +

◆ operator/=() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Time & operator/= (Time & left,
Int64 right 
)
+ 		+related
+
+ +

Overload of binary /= operator to scale/assign a time value.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a number)
+
+
+
Returns
left divided by right
+ +
+
+ +

◆ operator<()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator< (Time left,
Time right 
)
+ 		+related
+
+ +

Overload of < operator to compare two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
True if left is lesser than right
+ +
+
+ +

◆ operator<=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator<= (Time left,
Time right 
)
+ 		+related
+
+ +

Overload of <= operator to compare two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
True if left is lesser or equal than right
+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (Time left,
Time right 
)
+ 		+related
+
+ +

Overload of == operator to compare two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
True if both time values are equal
+ +
+
+ +

◆ operator>()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator> (Time left,
Time right 
)
+ 		+related
+
+ +

Overload of > operator to compare two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
True if left is greater than right
+ +
+
+ +

◆ operator>=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator>= (Time left,
Time right 
)
+ 		+related
+
+ +

Overload of >= operator to compare two time values.

+
Parameters
+ + + +
leftLeft operand (a time)
rightRight operand (a time)
+
+
+
Returns
True if left is greater or equal than right
+ +
+
+ +

◆ seconds()

+ +
+
+ + + + + +
+ + + + + + + + +
Time seconds (float amount)
+ 		+related
+
+ +

Construct a time value from a number of seconds.

+
Parameters
+ + +
amountNumber of seconds
+
+
+
Returns
Time value constructed from the amount of seconds
+
See also
milliseconds, microseconds
+ +
+
+

Member Data Documentation

+ +

◆ Zero

+ +
+
+ + + + + +
+ + + + +
const Time sf::Time::Zero
+ 		+static
+
+ +

Predefined "zero" time value.

+ +

Definition at line 85 of file Time.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Touch-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Touch-members.html new file mode 100644 index 000000000..f294a464c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Touch-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Touch Member List
+
+
+ +

This is the complete list of members for sf::Touch, including all inherited members.

+ + + + +
getPosition(unsigned int finger)sf::Touchstatic
getPosition(unsigned int finger, const WindowBase &relativeTo)sf::Touchstatic
isDown(unsigned int finger)sf::Touchstatic
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Touch.html b/Space-Invaders/sfml/doc/html/classsf_1_1Touch.html new file mode 100644 index 000000000..56712b0f7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Touch.html @@ -0,0 +1,271 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +List of all members
+
sf::Touch Class Reference
Window module
+
+
+ +

Give access to the real-time state of the touches. + More...

+ +

#include <SFML/Window/Touch.hpp>

+ + + + + + + + + + + +

+Static Public Member Functions

static bool isDown (unsigned int finger)
 Check if a touch event is currently down.
 
static Vector2i getPosition (unsigned int finger)
 Get the current position of a touch in desktop coordinates.
 
static Vector2i getPosition (unsigned int finger, const WindowBase &relativeTo)
 Get the current position of a touch in window coordinates.
 
+

Detailed Description

+

Give access to the real-time state of the touches.

+

sf::Touch provides an interface to the state of the touches.

+

It only contains static functions, so it's not meant to be instantiated.

+

This class allows users to query the touches state at any time and directly, without having to deal with a window and its events. Compared to the TouchBegan, TouchMoved and TouchEnded events, sf::Touch can retrieve the state of the touches at any time (you don't need to store and update a boolean on your side in order to know if a touch is down), and you always get the real state of the touches, even if they happen when your window is out of focus and no event is triggered.

+

The getPosition function can be used to retrieve the current position of a touch. There are two versions: one that operates in global coordinates (relative to the desktop) and one that operates in window coordinates (relative to a specific window).

+

Touches are identified by an index (the "finger"), so that in multi-touch events, individual touches can be tracked correctly. As long as a finger touches the screen, it will keep the same index even if other fingers start or stop touching the screen in the meantime. As a consequence, active touch indices may not always be sequential (i.e. touch number 0 may be released while touch number 1 is still down).

+

Usage example:

if (sf::Touch::isDown(0))
+
{
+
// touch 0 is down
+
}
+
+
// get global position of touch 1
+
sf::Vector2i globalPos = sf::Touch::getPosition(1);
+
+
// get position of touch 1 relative to a window
+
sf::Vector2i relativePos = sf::Touch::getPosition(1, window);
+
sf::Touch::isDown
static bool isDown(unsigned int finger)
Check if a touch event is currently down.
+
sf::Touch::getPosition
static Vector2i getPosition(unsigned int finger)
Get the current position of a touch in desktop coordinates.
+
sf::Vector2
Utility template class for manipulating 2-dimensional vectors.
Definition: Vector2.hpp:38
+
See also
sf::Joystick, sf::Keyboard, sf::Mouse
+ +

Definition at line 43 of file Touch.hpp.

+

Member Function Documentation

+ +

◆ getPosition() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + +
static Vector2i sf::Touch::getPosition (unsigned int finger)
+ 		+static
+
+ +

Get the current position of a touch in desktop coordinates.

+

This function returns the current touch position in global (desktop) coordinates.

+
Parameters
+ + +
fingerFinger index
+
+
+
Returns
Current position of finger, or undefined if it's not down
+ +
+
+ +

◆ getPosition() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static Vector2i sf::Touch::getPosition (unsigned int finger,
const WindowBase & relativeTo 
)
+ 		+static
+
+ +

Get the current position of a touch in window coordinates.

+

This function returns the current touch position relative to the given window.

+
Parameters
+ + + +
fingerFinger index
relativeToReference window
+
+
+
Returns
Current position of finger, or undefined if it's not down
+ +
+
+ +

◆ isDown()

+ +
+
+ + + + + +
+ + + + + + + + +
static bool sf::Touch::isDown (unsigned int finger)
+ 		+static
+
+ +

Check if a touch event is currently down.

+
Parameters
+ + +
fingerFinger index
+
+
+
Returns
True if finger is currently touching the screen, false otherwise
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Transform-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Transform-members.html new file mode 100644 index 000000000..53a965545 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Transform-members.html @@ -0,0 +1,131 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Transform Member List
+
+
+ +

This is the complete list of members for sf::Transform, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + +
combine(const Transform &transform)sf::Transform
getInverse() constsf::Transform
getMatrix() constsf::Transform
Identitysf::Transformstatic
operator!=(const Transform &left, const Transform &right)sf::Transformrelated
operator*(const Transform &left, const Transform &right)sf::Transformrelated
operator*(const Transform &left, const Vector2f &right)sf::Transformrelated
operator*=(Transform &left, const Transform &right)sf::Transformrelated
operator==(const Transform &left, const Transform &right)sf::Transformrelated
rotate(float angle)sf::Transform
rotate(float angle, float centerX, float centerY)sf::Transform
rotate(float angle, const Vector2f &center)sf::Transform
scale(float scaleX, float scaleY)sf::Transform
scale(float scaleX, float scaleY, float centerX, float centerY)sf::Transform
scale(const Vector2f &factors)sf::Transform
scale(const Vector2f &factors, const Vector2f &center)sf::Transform
Transform()sf::Transform
Transform(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22)sf::Transform
transformPoint(float x, float y) constsf::Transform
transformPoint(const Vector2f &point) constsf::Transform
transformRect(const FloatRect &rectangle) constsf::Transform
translate(float x, float y)sf::Transform
translate(const Vector2f &offset)sf::Transform
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Transform.html b/Space-Invaders/sfml/doc/html/classsf_1_1Transform.html new file mode 100644 index 000000000..c7a19b10d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Transform.html @@ -0,0 +1,1134 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Static Public Attributes | +Related Functions | +List of all members
+
sf::Transform Class Reference
Graphics module
+
+
+ +

Define a 3x3 transform matrix. + More...

+ +

#include <SFML/Graphics/Transform.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Transform ()
 Default constructor.
 
 Transform (float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22)
 Construct a transform from a 3x3 matrix.
 
const float * getMatrix () const
 Return the transform as a 4x4 matrix.
 
Transform getInverse () const
 Return the inverse of the transform.
 
Vector2f transformPoint (float x, float y) const
 Transform a 2D point.
 
Vector2f transformPoint (const Vector2f &point) const
 Transform a 2D point.
 
FloatRect transformRect (const FloatRect &rectangle) const
 Transform a rectangle.
 
Transform & combine (const Transform &transform)
 Combine the current transform with another one.
 
Transform & translate (float x, float y)
 Combine the current transform with a translation.
 
Transform & translate (const Vector2f &offset)
 Combine the current transform with a translation.
 
Transform & rotate (float angle)
 Combine the current transform with a rotation.
 
Transform & rotate (float angle, float centerX, float centerY)
 Combine the current transform with a rotation.
 
Transform & rotate (float angle, const Vector2f &center)
 Combine the current transform with a rotation.
 
Transform & scale (float scaleX, float scaleY)
 Combine the current transform with a scaling.
 
Transform & scale (float scaleX, float scaleY, float centerX, float centerY)
 Combine the current transform with a scaling.
 
Transform & scale (const Vector2f &factors)
 Combine the current transform with a scaling.
 
Transform & scale (const Vector2f &factors, const Vector2f &center)
 Combine the current transform with a scaling.
 
+ + + + +

+Static Public Attributes

static const Transform Identity
 The identity transform (does nothing)
 
+ + + + + + + + + + + + + + + + + +

+Related Functions

(Note that these are not member functions.)

+
Transform operator* (const Transform &left, const Transform &right)
 Overload of binary operator * to combine two transforms.
 
Transform & operator*= (Transform &left, const Transform &right)
 Overload of binary operator *= to combine two transforms.
 
Vector2f operator* (const Transform &left, const Vector2f &right)
 Overload of binary operator * to transform a point.
 
bool operator== (const Transform &left, const Transform &right)
 Overload of binary operator == to compare two transforms.
 
bool operator!= (const Transform &left, const Transform &right)
 Overload of binary operator != to compare two transforms.
 
+

Detailed Description

+

Define a 3x3 transform matrix.

+

A sf::Transform specifies how to translate, rotate, scale, shear, project, whatever things.

+

In mathematical terms, it defines how to transform a coordinate system into another.

+

For example, if you apply a rotation transform to a sprite, the result will be a rotated sprite. And anything that is transformed by this rotation transform will be rotated the same way, according to its initial position.

+

Transforms are typically used for drawing. But they can also be used for any computation that requires to transform points between the local and global coordinate systems of an entity (like collision detection).

+

Example:

// define a translation transform
+
sf::Transform translation;
+
translation.translate(20, 50);
+
+
// define a rotation transform
+
sf::Transform rotation;
+
rotation.rotate(45);
+
+
// combine them
+
sf::Transform transform = translation * rotation;
+
+
// use the result to transform stuff...
+
sf::Vector2f point = transform.transformPoint(10, 20);
+
sf::FloatRect rect = transform.transformRect(sf::FloatRect(0, 0, 10, 100));
+ +
sf::Transform
Define a 3x3 transform matrix.
Definition: Transform.hpp:43
+
sf::Transform::translate
Transform & translate(float x, float y)
Combine the current transform with a translation.
+
sf::Transform::transformRect
FloatRect transformRect(const FloatRect &rectangle) const
Transform a rectangle.
+
sf::Transform::rotate
Transform & rotate(float angle)
Combine the current transform with a rotation.
+
sf::Transform::transformPoint
Vector2f transformPoint(float x, float y) const
Transform a 2D point.
+ +
See also
sf::Transformable, sf::RenderStates
+ +

Definition at line 42 of file Transform.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Transform() [1/2]

+ +
+
+ + + + + + + +
sf::Transform::Transform ()
+
+ +

Default constructor.

+

Creates an identity transform (a transform that does nothing).

+ +
+
+ +

◆ Transform() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sf::Transform::Transform (float a00,
float a01,
float a02,
float a10,
float a11,
float a12,
float a20,
float a21,
float a22 
)
+
+ +

Construct a transform from a 3x3 matrix.

+
Parameters
+ + + + + + + + + + +
a00Element (0, 0) of the matrix
a01Element (0, 1) of the matrix
a02Element (0, 2) of the matrix
a10Element (1, 0) of the matrix
a11Element (1, 1) of the matrix
a12Element (1, 2) of the matrix
a20Element (2, 0) of the matrix
a21Element (2, 1) of the matrix
a22Element (2, 2) of the matrix
+
+
+ +
+
+

Member Function Documentation

+ +

◆ combine()

+ +
+
+ + + + + + + + +
Transform & sf::Transform::combine (const Transform & transform)
+
+ +

Combine the current transform with another one.

+

The result is a transform that is equivalent to applying transform followed by *this. Mathematically, it is equivalent to a matrix multiplication (*this) * transform.

+

These two statements are equivalent:

left.combine(right);
+
left *= right;
+
Parameters
+ + +
transformTransform to combine with this transform
+
+
+
Returns
Reference to *this
+ +
+
+ +

◆ getInverse()

+ +
+
+ + + + + + + +
Transform sf::Transform::getInverse () const
+
+ +

Return the inverse of the transform.

+

If the inverse cannot be computed, an identity transform is returned.

+
Returns
A new transform which is the inverse of self
+ +
+
+ +

◆ getMatrix()

+ +
+
+ + + + + + + +
const float * sf::Transform::getMatrix () const
+
+ +

Return the transform as a 4x4 matrix.

+

This function returns a pointer to an array of 16 floats containing the transform elements as a 4x4 matrix, which is directly compatible with OpenGL functions.

+
sf::Transform transform = ...;
+
glLoadMatrixf(transform.getMatrix());
+
sf::Transform::getMatrix
const float * getMatrix() const
Return the transform as a 4x4 matrix.
+
Returns
Pointer to a 4x4 matrix
+ +
+
+ +

◆ rotate() [1/3]

+ +
+
+ + + + + + + + +
Transform & sf::Transform::rotate (float angle)
+
+ +

Combine the current transform with a rotation.

+

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
+
transform.rotate(90).translate(50, 20);
+
Parameters
+ + +
angleRotation angle, in degrees
+
+
+
Returns
Reference to *this
+
See also
translate, scale
+ +
+
+ +

◆ rotate() [2/3]

+ +
+
+ + + + + + + + + + + + + + + + + + +
Transform & sf::Transform::rotate (float angle,
const Vector2f & center 
)
+
+ +

Combine the current transform with a rotation.

+

The center of rotation is provided for convenience as a second argument, so that you can build rotations around arbitrary points more easily (and efficiently) than the usual translate(-center).rotate(angle).translate(center).

+

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
+
transform.rotate(90, sf::Vector2f(8, 3)).translate(sf::Vector2f(50, 20));
+
Parameters
+ + + +
angleRotation angle, in degrees
centerCenter of rotation
+
+
+
Returns
Reference to *this
+
See also
translate, scale
+ +
+
+ +

◆ rotate() [3/3]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
Transform & sf::Transform::rotate (float angle,
float centerX,
float centerY 
)
+
+ +

Combine the current transform with a rotation.

+

The center of rotation is provided for convenience as a second argument, so that you can build rotations around arbitrary points more easily (and efficiently) than the usual translate(-center).rotate(angle).translate(center).

+

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
+
transform.rotate(90, 8, 3).translate(50, 20);
+
Parameters
+ + + + +
angleRotation angle, in degrees
centerXX coordinate of the center of rotation
centerYY coordinate of the center of rotation
+
+
+
Returns
Reference to *this
+
See also
translate, scale
+ +
+
+ +

◆ scale() [1/4]

+ +
+
+ + + + + + + + +
Transform & sf::Transform::scale (const Vector2f & factors)
+
+ +

Combine the current transform with a scaling.

+

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
+
transform.scale(sf::Vector2f(2, 1)).rotate(45);
+
sf::Transform::scale
Transform & scale(float scaleX, float scaleY)
Combine the current transform with a scaling.
+
Parameters
+ + +
factorsScaling factors
+
+
+
Returns
Reference to *this
+
See also
translate, rotate
+ +
+
+ +

◆ scale() [2/4]

+ +
+
+ + + + + + + + + + + + + + + + + + +
Transform & sf::Transform::scale (const Vector2f & factors,
const Vector2f & center 
)
+
+ +

Combine the current transform with a scaling.

+

The center of scaling is provided for convenience as a second argument, so that you can build scaling around arbitrary points more easily (and efficiently) than the usual translate(-center).scale(factors).translate(center).

+

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
+
transform.scale(sf::Vector2f(2, 1), sf::Vector2f(8, 3)).rotate(45);
+
Parameters
+ + + +
factorsScaling factors
centerCenter of scaling
+
+
+
Returns
Reference to *this
+
See also
translate, rotate
+ +
+
+ +

◆ scale() [3/4]

+ +
+
+ + + + + + + + + + + + + + + + + + +
Transform & sf::Transform::scale (float scaleX,
float scaleY 
)
+
+ +

Combine the current transform with a scaling.

+

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
+
transform.scale(2, 1).rotate(45);
+
Parameters
+ + + +
scaleXScaling factor on the X axis
scaleYScaling factor on the Y axis
+
+
+
Returns
Reference to *this
+
See also
translate, rotate
+ +
+
+ +

◆ scale() [4/4]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Transform & sf::Transform::scale (float scaleX,
float scaleY,
float centerX,
float centerY 
)
+
+ +

Combine the current transform with a scaling.

+

The center of scaling is provided for convenience as a second argument, so that you can build scaling around arbitrary points more easily (and efficiently) than the usual translate(-center).scale(factors).translate(center).

+

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
+
transform.scale(2, 1, 8, 3).rotate(45);
+
Parameters
+ + + + + +
scaleXScaling factor on X axis
scaleYScaling factor on Y axis
centerXX coordinate of the center of scaling
centerYY coordinate of the center of scaling
+
+
+
Returns
Reference to *this
+
See also
translate, rotate
+ +
+
+ +

◆ transformPoint() [1/2]

+ +
+
+ + + + + + + + +
Vector2f sf::Transform::transformPoint (const Vector2f & point) const
+
+ +

Transform a 2D point.

+

These two statements are equivalent:

sf::Vector2f transformedPoint = matrix.transformPoint(point);
+
sf::Vector2f transformedPoint = matrix * point;
+
Parameters
+ + +
pointPoint to transform
+
+
+
Returns
Transformed point
+ +
+
+ +

◆ transformPoint() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
Vector2f sf::Transform::transformPoint (float x,
float y 
) const
+
+ +

Transform a 2D point.

+

These two statements are equivalent:

sf::Vector2f transformedPoint = matrix.transformPoint(x, y);
+
sf::Vector2f transformedPoint = matrix * sf::Vector2f(x, y);
+
Parameters
+ + + +
xX coordinate of the point to transform
yY coordinate of the point to transform
+
+
+
Returns
Transformed point
+ +
+
+ +

◆ transformRect()

+ +
+
+ + + + + + + + +
FloatRect sf::Transform::transformRect (const FloatRect & rectangle) const
+
+ +

Transform a rectangle.

+

Since SFML doesn't provide support for oriented rectangles, the result of this function is always an axis-aligned rectangle. Which means that if the transform contains a rotation, the bounding rectangle of the transformed rectangle is returned.

+
Parameters
+ + +
rectangleRectangle to transform
+
+
+
Returns
Transformed rectangle
+ +
+
+ +

◆ translate() [1/2]

+ +
+
+ + + + + + + + +
Transform & sf::Transform::translate (const Vector2f & offset)
+
+ +

Combine the current transform with a translation.

+

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
+
transform.translate(sf::Vector2f(100, 200)).rotate(45);
+
Parameters
+ + +
offsetTranslation offset to apply
+
+
+
Returns
Reference to *this
+
See also
rotate, scale
+ +
+
+ +

◆ translate() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
Transform & sf::Transform::translate (float x,
float y 
)
+
+ +

Combine the current transform with a translation.

+

This function returns a reference to *this, so that calls can be chained.

sf::Transform transform;
+
transform.translate(100, 200).rotate(45);
+
Parameters
+ + + +
xOffset to apply on X axis
yOffset to apply on Y axis
+
+
+
Returns
Reference to *this
+
See also
rotate, scale
+ +
+
+

Friends And Related Function Documentation

+ +

◆ operator!=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (const Transform & left,
const Transform & right 
)
+ 		+related
+
+ +

Overload of binary operator != to compare two transforms.

+

This call is equivalent to !(left == right).

+
Parameters
+ + + +
leftLeft operand (the first transform)
rightRight operand (the second transform)
+
+
+
Returns
true if the transforms are not equal, false otherwise
+ +
+
+ +

◆ operator*() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Transform operator* (const Transform & left,
const Transform & right 
)
+ 		+related
+
+ +

Overload of binary operator * to combine two transforms.

+

This call is equivalent to calling Transform(left).combine(right).

+
Parameters
+ + + +
leftLeft operand (the first transform)
rightRight operand (the second transform)
+
+
+
Returns
New combined transform
+ +
+
+ +

◆ operator*() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2f operator* (const Transform & left,
const Vector2f & right 
)
+ 		+related
+
+ +

Overload of binary operator * to transform a point.

+

This call is equivalent to calling left.transformPoint(right).

+
Parameters
+ + + +
leftLeft operand (the transform)
rightRight operand (the point to transform)
+
+
+
Returns
New transformed point
+ +
+
+ +

◆ operator*=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Transform & operator*= (Transform & left,
const Transform & right 
)
+ 		+related
+
+ +

Overload of binary operator *= to combine two transforms.

+

This call is equivalent to calling left.combine(right).

+
Parameters
+ + + +
leftLeft operand (the first transform)
rightRight operand (the second transform)
+
+
+
Returns
The combined transform
+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (const Transform & left,
const Transform & right 
)
+ 		+related
+
+ +

Overload of binary operator == to compare two transforms.

+

Performs an element-wise comparison of the elements of the left transform with the elements of the right transform.

+
Parameters
+ + + +
leftLeft operand (the first transform)
rightRight operand (the second transform)
+
+
+
Returns
true if the transforms are equal, false otherwise
+ +
+
+

Member Data Documentation

+ +

◆ Identity

+ +
+
+ + + + + +
+ + + + +
const Transform sf::Transform::Identity
+ 		+static
+
+ +

The identity transform (does nothing)

+ +

Definition at line 372 of file Transform.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Transformable-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Transformable-members.html new file mode 100644 index 000000000..233c80a97 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Transformable-members.html @@ -0,0 +1,128 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Transformable Member List
+
+
+ +

This is the complete list of members for sf::Transformable, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + +
getInverseTransform() constsf::Transformable
getOrigin() constsf::Transformable
getPosition() constsf::Transformable
getRotation() constsf::Transformable
getScale() constsf::Transformable
getTransform() constsf::Transformable
move(float offsetX, float offsetY)sf::Transformable
move(const Vector2f &offset)sf::Transformable
rotate(float angle)sf::Transformable
scale(float factorX, float factorY)sf::Transformable
scale(const Vector2f &factor)sf::Transformable
setOrigin(float x, float y)sf::Transformable
setOrigin(const Vector2f &origin)sf::Transformable
setPosition(float x, float y)sf::Transformable
setPosition(const Vector2f &position)sf::Transformable
setRotation(float angle)sf::Transformable
setScale(float factorX, float factorY)sf::Transformable
setScale(const Vector2f &factors)sf::Transformable
Transformable()sf::Transformable
~Transformable()sf::Transformablevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Transformable.html b/Space-Invaders/sfml/doc/html/classsf_1_1Transformable.html new file mode 100644 index 000000000..e1fda0179 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Transformable.html @@ -0,0 +1,819 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::Transformable Class Reference
Graphics module
+
+
+ +

Decomposed transform defined by a position, a rotation and a scale. + More...

+ +

#include <SFML/Graphics/Transformable.hpp>

+
+Inheritance diagram for sf::Transformable:
+
+
+ + +sf::Shape +sf::Sprite +sf::Text +sf::CircleShape +sf::ConvexShape +sf::RectangleShape + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Transformable ()
 Default constructor.
 
virtual ~Transformable ()
 Virtual destructor.
 
void setPosition (float x, float y)
 set the position of the object
 
void setPosition (const Vector2f &position)
 set the position of the object
 
void setRotation (float angle)
 set the orientation of the object
 
void setScale (float factorX, float factorY)
 set the scale factors of the object
 
void setScale (const Vector2f &factors)
 set the scale factors of the object
 
void setOrigin (float x, float y)
 set the local origin of the object
 
void setOrigin (const Vector2f &origin)
 set the local origin of the object
 
const Vector2f & getPosition () const
 get the position of the object
 
float getRotation () const
 get the orientation of the object
 
const Vector2f & getScale () const
 get the current scale of the object
 
const Vector2f & getOrigin () const
 get the local origin of the object
 
void move (float offsetX, float offsetY)
 Move the object by a given offset.
 
void move (const Vector2f &offset)
 Move the object by a given offset.
 
void rotate (float angle)
 Rotate the object.
 
void scale (float factorX, float factorY)
 Scale the object.
 
void scale (const Vector2f &factor)
 Scale the object.
 
const Transform & getTransform () const
 get the combined transform of the object
 
const Transform & getInverseTransform () const
 get the inverse of the combined transform of the object
 
+

Detailed Description

+

Decomposed transform defined by a position, a rotation and a scale.

+

This class is provided for convenience, on top of sf::Transform.

+

sf::Transform, as a low-level class, offers a great level of flexibility but it is not always convenient to manage. Indeed, one can easily combine any kind of operation, such as a translation followed by a rotation followed by a scaling, but once the result transform is built, there's no way to go backward and, let's say, change only the rotation without modifying the translation and scaling. The entire transform must be recomputed, which means that you need to retrieve the initial translation and scale factors as well, and combine them the same way you did before updating the rotation. This is a tedious operation, and it requires to store all the individual components of the final transform.

+

That's exactly what sf::Transformable was written for: it hides these variables and the composed transform behind an easy to use interface. You can set or get any of the individual components without worrying about the others. It also provides the composed transform (as a sf::Transform), and keeps it up-to-date.

+

In addition to the position, rotation and scale, sf::Transformable provides an "origin" component, which represents the local origin of the three other components. Let's take an example with a 10x10 pixels sprite. By default, the sprite is positioned/rotated/scaled relatively to its top-left corner, because it is the local point (0, 0). But if we change the origin to be (5, 5), the sprite will be positioned/rotated/scaled around its center instead. And if we set the origin to (10, 10), it will be transformed around its bottom-right corner.

+

To keep the sf::Transformable class simple, there's only one origin for all the components. You cannot position the sprite relatively to its top-left corner while rotating it around its center, for example. To do such things, use sf::Transform directly.

+

sf::Transformable can be used as a base class. It is often combined with sf::Drawable – that's what SFML's sprites, texts and shapes do.

class MyEntity : public sf::Transformable, public sf::Drawable
+
{
+
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
+
{
+
states.transform *= getTransform();
+
target.draw(..., states);
+
}
+
};
+
+
MyEntity entity;
+
entity.setPosition(10, 20);
+
entity.setRotation(45);
+
window.draw(entity);
+
sf::Drawable
Abstract base class for objects that can be drawn to a render target.
Definition: Drawable.hpp:45
+
sf::RenderStates
Define the states used for drawing to a RenderTarget.
Definition: RenderStates.hpp:46
+
sf::RenderStates::transform
Transform transform
Transform.
Definition: RenderStates.hpp:116
+
sf::RenderTarget
Base class for all render targets (window, texture, ...)
Definition: RenderTarget.hpp:53
+
sf::RenderTarget::draw
void draw(const Drawable &drawable, const RenderStates &states=RenderStates::Default)
Draw a drawable object to the render target.
+
sf::Transformable
Decomposed transform defined by a position, a rotation and a scale.
Definition: Transformable.hpp:42
+

It can also be used as a member, if you don't want to use its API directly (because you don't need all its functions, or you have different naming conventions for example).

class MyEntity
+
{
+
public:
+
void SetPosition(const MyVector& v)
+
{
+
myTransform.setPosition(v.x(), v.y());
+
}
+
+
void Draw(sf::RenderTarget& target) const
+
{
+
target.draw(..., myTransform.getTransform());
+
}
+
+
private:
+
sf::Transformable myTransform;
+
};
+

A note on coordinates and undistorted rendering:
+By default, SFML (or more exactly, OpenGL) may interpolate drawable objects such as sprites or texts when rendering. While this allows transitions like slow movements or rotations to appear smoothly, it can lead to unwanted results in some cases, for example blurred or distorted objects. In order to render a sf::Drawable object pixel-perfectly, make sure the involved coordinates allow a 1:1 mapping of pixels in the window to texels (pixels in the texture). More specifically, this means:

    +
  • The object's position, origin and scale have no fractional part
    • +
  • The object's and the view's rotation are a multiple of 90 degrees
    • +
  • The view's center and size have no fractional part
    • +
+
See also
sf::Transform
+ +

Definition at line 41 of file Transformable.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Transformable()

+ +
+
+ + + + + + + +
sf::Transformable::Transformable ()
+
+ +

Default constructor.

+ +
+
+ +

◆ ~Transformable()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::Transformable::~Transformable ()
+ 		+virtual
+
+ +

Virtual destructor.

+ +
+
+

Member Function Documentation

+ +

◆ getInverseTransform()

+ +
+
+ + + + + + + +
const Transform & sf::Transformable::getInverseTransform () const
+
+ +

get the inverse of the combined transform of the object

+
Returns
Inverse of the combined transformations applied to the object
+
See also
getTransform
+ +
+
+ +

◆ getOrigin()

+ +
+
+ + + + + + + +
const Vector2f & sf::Transformable::getOrigin () const
+
+ +

get the local origin of the object

+
Returns
Current origin
+
See also
setOrigin
+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + + + +
const Vector2f & sf::Transformable::getPosition () const
+
+ +

get the position of the object

+
Returns
Current position
+
See also
setPosition
+ +
+
+ +

◆ getRotation()

+ +
+
+ + + + + + + +
float sf::Transformable::getRotation () const
+
+ +

get the orientation of the object

+

The rotation is always in the range [0, 360].

+
Returns
Current rotation, in degrees
+
See also
setRotation
+ +
+
+ +

◆ getScale()

+ +
+
+ + + + + + + +
const Vector2f & sf::Transformable::getScale () const
+
+ +

get the current scale of the object

+
Returns
Current scale factors
+
See also
setScale
+ +
+
+ +

◆ getTransform()

+ +
+
+ + + + + + + +
const Transform & sf::Transformable::getTransform () const
+
+ +

get the combined transform of the object

+
Returns
Transform combining the position/rotation/scale/origin of the object
+
See also
getInverseTransform
+ +
+
+ +

◆ move() [1/2]

+ +
+
+ + + + + + + + +
void sf::Transformable::move (const Vector2f & offset)
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

object.setPosition(object.getPosition() + offset);
+
sf::Transformable::getPosition
const Vector2f & getPosition() const
get the position of the object
+
Parameters
+ + +
offsetOffset
+
+
+
See also
setPosition
+ +
+
+ +

◆ move() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::move (float offsetX,
float offsetY 
)
+
+ +

Move the object by a given offset.

+

This function adds to the current position of the object, unlike setPosition which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f pos = object.getPosition();
+
object.setPosition(pos.x + offsetX, pos.y + offsetY);
+ +
sf::Vector2::x
T x
X coordinate of the vector.
Definition: Vector2.hpp:75
+
sf::Vector2::y
T y
Y coordinate of the vector.
Definition: Vector2.hpp:76
+
Parameters
+ + + +
offsetXX offset
offsetYY offset
+
+
+
See also
setPosition
+ +
+
+ +

◆ rotate()

+ +
+
+ + + + + + + + +
void sf::Transformable::rotate (float angle)
+
+ +

Rotate the object.

+

This function adds to the current rotation of the object, unlike setRotation which overwrites it. Thus, it is equivalent to the following code:

object.setRotation(object.getRotation() + angle);
+
sf::Transformable::getRotation
float getRotation() const
get the orientation of the object
+
Parameters
+ + +
angleAngle of rotation, in degrees
+
+
+ +
+
+ +

◆ scale() [1/2]

+ +
+
+ + + + + + + + +
void sf::Transformable::scale (const Vector2f & factor)
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factor.x, scale.y * factor.y);
+
sf::Transformable::scale
void scale(float factorX, float factorY)
Scale the object.
+
Parameters
+ + +
factorScale factors
+
+
+
See also
setScale
+ +
+
+ +

◆ scale() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::scale (float factorX,
float factorY 
)
+
+ +

Scale the object.

+

This function multiplies the current scale of the object, unlike setScale which overwrites it. Thus, it is equivalent to the following code:

sf::Vector2f scale = object.getScale();
+
object.setScale(scale.x * factorX, scale.y * factorY);
+
Parameters
+ + + +
factorXHorizontal scale factor
factorYVertical scale factor
+
+
+
See also
setScale
+ +
+
+ +

◆ setOrigin() [1/2]

+ +
+
+ + + + + + + + +
void sf::Transformable::setOrigin (const Vector2f & origin)
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + +
originNew origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setOrigin() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setOrigin (float x,
float y 
)
+
+ +

set the local origin of the object

+

The origin of an object defines the center point for all transformations (position, scale, rotation). The coordinates of this point must be relative to the top-left corner of the object, and ignore all transformations (position, scale, rotation). The default origin of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new origin
yY coordinate of the new origin
+
+
+
See also
getOrigin
+ +
+
+ +

◆ setPosition() [1/2]

+ +
+
+ + + + + + + + +
void sf::Transformable::setPosition (const Vector2f & position)
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + +
positionNew position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setPosition() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setPosition (float x,
float y 
)
+
+ +

set the position of the object

+

This function completely overwrites the previous position. See the move function to apply an offset based on the previous position instead. The default position of a transformable object is (0, 0).

+
Parameters
+ + + +
xX coordinate of the new position
yY coordinate of the new position
+
+
+
See also
move, getPosition
+ +
+
+ +

◆ setRotation()

+ +
+
+ + + + + + + + +
void sf::Transformable::setRotation (float angle)
+
+ +

set the orientation of the object

+

This function completely overwrites the previous rotation. See the rotate function to add an angle based on the previous rotation instead. The default rotation of a transformable object is 0.

+
Parameters
+ + +
angleNew rotation, in degrees
+
+
+
See also
rotate, getRotation
+ +
+
+ +

◆ setScale() [1/2]

+ +
+
+ + + + + + + + +
void sf::Transformable::setScale (const Vector2f & factors)
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + +
factorsNew scale factors
+
+
+
See also
scale, getScale
+ +
+
+ +

◆ setScale() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::Transformable::setScale (float factorX,
float factorY 
)
+
+ +

set the scale factors of the object

+

This function completely overwrites the previous scale. See the scale function to add a factor based on the previous scale instead. The default scale of a transformable object is (1, 1).

+
Parameters
+ + + +
factorXNew horizontal scale factor
factorYNew vertical scale factor
+
+
+
See also
scale, getScale
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Transformable.png b/Space-Invaders/sfml/doc/html/classsf_1_1Transformable.png new file mode 100644 index 000000000..1bcb6a6de Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Transformable.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1UdpSocket-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1UdpSocket-members.html new file mode 100644 index 000000000..67219db44 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1UdpSocket-members.html @@ -0,0 +1,135 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::UdpSocket Member List
+
+
+ +

This is the complete list of members for sf::UdpSocket, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AnyPort enum valuesf::Socket
bind(unsigned short port, const IpAddress &address=IpAddress::Any)sf::UdpSocket
close()sf::Socketprotected
create()sf::Socketprotected
create(SocketHandle handle)sf::Socketprotected
Disconnected enum valuesf::Socket
Done enum valuesf::Socket
Error enum valuesf::Socket
getHandle() constsf::Socketprotected
getLocalPort() constsf::UdpSocket
isBlocking() constsf::Socket
MaxDatagramSize enum valuesf::UdpSocket
NotReady enum valuesf::Socket
Partial enum valuesf::Socket
receive(void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort)sf::UdpSocket
receive(Packet &packet, IpAddress &remoteAddress, unsigned short &remotePort)sf::UdpSocket
send(const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort)sf::UdpSocket
send(Packet &packet, const IpAddress &remoteAddress, unsigned short remotePort)sf::UdpSocket
setBlocking(bool blocking)sf::Socket
Socket(Type type)sf::Socketprotected
Status enum namesf::Socket
Tcp enum valuesf::Socketprotected
Type enum namesf::Socketprotected
Udp enum valuesf::Socketprotected
UdpSocket()sf::UdpSocket
unbind()sf::UdpSocket
~Socket()sf::Socketvirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1UdpSocket.html b/Space-Invaders/sfml/doc/html/classsf_1_1UdpSocket.html new file mode 100644 index 000000000..9f997d1df --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1UdpSocket.html @@ -0,0 +1,883 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Protected Types | +Protected Member Functions | +List of all members
+
sf::UdpSocket Class Reference
Network module
+
+
+ +

Specialized socket using the UDP protocol. + More...

+ +

#include <SFML/Network/UdpSocket.hpp>

+
+Inheritance diagram for sf::UdpSocket:
+
+
+ + +sf::Socket +sf::NonCopyable + +
+ + + + + + + + + + +

+Public Types

enum  { MaxDatagramSize = 65507 + }
 
enum  Status {
+  Done +, NotReady +, Partial +, Disconnected +,
+  Error +
+ }
 Status codes that may be returned by socket functions. More...
 
enum  { AnyPort = 0 + }
 Some special values used by sockets. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 UdpSocket ()
 Default constructor.
 
unsigned short getLocalPort () const
 Get the port to which the socket is bound locally.
 
Status bind (unsigned short port, const IpAddress &address=IpAddress::Any)
 Bind the socket to a specific port.
 
void unbind ()
 Unbind the socket from the local port to which it is bound.
 
Status send (const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort)
 Send raw data to a remote peer.
 
Status receive (void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort)
 Receive raw data from a remote peer.
 
Status send (Packet &packet, const IpAddress &remoteAddress, unsigned short remotePort)
 Send a formatted packet of data to a remote peer.
 
Status receive (Packet &packet, IpAddress &remoteAddress, unsigned short &remotePort)
 Receive a formatted packet of data from a remote peer.
 
void setBlocking (bool blocking)
 Set the blocking state of the socket.
 
bool isBlocking () const
 Tell whether the socket is in blocking or non-blocking mode.
 
+ + + + +

+Protected Types

enum  Type { Tcp +, Udp + }
 Types of protocols that the socket can use. More...
 
+ + + + + + + + + + + + + +

+Protected Member Functions

SocketHandle getHandle () const
 Return the internal handle of the socket.
 
void create ()
 Create the internal representation of the socket.
 
void create (SocketHandle handle)
 Create the internal representation of the socket from a socket handle.
 
void close ()
 Close the socket gracefully.
 
+

Detailed Description

+

Specialized socket using the UDP protocol.

+

A UDP socket is a connectionless socket.

+

Instead of connecting once to a remote host, like TCP sockets, it can send to and receive from any host at any time.

+

It is a datagram protocol: bounded blocks of data (datagrams) are transfered over the network rather than a continuous stream of data (TCP). Therefore, one call to send will always match one call to receive (if the datagram is not lost), with the same data that was sent.

+

The UDP protocol is lightweight but unreliable. Unreliable means that datagrams may be duplicated, be lost or arrive reordered. However, if a datagram arrives, its data is guaranteed to be valid.

+

UDP is generally used for real-time communication (audio or video streaming, real-time games, etc.) where speed is crucial and lost data doesn't matter much.

+

Sending and receiving data can use either the low-level or the high-level functions. The low-level functions process a raw sequence of bytes, whereas the high-level interface uses packets (see sf::Packet), which are easier to use and provide more safety regarding the data that is exchanged. You can look at the sf::Packet class to get more details about how they work.

+

It is important to note that UdpSocket is unable to send datagrams bigger than MaxDatagramSize. In this case, it returns an error and doesn't send anything. This applies to both raw data and packets. Indeed, even packets are unable to split and recompose data, due to the unreliability of the protocol (dropped, mixed or duplicated datagrams may lead to a big mess when trying to recompose a packet).

+

If the socket is bound to a port, it is automatically unbound from it when the socket is destroyed. However, you can unbind the socket explicitly with the Unbind function if necessary, to stop receiving messages or make the port available for other sockets.

+

Usage example:

// ----- The client -----
+
+
// Create a socket and bind it to the port 55001
+
sf::UdpSocket socket;
+
socket.bind(55001);
+
+
// Send a message to 192.168.1.50 on port 55002
+
std::string message = "Hi, I am " + sf::IpAddress::getLocalAddress().toString();
+
socket.send(message.c_str(), message.size() + 1, "192.168.1.50", 55002);
+
+
// Receive an answer (most likely from 192.168.1.50, but could be anyone else)
+
char buffer[1024];
+
std::size_t received = 0;
+
sf::IpAddress sender;
+
unsigned short port;
+
socket.receive(buffer, sizeof(buffer), received, sender, port);
+
std::cout << sender.ToString() << " said: " << buffer << std::endl;
+
+
// ----- The server -----
+
+
// Create a socket and bind it to the port 55002
+
sf::UdpSocket socket;
+
socket.bind(55002);
+
+
// Receive a message from anyone
+
char buffer[1024];
+
std::size_t received = 0;
+
sf::IpAddress sender;
+
unsigned short port;
+
socket.receive(buffer, sizeof(buffer), received, sender, port);
+
std::cout << sender.ToString() << " said: " << buffer << std::endl;
+
+
// Send an answer
+
std::string message = "Welcome " + sender.toString();
+
socket.send(message.c_str(), message.size() + 1, sender, port);
+
sf::IpAddress
Encapsulate an IPv4 network address.
Definition: IpAddress.hpp:45
+
sf::IpAddress::getLocalAddress
static IpAddress getLocalAddress()
Get the computer's local address.
+
sf::IpAddress::toString
std::string toString() const
Get a string representation of the address.
+
sf::UdpSocket
Specialized socket using the UDP protocol.
Definition: UdpSocket.hpp:46
+
sf::UdpSocket::send
Status send(const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort)
Send raw data to a remote peer.
+
sf::UdpSocket::bind
Status bind(unsigned short port, const IpAddress &address=IpAddress::Any)
Bind the socket to a specific port.
+
sf::UdpSocket::receive
Status receive(void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort)
Receive raw data from a remote peer.
+
See also
sf::Socket, sf::TcpSocket, sf::Packet
+ +

Definition at line 45 of file UdpSocket.hpp.

+

Member Enumeration Documentation

+ +

◆ anonymous enum

+ +
+
+ + + + + +
+ + + + +
anonymous enum
+ 		+inherited
+
+ +

Some special values used by sockets.

+ + +
Enumerator
AnyPort 

Special value that tells the system to pick any available port.

+
+ +

Definition at line 66 of file Socket.hpp.

+ +
+
+ +

◆ anonymous enum

+ +
+
+ + + + +
anonymous enum
+
+ + +
Enumerator
MaxDatagramSize 

The maximum number of bytes that can be sent in a single UDP datagram.

+
+ +

Definition at line 52 of file UdpSocket.hpp.

+ +
+
+ +

◆ Status

+ +
+
+ + + + + +
+ + + + +
enum sf::Socket::Status
+ 		+inherited
+
+ +

Status codes that may be returned by socket functions.

+ + + + + + +
Enumerator
Done 

The socket has sent / received the data.

+
NotReady 

The socket is not ready to send / receive data yet.

+
Partial 

The socket sent a part of the data.

+
Disconnected 

The TCP socket has been disconnected.

+
Error 

An unexpected error happened.

+
+ +

Definition at line 53 of file Socket.hpp.

+ +
+
+ +

◆ Type

+ +
+
+ + + + + +
+ + + + +
enum sf::Socket::Type
+ 		+protectedinherited
+
+ +

Types of protocols that the socket can use.

+ + + +
Enumerator
Tcp 

TCP protocol.

+
Udp 

UDP protocol.

+
+ +

Definition at line 114 of file Socket.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ UdpSocket()

+ +
+
+ + + + + + + +
sf::UdpSocket::UdpSocket ()
+
+ +

Default constructor.

+ +
+
+

Member Function Documentation

+ +

◆ bind()

+ +
+
+ + + + + + + + + + + + + + + + + + +
Status sf::UdpSocket::bind (unsigned short port,
const IpAddress & address = IpAddress::Any 
)
+
+ +

Bind the socket to a specific port.

+

Binding the socket to a port is necessary for being able to receive data on that port.

+

When providing sf::Socket::AnyPort as port, the listener will request an available port from the system. The chosen port can be retrieved by calling getLocalPort().

+

Since the socket can only be bound to a single port at any given moment, if it is already bound when this function is called, it will be unbound from the previous port before being bound to the new one.

+
Parameters
+ + + +
portPort to bind the socket to
addressAddress of the interface to bind to
+
+
+
Returns
Status code
+
See also
unbind, getLocalPort
+ +
+
+ +

◆ close()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Socket::close ()
+ 		+protectedinherited
+
+ +

Close the socket gracefully.

+

This function can only be accessed by derived classes.

+ +
+
+ +

◆ create() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
void sf::Socket::create ()
+ 		+protectedinherited
+
+ +

Create the internal representation of the socket.

+

This function can only be accessed by derived classes.

+ +
+
+ +

◆ create() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Socket::create (SocketHandle handle)
+ 		+protectedinherited
+
+ +

Create the internal representation of the socket from a socket handle.

+

This function can only be accessed by derived classes.

+
Parameters
+ + +
handleOS-specific handle of the socket to wrap
+
+
+ +
+
+ +

◆ getHandle()

+ +
+
+ + + + + +
+ + + + + + + +
SocketHandle sf::Socket::getHandle () const
+ 		+protectedinherited
+
+ +

Return the internal handle of the socket.

+

The returned handle may be invalid if the socket was not created yet (or already destroyed). This function can only be accessed by derived classes.

+
Returns
The internal (OS-specific) handle of the socket
+ +
+
+ +

◆ getLocalPort()

+ +
+
+ + + + + + + +
unsigned short sf::UdpSocket::getLocalPort () const
+
+ +

Get the port to which the socket is bound locally.

+

If the socket is not bound to a port, this function returns 0.

+
Returns
Port to which the socket is bound
+
See also
bind
+ +
+
+ +

◆ isBlocking()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::Socket::isBlocking () const
+ 		+inherited
+
+ +

Tell whether the socket is in blocking or non-blocking mode.

+
Returns
True if the socket is blocking, false otherwise
+
See also
setBlocking
+ +
+
+ +

◆ receive() [1/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
Status sf::UdpSocket::receive (Packet & packet,
IpAddress & remoteAddress,
unsigned short & remotePort 
)
+
+ +

Receive a formatted packet of data from a remote peer.

+

In blocking mode, this function will wait until the whole packet has been received.

+
Parameters
+ + + + +
packetPacket to fill with the received data
remoteAddressAddress of the peer that sent the data
remotePortPort of the peer that sent the data
+
+
+
Returns
Status code
+
See also
send
+ +
+
+ +

◆ receive() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Status sf::UdpSocket::receive (void * data,
std::size_t size,
std::size_t & received,
IpAddress & remoteAddress,
unsigned short & remotePort 
)
+
+ +

Receive raw data from a remote peer.

+

In blocking mode, this function will wait until some bytes are actually received. Be careful to use a buffer which is large enough for the data that you intend to receive, if it is too small then an error will be returned and all the data will be lost.

+
Parameters
+ + + + + + +
dataPointer to the array to fill with the received bytes
sizeMaximum number of bytes that can be received
receivedThis variable is filled with the actual number of bytes received
remoteAddressAddress of the peer that sent the data
remotePortPort of the peer that sent the data
+
+
+
Returns
Status code
+
See also
send
+ +
+
+ +

◆ send() [1/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Status sf::UdpSocket::send (const void * data,
std::size_t size,
const IpAddress & remoteAddress,
unsigned short remotePort 
)
+
+ +

Send raw data to a remote peer.

+

Make sure that size is not greater than UdpSocket::MaxDatagramSize, otherwise this function will fail and no data will be sent.

+
Parameters
+ + + + + +
dataPointer to the sequence of bytes to send
sizeNumber of bytes to send
remoteAddressAddress of the receiver
remotePortPort of the receiver to send the data to
+
+
+
Returns
Status code
+
See also
receive
+ +
+
+ +

◆ send() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
Status sf::UdpSocket::send (Packet & packet,
const IpAddress & remoteAddress,
unsigned short remotePort 
)
+
+ +

Send a formatted packet of data to a remote peer.

+

Make sure that the packet size is not greater than UdpSocket::MaxDatagramSize, otherwise this function will fail and no data will be sent.

+
Parameters
+ + + + +
packetPacket to send
remoteAddressAddress of the receiver
remotePortPort of the receiver to send the data to
+
+
+
Returns
Status code
+
See also
receive
+ +
+
+ +

◆ setBlocking()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::Socket::setBlocking (bool blocking)
+ 		+inherited
+
+ +

Set the blocking state of the socket.

+

In blocking mode, calls will not return until they have completed their task. For example, a call to Receive in blocking mode won't return until some data was actually received. In non-blocking mode, calls will always return immediately, using the return code to signal whether there was data available or not. By default, all sockets are blocking.

+
Parameters
+ + +
blockingTrue to set the socket as blocking, false for non-blocking
+
+
+
See also
isBlocking
+ +
+
+ +

◆ unbind()

+ +
+
+ + + + + + + +
void sf::UdpSocket::unbind ()
+
+ +

Unbind the socket from the local port to which it is bound.

+

The port that the socket was previously bound to is immediately made available to the operating system after this function is called. This means that a subsequent call to bind() will be able to re-bind the port if no other process has done so in the mean time. If the socket is not bound to a port, this function has no effect.

+
See also
bind
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1UdpSocket.png b/Space-Invaders/sfml/doc/html/classsf_1_1UdpSocket.png new file mode 100644 index 000000000..43221f426 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1UdpSocket.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Utf.html b/Space-Invaders/sfml/doc/html/classsf_1_1Utf.html new file mode 100644 index 000000000..53079f3b7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Utf.html @@ -0,0 +1,125 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Utf< N > Class Template Reference
System module
+
+
+ +

Utility class providing generic functions for UTF conversions. + More...

+ +

#include <SFML/System/Utf.hpp>

+

Detailed Description

+
template<unsigned int N>
+class sf::Utf< N >

Utility class providing generic functions for UTF conversions.

+

sf::Utf is a low-level, generic interface for counting, iterating, encoding and decoding Unicode characters and strings. It is able to handle ANSI, wide, latin-1, UTF-8, UTF-16 and UTF-32 encodings.

+

sf::Utf<X> functions are all static, these classes are not meant to be instantiated. All the functions are template, so that you can use any character / string type for a given encoding.

+

It has 3 specializations:

+ +

Definition at line 41 of file Utf.hpp.

+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0116_01_4-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0116_01_4-members.html new file mode 100644 index 000000000..626b3a262 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0116_01_4-members.html @@ -0,0 +1,121 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Utf< 16 > Member List
+
+
+ +

This is the complete list of members for sf::Utf< 16 >, including all inherited members.

+ + + + + + + + + + + + + + +
count(In begin, In end)sf::Utf< 16 >static
decode(In begin, In end, Uint32 &output, Uint32 replacement=0)sf::Utf< 16 >static
encode(Uint32 input, Out output, Uint16 replacement=0)sf::Utf< 16 >static
fromAnsi(In begin, In end, Out output, const std::locale &locale=std::locale())sf::Utf< 16 >static
fromLatin1(In begin, In end, Out output)sf::Utf< 16 >static
fromWide(In begin, In end, Out output)sf::Utf< 16 >static
next(In begin, In end)sf::Utf< 16 >static
toAnsi(In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale())sf::Utf< 16 >static
toLatin1(In begin, In end, Out output, char replacement=0)sf::Utf< 16 >static
toUtf16(In begin, In end, Out output)sf::Utf< 16 >static
toUtf32(In begin, In end, Out output)sf::Utf< 16 >static
toUtf8(In begin, In end, Out output)sf::Utf< 16 >static
toWide(In begin, In end, Out output, wchar_t replacement=0)sf::Utf< 16 >static
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0116_01_4.html b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0116_01_4.html new file mode 100644 index 000000000..b7dfc059b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0116_01_4.html @@ -0,0 +1,927 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +List of all members
+
sf::Utf< 16 > Class Reference
+
+
+ +

Specialization of the Utf template for UTF-16. + More...

+ +

#include <SFML/System/Utf.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

template<typename In >
static In decode (In begin, In end, Uint32 &output, Uint32 replacement=0)
 Decode a single UTF-16 character.
 
template<typename Out >
static Out encode (Uint32 input, Out output, Uint16 replacement=0)
 Encode a single UTF-16 character.
 
template<typename In >
static In next (In begin, In end)
 Advance to the next UTF-16 character.
 
template<typename In >
static std::size_t count (In begin, In end)
 Count the number of characters of a UTF-16 sequence.
 
template<typename In , typename Out >
static Out fromAnsi (In begin, In end, Out output, const std::locale &locale=std::locale())
 Convert an ANSI characters range to UTF-16.
 
template<typename In , typename Out >
static Out fromWide (In begin, In end, Out output)
 Convert a wide characters range to UTF-16.
 
template<typename In , typename Out >
static Out fromLatin1 (In begin, In end, Out output)
 Convert a latin-1 (ISO-5589-1) characters range to UTF-16.
 
template<typename In , typename Out >
static Out toAnsi (In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale())
 Convert an UTF-16 characters range to ANSI characters.
 
template<typename In , typename Out >
static Out toWide (In begin, In end, Out output, wchar_t replacement=0)
 Convert an UTF-16 characters range to wide characters.
 
template<typename In , typename Out >
static Out toLatin1 (In begin, In end, Out output, char replacement=0)
 Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters.
 
template<typename In , typename Out >
static Out toUtf8 (In begin, In end, Out output)
 Convert a UTF-16 characters range to UTF-8.
 
template<typename In , typename Out >
static Out toUtf16 (In begin, In end, Out output)
 Convert a UTF-16 characters range to UTF-16.
 
template<typename In , typename Out >
static Out toUtf32 (In begin, In end, Out output)
 Convert a UTF-16 characters range to UTF-32.
 
+

Detailed Description

+

Specialization of the Utf template for UTF-16.

+ +

Definition at line 255 of file Utf.hpp.

+

Member Function Documentation

+ +

◆ count()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static std::size_t sf::Utf< 16 >::count (In begin,
In end 
)
+ 		+static
+
+ +

Count the number of characters of a UTF-16 sequence.

+

This function is necessary for multi-elements encodings, as a single character may use more than 1 storage element, thus the total size can be different from (begin - end).

+
Parameters
+ + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
+
+
+
Returns
Iterator pointing to one past the last read element of the input sequence
+ +
+
+ +

◆ decode()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static In sf::Utf< 16 >::decode (In begin,
In end,
Uint32 & output,
Uint32 replacement = 0 
)
+ 		+static
+
+ +

Decode a single UTF-16 character.

+

Decoding a character means finding its unique 32-bits code (called the codepoint) in the Unicode standard.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputCodepoint of the decoded UTF-16 character
replacementReplacement character to use in case the UTF-8 sequence is invalid
+
+
+
Returns
Iterator pointing to one past the last read element of the input sequence
+ +
+
+ +

◆ encode()

+ +
+
+
+template<typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 16 >::encode (Uint32 input,
Out output,
Uint16 replacement = 0 
)
+ 		+static
+
+ +

Encode a single UTF-16 character.

+

Encoding a character means converting a unique 32-bits code (called the codepoint) in the target encoding, UTF-16.

+
Parameters
+ + + + +
inputCodepoint to encode as UTF-16
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to UTF-16 (use 0 to skip them)
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ fromAnsi()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 16 >::fromAnsi (In begin,
In end,
Out output,
const std::locale & locale = std::locale() 
)
+ 		+static
+
+ +

Convert an ANSI characters range to UTF-16.

+

The current global locale will be used by default, unless you pass a custom one in the locale parameter.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
localeLocale to use for conversion
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ fromLatin1()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 16 >::fromLatin1 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a latin-1 (ISO-5589-1) characters range to UTF-16.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ fromWide()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 16 >::fromWide (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a wide characters range to UTF-16.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ next()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static In sf::Utf< 16 >::next (In begin,
In end 
)
+ 		+static
+
+ +

Advance to the next UTF-16 character.

+

This function is necessary for multi-elements encodings, as a single character may use more than 1 storage element.

+
Parameters
+ + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
+
+
+
Returns
Iterator pointing to one past the last read element of the input sequence
+ +
+
+ +

◆ toAnsi()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 16 >::toAnsi (In begin,
In end,
Out output,
char replacement = 0,
const std::locale & locale = std::locale() 
)
+ 		+static
+
+ +

Convert an UTF-16 characters range to ANSI characters.

+

The current global locale will be used by default, unless you pass a custom one in the locale parameter.

+
Parameters
+ + + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to ANSI (use 0 to skip them)
localeLocale to use for conversion
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toLatin1()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 16 >::toLatin1 (In begin,
In end,
Out output,
char replacement = 0 
)
+ 		+static
+
+ +

Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to wide (use 0 to skip them)
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toUtf16()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 16 >::toUtf16 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a UTF-16 characters range to UTF-16.

+

This functions does nothing more than a direct copy; it is defined only to provide the same interface as other specializations of the sf::Utf<> template, and allow generic code to be written on top of it.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toUtf32()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 16 >::toUtf32 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a UTF-16 characters range to UTF-32.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toUtf8()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 16 >::toUtf8 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a UTF-16 characters range to UTF-8.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toWide()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 16 >::toWide (In begin,
In end,
Out output,
wchar_t replacement = 0 
)
+ 		+static
+
+ +

Convert an UTF-16 characters range to wide characters.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to wide (use 0 to skip them)
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0132_01_4-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0132_01_4-members.html new file mode 100644 index 000000000..07c4207cf --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0132_01_4-members.html @@ -0,0 +1,125 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Utf< 32 > Member List
+
+
+ +

This is the complete list of members for sf::Utf< 32 >, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
count(In begin, In end)sf::Utf< 32 >static
decode(In begin, In end, Uint32 &output, Uint32 replacement=0)sf::Utf< 32 >static
decodeAnsi(In input, const std::locale &locale=std::locale())sf::Utf< 32 >static
decodeWide(In input)sf::Utf< 32 >static
encode(Uint32 input, Out output, Uint32 replacement=0)sf::Utf< 32 >static
encodeAnsi(Uint32 codepoint, Out output, char replacement=0, const std::locale &locale=std::locale())sf::Utf< 32 >static
encodeWide(Uint32 codepoint, Out output, wchar_t replacement=0)sf::Utf< 32 >static
fromAnsi(In begin, In end, Out output, const std::locale &locale=std::locale())sf::Utf< 32 >static
fromLatin1(In begin, In end, Out output)sf::Utf< 32 >static
fromWide(In begin, In end, Out output)sf::Utf< 32 >static
next(In begin, In end)sf::Utf< 32 >static
toAnsi(In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale())sf::Utf< 32 >static
toLatin1(In begin, In end, Out output, char replacement=0)sf::Utf< 32 >static
toUtf16(In begin, In end, Out output)sf::Utf< 32 >static
toUtf32(In begin, In end, Out output)sf::Utf< 32 >static
toUtf8(In begin, In end, Out output)sf::Utf< 32 >static
toWide(In begin, In end, Out output, wchar_t replacement=0)sf::Utf< 32 >static
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0132_01_4.html b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0132_01_4.html new file mode 100644 index 000000000..e36458244 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_0132_01_4.html @@ -0,0 +1,1149 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +List of all members
+
sf::Utf< 32 > Class Reference
+
+
+ +

Specialization of the Utf template for UTF-32. + More...

+ +

#include <SFML/System/Utf.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

template<typename In >
static In decode (In begin, In end, Uint32 &output, Uint32 replacement=0)
 Decode a single UTF-32 character.
 
template<typename Out >
static Out encode (Uint32 input, Out output, Uint32 replacement=0)
 Encode a single UTF-32 character.
 
template<typename In >
static In next (In begin, In end)
 Advance to the next UTF-32 character.
 
template<typename In >
static std::size_t count (In begin, In end)
 Count the number of characters of a UTF-32 sequence.
 
template<typename In , typename Out >
static Out fromAnsi (In begin, In end, Out output, const std::locale &locale=std::locale())
 Convert an ANSI characters range to UTF-32.
 
template<typename In , typename Out >
static Out fromWide (In begin, In end, Out output)
 Convert a wide characters range to UTF-32.
 
template<typename In , typename Out >
static Out fromLatin1 (In begin, In end, Out output)
 Convert a latin-1 (ISO-5589-1) characters range to UTF-32.
 
template<typename In , typename Out >
static Out toAnsi (In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale())
 Convert an UTF-32 characters range to ANSI characters.
 
template<typename In , typename Out >
static Out toWide (In begin, In end, Out output, wchar_t replacement=0)
 Convert an UTF-32 characters range to wide characters.
 
template<typename In , typename Out >
static Out toLatin1 (In begin, In end, Out output, char replacement=0)
 Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters.
 
template<typename In , typename Out >
static Out toUtf8 (In begin, In end, Out output)
 Convert a UTF-32 characters range to UTF-8.
 
template<typename In , typename Out >
static Out toUtf16 (In begin, In end, Out output)
 Convert a UTF-32 characters range to UTF-16.
 
template<typename In , typename Out >
static Out toUtf32 (In begin, In end, Out output)
 Convert a UTF-32 characters range to UTF-32.
 
template<typename In >
static Uint32 decodeAnsi (In input, const std::locale &locale=std::locale())
 Decode a single ANSI character to UTF-32.
 
template<typename In >
static Uint32 decodeWide (In input)
 Decode a single wide character to UTF-32.
 
template<typename Out >
static Out encodeAnsi (Uint32 codepoint, Out output, char replacement=0, const std::locale &locale=std::locale())
 Encode a single UTF-32 character to ANSI.
 
template<typename Out >
static Out encodeWide (Uint32 codepoint, Out output, wchar_t replacement=0)
 Encode a single UTF-32 character to wide.
 
+

Detailed Description

+

Specialization of the Utf template for UTF-32.

+ +

Definition at line 462 of file Utf.hpp.

+

Member Function Documentation

+ +

◆ count()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static std::size_t sf::Utf< 32 >::count (In begin,
In end 
)
+ 		+static
+
+ +

Count the number of characters of a UTF-32 sequence.

+

This function is trivial for UTF-32, which can store every character in a single storage element.

+
Parameters
+ + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
+
+
+
Returns
Iterator pointing to one past the last read element of the input sequence
+ +
+
+ +

◆ decode()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static In sf::Utf< 32 >::decode (In begin,
In end,
Uint32 & output,
Uint32 replacement = 0 
)
+ 		+static
+
+ +

Decode a single UTF-32 character.

+

Decoding a character means finding its unique 32-bits code (called the codepoint) in the Unicode standard. For UTF-32, the character value is the same as the codepoint.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputCodepoint of the decoded UTF-32 character
replacementReplacement character to use in case the UTF-8 sequence is invalid
+
+
+
Returns
Iterator pointing to one past the last read element of the input sequence
+ +
+
+ +

◆ decodeAnsi()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static Uint32 sf::Utf< 32 >::decodeAnsi (In input,
const std::locale & locale = std::locale() 
)
+ 		+static
+
+ +

Decode a single ANSI character to UTF-32.

+

This function does not exist in other specializations of sf::Utf<>, it is defined for convenience (it is used by several other conversion functions).

+
Parameters
+ + + +
inputInput ANSI character
localeLocale to use for conversion
+
+
+
Returns
Converted character
+ +
+
+ +

◆ decodeWide()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + +
static Uint32 sf::Utf< 32 >::decodeWide (In input)
+ 		+static
+
+ +

Decode a single wide character to UTF-32.

+

This function does not exist in other specializations of sf::Utf<>, it is defined for convenience (it is used by several other conversion functions).

+
Parameters
+ + +
inputInput wide character
+
+
+
Returns
Converted character
+ +
+
+ +

◆ encode()

+ +
+
+
+template<typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::encode (Uint32 input,
Out output,
Uint32 replacement = 0 
)
+ 		+static
+
+ +

Encode a single UTF-32 character.

+

Encoding a character means converting a unique 32-bits code (called the codepoint) in the target encoding, UTF-32. For UTF-32, the codepoint is the same as the character value.

+
Parameters
+ + + + +
inputCodepoint to encode as UTF-32
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to UTF-32 (use 0 to skip them)
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ encodeAnsi()

+ +
+
+
+template<typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::encodeAnsi (Uint32 codepoint,
Out output,
char replacement = 0,
const std::locale & locale = std::locale() 
)
+ 		+static
+
+ +

Encode a single UTF-32 character to ANSI.

+

This function does not exist in other specializations of sf::Utf<>, it is defined for convenience (it is used by several other conversion functions).

+
Parameters
+ + + + + +
codepointIterator pointing to the beginning of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement if the input character is not convertible to ANSI (use 0 to skip it)
localeLocale to use for conversion
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ encodeWide()

+ +
+
+
+template<typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::encodeWide (Uint32 codepoint,
Out output,
wchar_t replacement = 0 
)
+ 		+static
+
+ +

Encode a single UTF-32 character to wide.

+

This function does not exist in other specializations of sf::Utf<>, it is defined for convenience (it is used by several other conversion functions).

+
Parameters
+ + + + +
codepointIterator pointing to the beginning of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement if the input character is not convertible to wide (use 0 to skip it)
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ fromAnsi()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::fromAnsi (In begin,
In end,
Out output,
const std::locale & locale = std::locale() 
)
+ 		+static
+
+ +

Convert an ANSI characters range to UTF-32.

+

The current global locale will be used by default, unless you pass a custom one in the locale parameter.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
localeLocale to use for conversion
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ fromLatin1()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::fromLatin1 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a latin-1 (ISO-5589-1) characters range to UTF-32.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ fromWide()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::fromWide (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a wide characters range to UTF-32.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ next()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static In sf::Utf< 32 >::next (In begin,
In end 
)
+ 		+static
+
+ +

Advance to the next UTF-32 character.

+

This function is trivial for UTF-32, which can store every character in a single storage element.

+
Parameters
+ + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
+
+
+
Returns
Iterator pointing to one past the last read element of the input sequence
+ +
+
+ +

◆ toAnsi()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::toAnsi (In begin,
In end,
Out output,
char replacement = 0,
const std::locale & locale = std::locale() 
)
+ 		+static
+
+ +

Convert an UTF-32 characters range to ANSI characters.

+

The current global locale will be used by default, unless you pass a custom one in the locale parameter.

+
Parameters
+ + + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to ANSI (use 0 to skip them)
localeLocale to use for conversion
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toLatin1()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::toLatin1 (In begin,
In end,
Out output,
char replacement = 0 
)
+ 		+static
+
+ +

Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to wide (use 0 to skip them)
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toUtf16()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::toUtf16 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a UTF-32 characters range to UTF-16.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toUtf32()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::toUtf32 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a UTF-32 characters range to UTF-32.

+

This functions does nothing more than a direct copy; it is defined only to provide the same interface as other specializations of the sf::Utf<> template, and allow generic code to be written on top of it.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toUtf8()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::toUtf8 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a UTF-32 characters range to UTF-8.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toWide()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 32 >::toWide (In begin,
In end,
Out output,
wchar_t replacement = 0 
)
+ 		+static
+
+ +

Convert an UTF-32 characters range to wide characters.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to wide (use 0 to skip them)
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_018_01_4-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_018_01_4-members.html new file mode 100644 index 000000000..adf0c4d1d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_018_01_4-members.html @@ -0,0 +1,121 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Utf< 8 > Member List
+
+
+ +

This is the complete list of members for sf::Utf< 8 >, including all inherited members.

+ + + + + + + + + + + + + + +
count(In begin, In end)sf::Utf< 8 >static
decode(In begin, In end, Uint32 &output, Uint32 replacement=0)sf::Utf< 8 >static
encode(Uint32 input, Out output, Uint8 replacement=0)sf::Utf< 8 >static
fromAnsi(In begin, In end, Out output, const std::locale &locale=std::locale())sf::Utf< 8 >static
fromLatin1(In begin, In end, Out output)sf::Utf< 8 >static
fromWide(In begin, In end, Out output)sf::Utf< 8 >static
next(In begin, In end)sf::Utf< 8 >static
toAnsi(In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale())sf::Utf< 8 >static
toLatin1(In begin, In end, Out output, char replacement=0)sf::Utf< 8 >static
toUtf16(In begin, In end, Out output)sf::Utf< 8 >static
toUtf32(In begin, In end, Out output)sf::Utf< 8 >static
toUtf8(In begin, In end, Out output)sf::Utf< 8 >static
toWide(In begin, In end, Out output, wchar_t replacement=0)sf::Utf< 8 >static
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_018_01_4.html b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_018_01_4.html new file mode 100644 index 000000000..74fe83830 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Utf_3_018_01_4.html @@ -0,0 +1,927 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +List of all members
+
sf::Utf< 8 > Class Reference
+
+
+ +

Specialization of the Utf template for UTF-8. + More...

+ +

#include <SFML/System/Utf.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Static Public Member Functions

template<typename In >
static In decode (In begin, In end, Uint32 &output, Uint32 replacement=0)
 Decode a single UTF-8 character.
 
template<typename Out >
static Out encode (Uint32 input, Out output, Uint8 replacement=0)
 Encode a single UTF-8 character.
 
template<typename In >
static In next (In begin, In end)
 Advance to the next UTF-8 character.
 
template<typename In >
static std::size_t count (In begin, In end)
 Count the number of characters of a UTF-8 sequence.
 
template<typename In , typename Out >
static Out fromAnsi (In begin, In end, Out output, const std::locale &locale=std::locale())
 Convert an ANSI characters range to UTF-8.
 
template<typename In , typename Out >
static Out fromWide (In begin, In end, Out output)
 Convert a wide characters range to UTF-8.
 
template<typename In , typename Out >
static Out fromLatin1 (In begin, In end, Out output)
 Convert a latin-1 (ISO-5589-1) characters range to UTF-8.
 
template<typename In , typename Out >
static Out toAnsi (In begin, In end, Out output, char replacement=0, const std::locale &locale=std::locale())
 Convert an UTF-8 characters range to ANSI characters.
 
template<typename In , typename Out >
static Out toWide (In begin, In end, Out output, wchar_t replacement=0)
 Convert an UTF-8 characters range to wide characters.
 
template<typename In , typename Out >
static Out toLatin1 (In begin, In end, Out output, char replacement=0)
 Convert an UTF-8 characters range to latin-1 (ISO-5589-1) characters.
 
template<typename In , typename Out >
static Out toUtf8 (In begin, In end, Out output)
 Convert a UTF-8 characters range to UTF-8.
 
template<typename In , typename Out >
static Out toUtf16 (In begin, In end, Out output)
 Convert a UTF-8 characters range to UTF-16.
 
template<typename In , typename Out >
static Out toUtf32 (In begin, In end, Out output)
 Convert a UTF-8 characters range to UTF-32.
 
+

Detailed Description

+

Specialization of the Utf template for UTF-8.

+ +

Definition at line 48 of file Utf.hpp.

+

Member Function Documentation

+ +

◆ count()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static std::size_t sf::Utf< 8 >::count (In begin,
In end 
)
+ 		+static
+
+ +

Count the number of characters of a UTF-8 sequence.

+

This function is necessary for multi-elements encodings, as a single character may use more than 1 storage element, thus the total size can be different from (begin - end).

+
Parameters
+ + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
+
+
+
Returns
Iterator pointing to one past the last read element of the input sequence
+ +
+
+ +

◆ decode()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static In sf::Utf< 8 >::decode (In begin,
In end,
Uint32 & output,
Uint32 replacement = 0 
)
+ 		+static
+
+ +

Decode a single UTF-8 character.

+

Decoding a character means finding its unique 32-bits code (called the codepoint) in the Unicode standard.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputCodepoint of the decoded UTF-8 character
replacementReplacement character to use in case the UTF-8 sequence is invalid
+
+
+
Returns
Iterator pointing to one past the last read element of the input sequence
+ +
+
+ +

◆ encode()

+ +
+
+
+template<typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 8 >::encode (Uint32 input,
Out output,
Uint8 replacement = 0 
)
+ 		+static
+
+ +

Encode a single UTF-8 character.

+

Encoding a character means converting a unique 32-bits code (called the codepoint) in the target encoding, UTF-8.

+
Parameters
+ + + + +
inputCodepoint to encode as UTF-8
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to UTF-8 (use 0 to skip them)
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ fromAnsi()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 8 >::fromAnsi (In begin,
In end,
Out output,
const std::locale & locale = std::locale() 
)
+ 		+static
+
+ +

Convert an ANSI characters range to UTF-8.

+

The current global locale will be used by default, unless you pass a custom one in the locale parameter.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
localeLocale to use for conversion
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ fromLatin1()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 8 >::fromLatin1 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a latin-1 (ISO-5589-1) characters range to UTF-8.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ fromWide()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 8 >::fromWide (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a wide characters range to UTF-8.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ next()

+ +
+
+
+template<typename In >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
static In sf::Utf< 8 >::next (In begin,
In end 
)
+ 		+static
+
+ +

Advance to the next UTF-8 character.

+

This function is necessary for multi-elements encodings, as a single character may use more than 1 storage element.

+
Parameters
+ + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
+
+
+
Returns
Iterator pointing to one past the last read element of the input sequence
+ +
+
+ +

◆ toAnsi()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 8 >::toAnsi (In begin,
In end,
Out output,
char replacement = 0,
const std::locale & locale = std::locale() 
)
+ 		+static
+
+ +

Convert an UTF-8 characters range to ANSI characters.

+

The current global locale will be used by default, unless you pass a custom one in the locale parameter.

+
Parameters
+ + + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to ANSI (use 0 to skip them)
localeLocale to use for conversion
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toLatin1()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 8 >::toLatin1 (In begin,
In end,
Out output,
char replacement = 0 
)
+ 		+static
+
+ +

Convert an UTF-8 characters range to latin-1 (ISO-5589-1) characters.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to wide (use 0 to skip them)
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toUtf16()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 8 >::toUtf16 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a UTF-8 characters range to UTF-16.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toUtf32()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 8 >::toUtf32 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a UTF-8 characters range to UTF-32.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toUtf8()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 8 >::toUtf8 (In begin,
In end,
Out output 
)
+ 		+static
+
+ +

Convert a UTF-8 characters range to UTF-8.

+

This functions does nothing more than a direct copy; it is defined only to provide the same interface as other specializations of the sf::Utf<> template, and allow generic code to be written on top of it.

+
Parameters
+ + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+ +

◆ toWide()

+ +
+
+
+template<typename In , typename Out >
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
static Out sf::Utf< 8 >::toWide (In begin,
In end,
Out output,
wchar_t replacement = 0 
)
+ 		+static
+
+ +

Convert an UTF-8 characters range to wide characters.

+
Parameters
+ + + + + +
beginIterator pointing to the beginning of the input sequence
endIterator pointing to the end of the input sequence
outputIterator pointing to the beginning of the output sequence
replacementReplacement for characters not convertible to wide (use 0 to skip them)
+
+
+
Returns
Iterator to the end of the output sequence which has been written
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Vector2-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Vector2-members.html new file mode 100644 index 000000000..fe1682b8b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Vector2-members.html @@ -0,0 +1,125 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Vector2< T > Member List
+
+
+ +

This is the complete list of members for sf::Vector2< T >, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
operator!=(const Vector2< T > &left, const Vector2< T > &right)sf::Vector2< T >related
operator*(const Vector2< T > &left, T right)sf::Vector2< T >related
operator*(T left, const Vector2< T > &right)sf::Vector2< T >related
operator*=(Vector2< T > &left, T right)sf::Vector2< T >related
operator+(const Vector2< T > &left, const Vector2< T > &right)sf::Vector2< T >related
operator+=(Vector2< T > &left, const Vector2< T > &right)sf::Vector2< T >related
operator-(const Vector2< T > &right)sf::Vector2< T >related
operator-(const Vector2< T > &left, const Vector2< T > &right)sf::Vector2< T >related
operator-=(Vector2< T > &left, const Vector2< T > &right)sf::Vector2< T >related
operator/(const Vector2< T > &left, T right)sf::Vector2< T >related
operator/=(Vector2< T > &left, T right)sf::Vector2< T >related
operator==(const Vector2< T > &left, const Vector2< T > &right)sf::Vector2< T >related
Vector2()sf::Vector2< T >
Vector2(T X, T Y)sf::Vector2< T >
Vector2(const Vector2< U > &vector)sf::Vector2< T >explicit
xsf::Vector2< T >
ysf::Vector2< T >
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Vector2.html b/Space-Invaders/sfml/doc/html/classsf_1_1Vector2.html new file mode 100644 index 000000000..c9d63db96 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Vector2.html @@ -0,0 +1,934 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Public Attributes | +Related Functions | +List of all members
+
sf::Vector2< T > Class Template Reference
System module
+
+
+ +

Utility template class for manipulating 2-dimensional vectors. + More...

+ +

#include <SFML/System/Vector2.hpp>

+ + + + + + + + + + + + +

+Public Member Functions

 Vector2 ()
 Default constructor.
 
 Vector2 (T X, T Y)
 Construct the vector from its coordinates.
 
template<typename U >
 Vector2 (const Vector2< U > &vector)
 Construct the vector from another type of vector.
 
+ + + + + + + +

+Public Attributes

T x
 X coordinate of the vector.
 
T y
 Y coordinate of the vector.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Related Functions

(Note that these are not member functions.)

+
template<typename T >
Vector2< T > operator- (const Vector2< T > &right)
 Overload of unary operator -.
 
template<typename T >
Vector2< T > & operator+= (Vector2< T > &left, const Vector2< T > &right)
 Overload of binary operator +=.
 
template<typename T >
Vector2< T > & operator-= (Vector2< T > &left, const Vector2< T > &right)
 Overload of binary operator -=.
 
template<typename T >
Vector2< T > operator+ (const Vector2< T > &left, const Vector2< T > &right)
 Overload of binary operator +.
 
template<typename T >
Vector2< T > operator- (const Vector2< T > &left, const Vector2< T > &right)
 Overload of binary operator -.
 
template<typename T >
Vector2< T > operator* (const Vector2< T > &left, T right)
 Overload of binary operator *.
 
template<typename T >
Vector2< T > operator* (T left, const Vector2< T > &right)
 Overload of binary operator *.
 
template<typename T >
Vector2< T > & operator*= (Vector2< T > &left, T right)
 Overload of binary operator *=.
 
template<typename T >
Vector2< T > operator/ (const Vector2< T > &left, T right)
 Overload of binary operator /.
 
template<typename T >
Vector2< T > & operator/= (Vector2< T > &left, T right)
 Overload of binary operator /=.
 
template<typename T >
bool operator== (const Vector2< T > &left, const Vector2< T > &right)
 Overload of binary operator ==.
 
template<typename T >
bool operator!= (const Vector2< T > &left, const Vector2< T > &right)
 Overload of binary operator !=.
 
+

Detailed Description

+
template<typename T>
+class sf::Vector2< T >

Utility template class for manipulating 2-dimensional vectors.

+

sf::Vector2 is a simple class that defines a mathematical vector with two coordinates (x and y).

+

It can be used to represent anything that has two dimensions: a size, a point, a velocity, etc.

+

The template parameter T is the type of the coordinates. It can be any type that supports arithmetic operations (+, -, /, *) and comparisons (==, !=), for example int or float.

+

You generally don't have to care about the templated form (sf::Vector2<T>), the most common specializations have special typedefs:

    +
  • sf::Vector2<float> is sf::Vector2f
    • +
  • sf::Vector2<int> is sf::Vector2i
    • +
  • sf::Vector2<unsigned int> is sf::Vector2u
    • +
+

The sf::Vector2 class has a small and simple interface, its x and y members can be accessed directly (there are no accessors like setX(), getX()) and it contains no mathematical function like dot product, cross product, length, etc.

+

Usage example:

sf::Vector2f v1(16.5f, 24.f);
+
v1.x = 18.2f;
+
float y = v1.y;
+
+
sf::Vector2f v2 = v1 * 5.f;
+
sf::Vector2f v3;
+
v3 = v1 + v2;
+
+
bool different = (v2 != v3);
+ +
sf::Vector2::y
T y
Y coordinate of the vector.
Definition: Vector2.hpp:76
+

Note: for 3-dimensional vectors, see sf::Vector3.

+ +

Definition at line 37 of file Vector2.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Vector2() [1/3]

+ +
+
+
+template<typename T >
+ + + + + + + +
sf::Vector2< T >::Vector2 ()
+
+ +

Default constructor.

+

Creates a Vector2(0, 0).

+ +
+
+ +

◆ Vector2() [2/3]

+ +
+
+
+template<typename T >
+ + + + + + + + + + + + + + + + + + +
sf::Vector2< T >::Vector2 (T X,
T Y 
)
+
+ +

Construct the vector from its coordinates.

+
Parameters
+ + + +
XX coordinate
YY coordinate
+
+
+ +
+
+ +

◆ Vector2() [3/3]

+ +
+
+
+template<typename T >
+
+template<typename U >
+ + + + + +
+ + + + + + + + +
sf::Vector2< T >::Vector2 (const Vector2< U > & vector)
+ 		+explicit
+
+ +

Construct the vector from another type of vector.

+

This constructor doesn't replace the copy constructor, it's called only when U != T. A call to this constructor will fail to compile if U is not convertible to T.

+
Parameters
+ + +
vectorVector to convert
+
+
+ +
+
+

Friends And Related Function Documentation

+ +

◆ operator!=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (const Vector2< T > & left,
const Vector2< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator !=.

+

This operator compares strict difference between two vectors.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
True if left is not equal to right
+ +
+
+ +

◆ operator*() [1/2]

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2< T > operator* (const Vector2< T > & left,
T right 
)
+ 		+related
+
+ +

Overload of binary operator *.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a scalar value)
+
+
+
Returns
Memberwise multiplication by right
+ +
+
+ +

◆ operator*() [2/2]

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2< T > operator* (T left,
const Vector2< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator *.

+
Parameters
+ + + +
leftLeft operand (a scalar value)
rightRight operand (a vector)
+
+
+
Returns
Memberwise multiplication by left
+ +
+
+ +

◆ operator*=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2< T > & operator*= (Vector2< T > & left,
T right 
)
+ 		+related
+
+ +

Overload of binary operator *=.

+

This operator performs a memberwise multiplication by right, and assigns the result to left.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a scalar value)
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator+()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2< T > operator+ (const Vector2< T > & left,
const Vector2< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator +.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
Memberwise addition of both vectors
+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2< T > & operator+= (Vector2< T > & left,
const Vector2< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator +=.

+

This operator performs a memberwise addition of both vectors, and assigns the result to left.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator-() [1/2]

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2< T > operator- (const Vector2< T > & left,
const Vector2< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator -.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
Memberwise subtraction of both vectors
+ +
+
+ +

◆ operator-() [2/2]

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + +
Vector2< T > operator- (const Vector2< T > & right)
+ 		+related
+
+ +

Overload of unary operator -.

+
Parameters
+ + +
rightVector to negate
+
+
+
Returns
Memberwise opposite of the vector
+ +
+
+ +

◆ operator-=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2< T > & operator-= (Vector2< T > & left,
const Vector2< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator -=.

+

This operator performs a memberwise subtraction of both vectors, and assigns the result to left.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator/()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2< T > operator/ (const Vector2< T > & left,
T right 
)
+ 		+related
+
+ +

Overload of binary operator /.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a scalar value)
+
+
+
Returns
Memberwise division by right
+ +
+
+ +

◆ operator/=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector2< T > & operator/= (Vector2< T > & left,
T right 
)
+ 		+related
+
+ +

Overload of binary operator /=.

+

This operator performs a memberwise division by right, and assigns the result to left.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a scalar value)
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator==()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (const Vector2< T > & left,
const Vector2< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator ==.

+

This operator compares strict equality between two vectors.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
True if left is equal to right
+ +
+
+

Member Data Documentation

+ +

◆ x

+ +
+
+
+template<typename T >
+ + + + +
T sf::Vector2< T >::x
+
+ +

X coordinate of the vector.

+ +

Definition at line 75 of file Vector2.hpp.

+ +
+
+ +

◆ y

+ +
+
+
+template<typename T >
+ + + + +
T sf::Vector2< T >::y
+
+ +

Y coordinate of the vector.

+ +

Definition at line 76 of file Vector2.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Vector3-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Vector3-members.html new file mode 100644 index 000000000..b266813a0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Vector3-members.html @@ -0,0 +1,126 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Vector3< T > Member List
+
+
+ +

This is the complete list of members for sf::Vector3< T >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + +
operator!=(const Vector3< T > &left, const Vector3< T > &right)sf::Vector3< T >related
operator*(const Vector3< T > &left, T right)sf::Vector3< T >related
operator*(T left, const Vector3< T > &right)sf::Vector3< T >related
operator*=(Vector3< T > &left, T right)sf::Vector3< T >related
operator+(const Vector3< T > &left, const Vector3< T > &right)sf::Vector3< T >related
operator+=(Vector3< T > &left, const Vector3< T > &right)sf::Vector3< T >related
operator-(const Vector3< T > &left)sf::Vector3< T >related
operator-(const Vector3< T > &left, const Vector3< T > &right)sf::Vector3< T >related
operator-=(Vector3< T > &left, const Vector3< T > &right)sf::Vector3< T >related
operator/(const Vector3< T > &left, T right)sf::Vector3< T >related
operator/=(Vector3< T > &left, T right)sf::Vector3< T >related
operator==(const Vector3< T > &left, const Vector3< T > &right)sf::Vector3< T >related
Vector3()sf::Vector3< T >
Vector3(T X, T Y, T Z)sf::Vector3< T >
Vector3(const Vector3< U > &vector)sf::Vector3< T >explicit
xsf::Vector3< T >
ysf::Vector3< T >
zsf::Vector3< T >
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Vector3.html b/Space-Invaders/sfml/doc/html/classsf_1_1Vector3.html new file mode 100644 index 000000000..a77ba6586 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Vector3.html @@ -0,0 +1,965 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Public Attributes | +Related Functions | +List of all members
+
sf::Vector3< T > Class Template Reference
System module
+
+
+ +

Utility template class for manipulating 3-dimensional vectors. + More...

+ +

#include <SFML/System/Vector3.hpp>

+ + + + + + + + + + + + +

+Public Member Functions

 Vector3 ()
 Default constructor.
 
 Vector3 (T X, T Y, T Z)
 Construct the vector from its coordinates.
 
template<typename U >
 Vector3 (const Vector3< U > &vector)
 Construct the vector from another type of vector.
 
+ + + + + + + + + + +

+Public Attributes

T x
 X coordinate of the vector.
 
T y
 Y coordinate of the vector.
 
T z
 Z coordinate of the vector.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Related Functions

(Note that these are not member functions.)

+
template<typename T >
Vector3< T > operator- (const Vector3< T > &left)
 Overload of unary operator -.
 
template<typename T >
Vector3< T > & operator+= (Vector3< T > &left, const Vector3< T > &right)
 Overload of binary operator +=.
 
template<typename T >
Vector3< T > & operator-= (Vector3< T > &left, const Vector3< T > &right)
 Overload of binary operator -=.
 
template<typename T >
Vector3< T > operator+ (const Vector3< T > &left, const Vector3< T > &right)
 Overload of binary operator +.
 
template<typename T >
Vector3< T > operator- (const Vector3< T > &left, const Vector3< T > &right)
 Overload of binary operator -.
 
template<typename T >
Vector3< T > operator* (const Vector3< T > &left, T right)
 Overload of binary operator *.
 
template<typename T >
Vector3< T > operator* (T left, const Vector3< T > &right)
 Overload of binary operator *.
 
template<typename T >
Vector3< T > & operator*= (Vector3< T > &left, T right)
 Overload of binary operator *=.
 
template<typename T >
Vector3< T > operator/ (const Vector3< T > &left, T right)
 Overload of binary operator /.
 
template<typename T >
Vector3< T > & operator/= (Vector3< T > &left, T right)
 Overload of binary operator /=.
 
template<typename T >
bool operator== (const Vector3< T > &left, const Vector3< T > &right)
 Overload of binary operator ==.
 
template<typename T >
bool operator!= (const Vector3< T > &left, const Vector3< T > &right)
 Overload of binary operator !=.
 
+

Detailed Description

+
template<typename T>
+class sf::Vector3< T >

Utility template class for manipulating 3-dimensional vectors.

+

sf::Vector3 is a simple class that defines a mathematical vector with three coordinates (x, y and z).

+

It can be used to represent anything that has three dimensions: a size, a point, a velocity, etc.

+

The template parameter T is the type of the coordinates. It can be any type that supports arithmetic operations (+, -, /, *) and comparisons (==, !=), for example int or float.

+

You generally don't have to care about the templated form (sf::Vector3<T>), the most common specializations have special typedefs:

    +
  • sf::Vector3<float> is sf::Vector3f
    • +
  • sf::Vector3<int> is sf::Vector3i
    • +
+

The sf::Vector3 class has a small and simple interface, its x and y members can be accessed directly (there are no accessors like setX(), getX()) and it contains no mathematical function like dot product, cross product, length, etc.

+

Usage example:

sf::Vector3f v1(16.5f, 24.f, -8.2f);
+
v1.x = 18.2f;
+
float y = v1.y;
+
float z = v1.z;
+
+
sf::Vector3f v2 = v1 * 5.f;
+
sf::Vector3f v3;
+
v3 = v1 + v2;
+
+
bool different = (v2 != v3);
+
sf::Vector3
Utility template class for manipulating 3-dimensional vectors.
Definition: Vector3.hpp:38
+
sf::Vector3::z
T z
Z coordinate of the vector.
Definition: Vector3.hpp:78
+
sf::Vector3::y
T y
Y coordinate of the vector.
Definition: Vector3.hpp:77
+

Note: for 2-dimensional vectors, see sf::Vector2.

+ +

Definition at line 37 of file Vector3.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Vector3() [1/3]

+ +
+
+
+template<typename T >
+ + + + + + + +
sf::Vector3< T >::Vector3 ()
+
+ +

Default constructor.

+

Creates a Vector3(0, 0, 0).

+ +
+
+ +

◆ Vector3() [2/3]

+ +
+
+
+template<typename T >
+ + + + + + + + + + + + + + + + + + + + + + + + +
sf::Vector3< T >::Vector3 (T X,
T Y,
T Z 
)
+
+ +

Construct the vector from its coordinates.

+
Parameters
+ + + + +
XX coordinate
YY coordinate
ZZ coordinate
+
+
+ +
+
+ +

◆ Vector3() [3/3]

+ +
+
+
+template<typename T >
+
+template<typename U >
+ + + + + +
+ + + + + + + + +
sf::Vector3< T >::Vector3 (const Vector3< U > & vector)
+ 		+explicit
+
+ +

Construct the vector from another type of vector.

+

This constructor doesn't replace the copy constructor, it's called only when U != T. A call to this constructor will fail to compile if U is not convertible to T.

+
Parameters
+ + +
vectorVector to convert
+
+
+ +
+
+

Friends And Related Function Documentation

+ +

◆ operator!=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (const Vector3< T > & left,
const Vector3< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator !=.

+

This operator compares strict difference between two vectors.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
True if left is not equal to right
+ +
+
+ +

◆ operator*() [1/2]

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector3< T > operator* (const Vector3< T > & left,
T right 
)
+ 		+related
+
+ +

Overload of binary operator *.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a scalar value)
+
+
+
Returns
Memberwise multiplication by right
+ +
+
+ +

◆ operator*() [2/2]

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector3< T > operator* (T left,
const Vector3< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator *.

+
Parameters
+ + + +
leftLeft operand (a scalar value)
rightRight operand (a vector)
+
+
+
Returns
Memberwise multiplication by left
+ +
+
+ +

◆ operator*=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector3< T > & operator*= (Vector3< T > & left,
T right 
)
+ 		+related
+
+ +

Overload of binary operator *=.

+

This operator performs a memberwise multiplication by right, and assigns the result to left.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a scalar value)
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator+()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector3< T > operator+ (const Vector3< T > & left,
const Vector3< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator +.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
Memberwise addition of both vectors
+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector3< T > & operator+= (Vector3< T > & left,
const Vector3< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator +=.

+

This operator performs a memberwise addition of both vectors, and assigns the result to left.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator-() [1/2]

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + +
Vector3< T > operator- (const Vector3< T > & left)
+ 		+related
+
+ +

Overload of unary operator -.

+
Parameters
+ + +
leftVector to negate
+
+
+
Returns
Memberwise opposite of the vector
+ +
+
+ +

◆ operator-() [2/2]

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector3< T > operator- (const Vector3< T > & left,
const Vector3< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator -.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
Memberwise subtraction of both vectors
+ +
+
+ +

◆ operator-=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector3< T > & operator-= (Vector3< T > & left,
const Vector3< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator -=.

+

This operator performs a memberwise subtraction of both vectors, and assigns the result to left.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator/()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector3< T > operator/ (const Vector3< T > & left,
T right 
)
+ 		+related
+
+ +

Overload of binary operator /.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a scalar value)
+
+
+
Returns
Memberwise division by right
+ +
+
+ +

◆ operator/=()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
Vector3< T > & operator/= (Vector3< T > & left,
T right 
)
+ 		+related
+
+ +

Overload of binary operator /=.

+

This operator performs a memberwise division by right, and assigns the result to left.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a scalar value)
+
+
+
Returns
Reference to left
+ +
+
+ +

◆ operator==()

+ +
+
+
+template<typename T >
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (const Vector3< T > & left,
const Vector3< T > & right 
)
+ 		+related
+
+ +

Overload of binary operator ==.

+

This operator compares strict equality between two vectors.

+
Parameters
+ + + +
leftLeft operand (a vector)
rightRight operand (a vector)
+
+
+
Returns
True if left is equal to right
+ +
+
+

Member Data Documentation

+ +

◆ x

+ +
+
+
+template<typename T >
+ + + + +
T sf::Vector3< T >::x
+
+ +

X coordinate of the vector.

+ +

Definition at line 76 of file Vector3.hpp.

+ +
+
+ +

◆ y

+ +
+
+
+template<typename T >
+ + + + +
T sf::Vector3< T >::y
+
+ +

Y coordinate of the vector.

+ +

Definition at line 77 of file Vector3.hpp.

+ +
+
+ +

◆ z

+ +
+
+
+template<typename T >
+ + + + +
T sf::Vector3< T >::z
+
+ +

Z coordinate of the vector.

+ +

Definition at line 78 of file Vector3.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Vertex-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Vertex-members.html new file mode 100644 index 000000000..c91d9d09b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Vertex-members.html @@ -0,0 +1,116 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Vertex Member List
+
+
+ +

This is the complete list of members for sf::Vertex, including all inherited members.

+ + + + + + + + + +
colorsf::Vertex
positionsf::Vertex
texCoordssf::Vertex
Vertex()sf::Vertex
Vertex(const Vector2f &thePosition)sf::Vertex
Vertex(const Vector2f &thePosition, const Color &theColor)sf::Vertex
Vertex(const Vector2f &thePosition, const Vector2f &theTexCoords)sf::Vertex
Vertex(const Vector2f &thePosition, const Color &theColor, const Vector2f &theTexCoords)sf::Vertex
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Vertex.html b/Space-Invaders/sfml/doc/html/classsf_1_1Vertex.html new file mode 100644 index 000000000..04e8c9f69 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Vertex.html @@ -0,0 +1,395 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Public Attributes | +List of all members
+
sf::Vertex Class Reference
Graphics module
+
+
+ +

Define a point with color and texture coordinates. + More...

+ +

#include <SFML/Graphics/Vertex.hpp>

+ + + + + + + + + + + + + + + + + +

+Public Member Functions

 Vertex ()
 Default constructor.
 
 Vertex (const Vector2f &thePosition)
 Construct the vertex from its position.
 
 Vertex (const Vector2f &thePosition, const Color &theColor)
 Construct the vertex from its position and color.
 
 Vertex (const Vector2f &thePosition, const Vector2f &theTexCoords)
 Construct the vertex from its position and texture coordinates.
 
 Vertex (const Vector2f &thePosition, const Color &theColor, const Vector2f &theTexCoords)
 Construct the vertex from its position, color and texture coordinates.
 
+ + + + + + + + + + +

+Public Attributes

Vector2f position
 2D position of the vertex
 
Color color
 Color of the vertex.
 
Vector2f texCoords
 Coordinates of the texture's pixel to map to the vertex.
 
+

Detailed Description

+

Define a point with color and texture coordinates.

+

A vertex is an improved point.

+

It has a position and other extra attributes that will be used for drawing: in SFML, vertices also have a color and a pair of texture coordinates.

+

The vertex is the building block of drawing. Everything which is visible on screen is made of vertices. They are grouped as 2D primitives (triangles, quads, ...), and these primitives are grouped to create even more complex 2D entities such as sprites, texts, etc.

+

If you use the graphical entities of SFML (sprite, text, shape) you won't have to deal with vertices directly. But if you want to define your own 2D entities, such as tiled maps or particle systems, using vertices will allow you to get maximum performances.

+

Example:

// define a 100x100 square, red, with a 10x10 texture mapped on it
+
sf::Vertex vertices[] =
+
{
+
sf::Vertex(sf::Vector2f( 0, 0), sf::Color::Red, sf::Vector2f( 0, 0)),
+
sf::Vertex(sf::Vector2f( 0, 100), sf::Color::Red, sf::Vector2f( 0, 10)),
+
sf::Vertex(sf::Vector2f(100, 100), sf::Color::Red, sf::Vector2f(10, 10)),
+
sf::Vertex(sf::Vector2f(100, 0), sf::Color::Red, sf::Vector2f(10, 0))
+
};
+
+
// draw it
+
window.draw(vertices, 4, sf::Quads);
+
sf::Color::Red
static const Color Red
Red predefined color.
Definition: Color.hpp:85
+ +
sf::Vertex
Define a point with color and texture coordinates.
Definition: Vertex.hpp:43
+
sf::Quads
@ Quads
List of individual quads (deprecated, don't work with OpenGL ES)
Definition: PrimitiveType.hpp:47
+

Note: although texture coordinates are supposed to be an integer amount of pixels, their type is float because of some buggy graphics drivers that are not able to process integer coordinates correctly.

+
See also
sf::VertexArray
+ +

Definition at line 42 of file Vertex.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Vertex() [1/5]

+ +
+
+ + + + + + + +
sf::Vertex::Vertex ()
+
+ +

Default constructor.

+ +
+
+ +

◆ Vertex() [2/5]

+ +
+
+ + + + + + + + +
sf::Vertex::Vertex (const Vector2f & thePosition)
+
+ +

Construct the vertex from its position.

+

The vertex color is white and texture coordinates are (0, 0).

+
Parameters
+ + +
thePositionVertex position
+
+
+ +
+
+ +

◆ Vertex() [3/5]

+ +
+
+ + + + + + + + + + + + + + + + + + +
sf::Vertex::Vertex (const Vector2f & thePosition,
const Color & theColor 
)
+
+ +

Construct the vertex from its position and color.

+

The texture coordinates are (0, 0).

+
Parameters
+ + + +
thePositionVertex position
theColorVertex color
+
+
+ +
+
+ +

◆ Vertex() [4/5]

+ +
+
+ + + + + + + + + + + + + + + + + + +
sf::Vertex::Vertex (const Vector2f & thePosition,
const Vector2f & theTexCoords 
)
+
+ +

Construct the vertex from its position and texture coordinates.

+

The vertex color is white.

+
Parameters
+ + + +
thePositionVertex position
theTexCoordsVertex texture coordinates
+
+
+ +
+
+ +

◆ Vertex() [5/5]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
sf::Vertex::Vertex (const Vector2f & thePosition,
const Color & theColor,
const Vector2f & theTexCoords 
)
+
+ +

Construct the vertex from its position, color and texture coordinates.

+
Parameters
+ + + + +
thePositionVertex position
theColorVertex color
theTexCoordsVertex texture coordinates
+
+
+ +
+
+

Member Data Documentation

+ +

◆ color

+ +
+
+ + + + +
Color sf::Vertex::color
+
+ +

Color of the vertex.

+ +

Definition at line 98 of file Vertex.hpp.

+ +
+
+ +

◆ position

+ +
+
+ + + + +
Vector2f sf::Vertex::position
+
+ +

2D position of the vertex

+ +

Definition at line 97 of file Vertex.hpp.

+ +
+
+ +

◆ texCoords

+ +
+
+ + + + +
Vector2f sf::Vertex::texCoords
+
+ +

Coordinates of the texture's pixel to map to the vertex.

+ +

Definition at line 99 of file Vertex.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1VertexArray-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1VertexArray-members.html new file mode 100644 index 000000000..c77eae331 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1VertexArray-members.html @@ -0,0 +1,120 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::VertexArray Member List
+
+
+ +

This is the complete list of members for sf::VertexArray, including all inherited members.

+ + + + + + + + + + + + + +
append(const Vertex &vertex)sf::VertexArray
clear()sf::VertexArray
getBounds() constsf::VertexArray
getPrimitiveType() constsf::VertexArray
getVertexCount() constsf::VertexArray
operator[](std::size_t index)sf::VertexArray
operator[](std::size_t index) constsf::VertexArray
resize(std::size_t vertexCount)sf::VertexArray
setPrimitiveType(PrimitiveType type)sf::VertexArray
VertexArray()sf::VertexArray
VertexArray(PrimitiveType type, std::size_t vertexCount=0)sf::VertexArrayexplicit
~Drawable()sf::Drawableinlinevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1VertexArray.html b/Space-Invaders/sfml/doc/html/classsf_1_1VertexArray.html new file mode 100644 index 000000000..1eb9b7417 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1VertexArray.html @@ -0,0 +1,470 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::VertexArray Class Reference
Graphics module
+
+
+ +

Define a set of one or more 2D primitives. + More...

+ +

#include <SFML/Graphics/VertexArray.hpp>

+
+Inheritance diagram for sf::VertexArray:
+
+
+ + +sf::Drawable + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 VertexArray ()
 Default constructor.
 
 VertexArray (PrimitiveType type, std::size_t vertexCount=0)
 Construct the vertex array with a type and an initial number of vertices.
 
std::size_t getVertexCount () const
 Return the vertex count.
 
Vertex & operator[] (std::size_t index)
 Get a read-write access to a vertex by its index.
 
const Vertex & operator[] (std::size_t index) const
 Get a read-only access to a vertex by its index.
 
void clear ()
 Clear the vertex array.
 
void resize (std::size_t vertexCount)
 Resize the vertex array.
 
void append (const Vertex &vertex)
 Add a vertex to the array.
 
void setPrimitiveType (PrimitiveType type)
 Set the type of primitives to draw.
 
PrimitiveType getPrimitiveType () const
 Get the type of primitives drawn by the vertex array.
 
FloatRect getBounds () const
 Compute the bounding rectangle of the vertex array.
 
+

Detailed Description

+

Define a set of one or more 2D primitives.

+

sf::VertexArray is a very simple wrapper around a dynamic array of vertices and a primitives type.

+

It inherits sf::Drawable, but unlike other drawables it is not transformable.

+

Example:

sf::VertexArray lines(sf::LineStrip, 4);
+
lines[0].position = sf::Vector2f(10, 0);
+
lines[1].position = sf::Vector2f(20, 0);
+
lines[2].position = sf::Vector2f(30, 5);
+
lines[3].position = sf::Vector2f(40, 2);
+
+
window.draw(lines);
+ +
sf::VertexArray
Define a set of one or more 2D primitives.
Definition: VertexArray.hpp:46
+
sf::LineStrip
@ LineStrip
List of connected lines, a point uses the previous point to form a line.
Definition: PrimitiveType.hpp:43
+
See also
sf::Vertex
+ +

Definition at line 45 of file VertexArray.hpp.

+

Constructor & Destructor Documentation

+ +

◆ VertexArray() [1/2]

+ +
+
+ + + + + + + +
sf::VertexArray::VertexArray ()
+
+ +

Default constructor.

+

Creates an empty vertex array.

+ +
+
+ +

◆ VertexArray() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
sf::VertexArray::VertexArray (PrimitiveType type,
std::size_t vertexCount = 0 
)
+ 		+explicit
+
+ +

Construct the vertex array with a type and an initial number of vertices.

+
Parameters
+ + + +
typeType of primitives
vertexCountInitial number of vertices in the array
+
+
+ +
+
+

Member Function Documentation

+ +

◆ append()

+ +
+
+ + + + + + + + +
void sf::VertexArray::append (const Vertex & vertex)
+
+ +

Add a vertex to the array.

+
Parameters
+ + +
vertexVertex to add
+
+
+ +
+
+ +

◆ clear()

+ +
+
+ + + + + + + +
void sf::VertexArray::clear ()
+
+ +

Clear the vertex array.

+

This function removes all the vertices from the array. It doesn't deallocate the corresponding memory, so that adding new vertices after clearing doesn't involve reallocating all the memory.

+ +
+
+ +

◆ getBounds()

+ +
+
+ + + + + + + +
FloatRect sf::VertexArray::getBounds () const
+
+ +

Compute the bounding rectangle of the vertex array.

+

This function returns the minimal axis-aligned rectangle that contains all the vertices of the array.

+
Returns
Bounding rectangle of the vertex array
+ +
+
+ +

◆ getPrimitiveType()

+ +
+
+ + + + + + + +
PrimitiveType sf::VertexArray::getPrimitiveType () const
+
+ +

Get the type of primitives drawn by the vertex array.

+
Returns
Primitive type
+ +
+
+ +

◆ getVertexCount()

+ +
+
+ + + + + + + +
std::size_t sf::VertexArray::getVertexCount () const
+
+ +

Return the vertex count.

+
Returns
Number of vertices in the array
+ +
+
+ +

◆ operator[]() [1/2]

+ +
+
+ + + + + + + + +
Vertex & sf::VertexArray::operator[] (std::size_t index)
+
+ +

Get a read-write access to a vertex by its index.

+

This function doesn't check index, it must be in range [0, getVertexCount() - 1]. The behavior is undefined otherwise.

+
Parameters
+ + +
indexIndex of the vertex to get
+
+
+
Returns
Reference to the index-th vertex
+
See also
getVertexCount
+ +
+
+ +

◆ operator[]() [2/2]

+ +
+
+ + + + + + + + +
const Vertex & sf::VertexArray::operator[] (std::size_t index) const
+
+ +

Get a read-only access to a vertex by its index.

+

This function doesn't check index, it must be in range [0, getVertexCount() - 1]. The behavior is undefined otherwise.

+
Parameters
+ + +
indexIndex of the vertex to get
+
+
+
Returns
Const reference to the index-th vertex
+
See also
getVertexCount
+ +
+
+ +

◆ resize()

+ +
+
+ + + + + + + + +
void sf::VertexArray::resize (std::size_t vertexCount)
+
+ +

Resize the vertex array.

+

If vertexCount is greater than the current size, the previous vertices are kept and new (default-constructed) vertices are added. If vertexCount is less than the current size, existing vertices are removed from the array.

+
Parameters
+ + +
vertexCountNew size of the array (number of vertices)
+
+
+ +
+
+ +

◆ setPrimitiveType()

+ +
+
+ + + + + + + + +
void sf::VertexArray::setPrimitiveType (PrimitiveType type)
+
+ +

Set the type of primitives to draw.

+

This function defines how the vertices must be interpreted when it's time to draw them:

    +
  • As points
    • +
  • As lines
    • +
  • As triangles
    • +
  • As quads The default primitive type is sf::Points.
    • +
+
Parameters
+ + +
typeType of primitive
+
+
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1VertexArray.png b/Space-Invaders/sfml/doc/html/classsf_1_1VertexArray.png new file mode 100644 index 000000000..d67296a97 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1VertexArray.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1VertexBuffer-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1VertexBuffer-members.html new file mode 100644 index 000000000..3a8a140d1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1VertexBuffer-members.html @@ -0,0 +1,133 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::VertexBuffer Member List
+
+
+ +

This is the complete list of members for sf::VertexBuffer, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
bind(const VertexBuffer *vertexBuffer)sf::VertexBufferstatic
create(std::size_t vertexCount)sf::VertexBuffer
Dynamic enum valuesf::VertexBuffer
getNativeHandle() constsf::VertexBuffer
getPrimitiveType() constsf::VertexBuffer
getUsage() constsf::VertexBuffer
getVertexCount() constsf::VertexBuffer
isAvailable()sf::VertexBufferstatic
operator=(const VertexBuffer &right)sf::VertexBuffer
setPrimitiveType(PrimitiveType type)sf::VertexBuffer
setUsage(Usage usage)sf::VertexBuffer
Static enum valuesf::VertexBuffer
Stream enum valuesf::VertexBuffer
swap(VertexBuffer &right)sf::VertexBuffer
update(const Vertex *vertices)sf::VertexBuffer
update(const Vertex *vertices, std::size_t vertexCount, unsigned int offset)sf::VertexBuffer
update(const VertexBuffer &vertexBuffer)sf::VertexBuffer
Usage enum namesf::VertexBuffer
VertexBuffer()sf::VertexBuffer
VertexBuffer(PrimitiveType type)sf::VertexBufferexplicit
VertexBuffer(Usage usage)sf::VertexBufferexplicit
VertexBuffer(PrimitiveType type, Usage usage)sf::VertexBuffer
VertexBuffer(const VertexBuffer &copy)sf::VertexBuffer
~Drawable()sf::Drawableinlinevirtual
~VertexBuffer()sf::VertexBuffer
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1VertexBuffer.html b/Space-Invaders/sfml/doc/html/classsf_1_1VertexBuffer.html new file mode 100644 index 000000000..62997c4e1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1VertexBuffer.html @@ -0,0 +1,831 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Types | +Public Member Functions | +Static Public Member Functions | +List of all members
+
sf::VertexBuffer Class Reference
Graphics module
+
+
+ +

Vertex buffer storage for one or more 2D primitives. + More...

+ +

#include <SFML/Graphics/VertexBuffer.hpp>

+
+Inheritance diagram for sf::VertexBuffer:
+
+
+ + +sf::Drawable +sf::GlResource + +
+ + + + + +

+Public Types

enum  Usage { Stream +, Dynamic +, Static + }
 Usage specifiers. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 VertexBuffer ()
 Default constructor.
 
 VertexBuffer (PrimitiveType type)
 Construct a VertexBuffer with a specific PrimitiveType.
 
 VertexBuffer (Usage usage)
 Construct a VertexBuffer with a specific usage specifier.
 
 VertexBuffer (PrimitiveType type, Usage usage)
 Construct a VertexBuffer with a specific PrimitiveType and usage specifier.
 
 VertexBuffer (const VertexBuffer &copy)
 Copy constructor.
 
 ~VertexBuffer ()
 Destructor.
 
bool create (std::size_t vertexCount)
 Create the vertex buffer.
 
std::size_t getVertexCount () const
 Return the vertex count.
 
bool update (const Vertex *vertices)
 Update the whole buffer from an array of vertices.
 
bool update (const Vertex *vertices, std::size_t vertexCount, unsigned int offset)
 Update a part of the buffer from an array of vertices.
 
bool update (const VertexBuffer &vertexBuffer)
 Copy the contents of another buffer into this buffer.
 
VertexBuffer & operator= (const VertexBuffer &right)
 Overload of assignment operator.
 
void swap (VertexBuffer &right)
 Swap the contents of this vertex buffer with those of another.
 
unsigned int getNativeHandle () const
 Get the underlying OpenGL handle of the vertex buffer.
 
void setPrimitiveType (PrimitiveType type)
 Set the type of primitives to draw.
 
PrimitiveType getPrimitiveType () const
 Get the type of primitives drawn by the vertex buffer.
 
void setUsage (Usage usage)
 Set the usage specifier of this vertex buffer.
 
Usage getUsage () const
 Get the usage specifier of this vertex buffer.
 
+ + + + + + + +

+Static Public Member Functions

static void bind (const VertexBuffer *vertexBuffer)
 Bind a vertex buffer for rendering.
 
static bool isAvailable ()
 Tell whether or not the system supports vertex buffers.
 
+

Detailed Description

+

Vertex buffer storage for one or more 2D primitives.

+

sf::VertexBuffer is a simple wrapper around a dynamic buffer of vertices and a primitives type.

+

Unlike sf::VertexArray, the vertex data is stored in graphics memory.

+

In situations where a large amount of vertex data would have to be transferred from system memory to graphics memory every frame, using sf::VertexBuffer can help. By using a sf::VertexBuffer, data that has not been changed between frames does not have to be re-transferred from system to graphics memory as would be the case with sf::VertexArray. If data transfer is a bottleneck, this can lead to performance gains.

+

Using sf::VertexBuffer, the user also has the ability to only modify a portion of the buffer in graphics memory. This way, a large buffer can be allocated at the start of the application and only the applicable portions of it need to be updated during the course of the application. This allows the user to take full control of data transfers between system and graphics memory if they need to.

+

In special cases, the user can make use of multiple threads to update vertex data in multiple distinct regions of the buffer simultaneously. This might make sense when e.g. the position of multiple objects has to be recalculated very frequently. The computation load can be spread across multiple threads as long as there are no other data dependencies.

+

Simultaneous updates to the vertex buffer are not guaranteed to be carried out by the driver in any specific order. Updating the same region of the buffer from multiple threads will not cause undefined behaviour, however the final state of the buffer will be unpredictable.

+

Simultaneous updates of distinct non-overlapping regions of the buffer are also not guaranteed to complete in a specific order. However, in this case the user can make sure to synchronize the writer threads at well-defined points in their code. The driver will make sure that all pending data transfers complete before the vertex buffer is sourced by the rendering pipeline.

+

It inherits sf::Drawable, but unlike other drawables it is not transformable.

+

Example:

sf::Vertex vertices[15];
+
...
+
sf::VertexBuffer triangles(sf::Triangles);
+
triangles.create(15);
+
triangles.update(vertices);
+
...
+
window.draw(triangles);
+
sf::Vertex
Define a point with color and texture coordinates.
Definition: Vertex.hpp:43
+
sf::Triangles
@ Triangles
List of individual triangles.
Definition: PrimitiveType.hpp:44
+
See also
sf::Vertex, sf::VertexArray
+ +

Definition at line 46 of file VertexBuffer.hpp.

+

Member Enumeration Documentation

+ +

◆ Usage

+ +
+
+ + + + +
enum sf::VertexBuffer::Usage
+
+ +

Usage specifiers.

+

If data is going to be updated once or more every frame, set the usage to Stream. If data is going to be set once and used for a long time without being modified, set the usage to Static. For everything else Dynamic should be a good compromise.

+ + + + +
Enumerator
Stream 

Constantly changing data.

+
Dynamic 

Occasionally changing data.

+
Static 

Rarely changing data.

+
+ +

Definition at line 60 of file VertexBuffer.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ VertexBuffer() [1/5]

+ +
+
+ + + + + + + +
sf::VertexBuffer::VertexBuffer ()
+
+ +

Default constructor.

+

Creates an empty vertex buffer.

+ +
+
+ +

◆ VertexBuffer() [2/5]

+ +
+
+ + + + + +
+ + + + + + + + +
sf::VertexBuffer::VertexBuffer (PrimitiveType type)
+ 		+explicit
+
+ +

Construct a VertexBuffer with a specific PrimitiveType.

+

Creates an empty vertex buffer and sets its primitive type to type.

+
Parameters
+ + +
typeType of primitive
+
+
+ +
+
+ +

◆ VertexBuffer() [3/5]

+ +
+
+ + + + + +
+ + + + + + + + +
sf::VertexBuffer::VertexBuffer (Usage usage)
+ 		+explicit
+
+ +

Construct a VertexBuffer with a specific usage specifier.

+

Creates an empty vertex buffer and sets its usage to usage.

+
Parameters
+ + +
usageUsage specifier
+
+
+ +
+
+ +

◆ VertexBuffer() [4/5]

+ +
+
+ + + + + + + + + + + + + + + + + + +
sf::VertexBuffer::VertexBuffer (PrimitiveType type,
Usage usage 
)
+
+ +

Construct a VertexBuffer with a specific PrimitiveType and usage specifier.

+

Creates an empty vertex buffer and sets its primitive type to type and usage to usage.

+
Parameters
+ + + +
typeType of primitive
usageUsage specifier
+
+
+ +
+
+ +

◆ VertexBuffer() [5/5]

+ +
+
+ + + + + + + + +
sf::VertexBuffer::VertexBuffer (const VertexBuffer & copy)
+
+ +

Copy constructor.

+
Parameters
+ + +
copyinstance to copy
+
+
+ +
+
+ +

◆ ~VertexBuffer()

+ +
+
+ + + + + + + +
sf::VertexBuffer::~VertexBuffer ()
+
+ +

Destructor.

+ +
+
+

Member Function Documentation

+ +

◆ bind()

+ +
+
+ + + + + +
+ + + + + + + + +
static void sf::VertexBuffer::bind (const VertexBuffer * vertexBuffer)
+ 		+static
+
+ +

Bind a vertex buffer for rendering.

+

This function is not part of the graphics API, it mustn't be used when drawing SFML entities. It must be used only if you mix sf::VertexBuffer with OpenGL code.

+
sf::VertexBuffer vb1, vb2;
+
...
+
sf::VertexBuffer::bind(&vb1);
+
// draw OpenGL stuff that use vb1...
+
sf::VertexBuffer::bind(&vb2);
+
// draw OpenGL stuff that use vb2...
+
sf::VertexBuffer::bind(NULL);
+
// draw OpenGL stuff that use no vertex buffer...
+
sf::VertexBuffer
Vertex buffer storage for one or more 2D primitives.
Definition: VertexBuffer.hpp:47
+
sf::VertexBuffer::bind
static void bind(const VertexBuffer *vertexBuffer)
Bind a vertex buffer for rendering.
+
Parameters
+ + +
vertexBufferPointer to the vertex buffer to bind, can be null to use no vertex buffer
+
+
+ +
+
+ +

◆ create()

+ +
+
+ + + + + + + + +
bool sf::VertexBuffer::create (std::size_t vertexCount)
+
+ +

Create the vertex buffer.

+

Creates the vertex buffer and allocates enough graphics memory to hold vertexCount vertices. Any previously allocated memory is freed in the process.

+

In order to deallocate previously allocated memory pass 0 as vertexCount. Don't forget to recreate with a non-zero value when graphics memory should be allocated again.

+
Parameters
+ + +
vertexCountNumber of vertices worth of memory to allocate
+
+
+
Returns
True if creation was successful
+ +
+
+ +

◆ getNativeHandle()

+ +
+
+ + + + + + + +
unsigned int sf::VertexBuffer::getNativeHandle () const
+
+ +

Get the underlying OpenGL handle of the vertex buffer.

+

You shouldn't need to use this function, unless you have very specific stuff to implement that SFML doesn't support, or implement a temporary workaround until a bug is fixed.

+
Returns
OpenGL handle of the vertex buffer or 0 if not yet created
+ +
+
+ +

◆ getPrimitiveType()

+ +
+
+ + + + + + + +
PrimitiveType sf::VertexBuffer::getPrimitiveType () const
+
+ +

Get the type of primitives drawn by the vertex buffer.

+
Returns
Primitive type
+ +
+
+ +

◆ getUsage()

+ +
+
+ + + + + + + +
Usage sf::VertexBuffer::getUsage () const
+
+ +

Get the usage specifier of this vertex buffer.

+
Returns
Usage specifier
+ +
+
+ +

◆ getVertexCount()

+ +
+
+ + + + + + + +
std::size_t sf::VertexBuffer::getVertexCount () const
+
+ +

Return the vertex count.

+
Returns
Number of vertices in the vertex buffer
+ +
+
+ +

◆ isAvailable()

+ +
+
+ + + + + +
+ + + + + + + +
static bool sf::VertexBuffer::isAvailable ()
+ 		+static
+
+ +

Tell whether or not the system supports vertex buffers.

+

This function should always be called before using the vertex buffer features. If it returns false, then any attempt to use sf::VertexBuffer will fail.

+
Returns
True if vertex buffers are supported, false otherwise
+ +
+
+ +

◆ operator=()

+ +
+
+ + + + + + + + +
VertexBuffer & sf::VertexBuffer::operator= (const VertexBuffer & right)
+
+ +

Overload of assignment operator.

+
Parameters
+ + +
rightInstance to assign
+
+
+
Returns
Reference to self
+ +
+
+ +

◆ setPrimitiveType()

+ +
+
+ + + + + + + + +
void sf::VertexBuffer::setPrimitiveType (PrimitiveType type)
+
+ +

Set the type of primitives to draw.

+

This function defines how the vertices must be interpreted when it's time to draw them.

+

The default primitive type is sf::Points.

+
Parameters
+ + +
typeType of primitive
+
+
+ +
+
+ +

◆ setUsage()

+ +
+
+ + + + + + + + +
void sf::VertexBuffer::setUsage (Usage usage)
+
+ +

Set the usage specifier of this vertex buffer.

+

This function provides a hint about how this vertex buffer is going to be used in terms of data update frequency.

+

After changing the usage specifier, the vertex buffer has to be updated with new data for the usage specifier to take effect.

+

The default primitive type is sf::VertexBuffer::Stream.

+
Parameters
+ + +
usageUsage specifier
+
+
+ +
+
+ +

◆ swap()

+ +
+
+ + + + + + + + +
void sf::VertexBuffer::swap (VertexBuffer & right)
+
+ +

Swap the contents of this vertex buffer with those of another.

+
Parameters
+ + +
rightInstance to swap with
+
+
+ +
+
+ +

◆ update() [1/3]

+ +
+
+ + + + + + + + +
bool sf::VertexBuffer::update (const Vertex * vertices)
+
+ +

Update the whole buffer from an array of vertices.

+

The vertex array is assumed to have the same size as the created buffer.

+

No additional check is performed on the size of the vertex array, passing invalid arguments will lead to undefined behavior.

+

This function does nothing if vertices is null or if the buffer was not previously created.

+
Parameters
+ + +
verticesArray of vertices to copy to the buffer
+
+
+
Returns
True if the update was successful
+ +
+
+ +

◆ update() [2/3]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::VertexBuffer::update (const Vertex * vertices,
std::size_t vertexCount,
unsigned int offset 
)
+
+ +

Update a part of the buffer from an array of vertices.

+

offset is specified as the number of vertices to skip from the beginning of the buffer.

+

If offset is 0 and vertexCount is equal to the size of the currently created buffer, its whole contents are replaced.

+

If offset is 0 and vertexCount is greater than the size of the currently created buffer, a new buffer is created containing the vertex data.

+

If offset is 0 and vertexCount is less than the size of the currently created buffer, only the corresponding region is updated.

+

If offset is not 0 and offset + vertexCount is greater than the size of the currently created buffer, the update fails.

+

No additional check is performed on the size of the vertex array, passing invalid arguments will lead to undefined behavior.

+
Parameters
+ + + + +
verticesArray of vertices to copy to the buffer
vertexCountNumber of vertices to copy
offsetOffset in the buffer to copy to
+
+
+
Returns
True if the update was successful
+ +
+
+ +

◆ update() [3/3]

+ +
+
+ + + + + + + + +
bool sf::VertexBuffer::update (const VertexBuffer & vertexBuffer)
+
+ +

Copy the contents of another buffer into this buffer.

+
Parameters
+ + +
vertexBufferVertex buffer whose contents to copy into this vertex buffer
+
+
+
Returns
True if the copy was successful
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1VertexBuffer.png b/Space-Invaders/sfml/doc/html/classsf_1_1VertexBuffer.png new file mode 100644 index 000000000..5227d4206 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1VertexBuffer.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1VideoMode-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1VideoMode-members.html new file mode 100644 index 000000000..8d8d2d8e2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1VideoMode-members.html @@ -0,0 +1,122 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::VideoMode Member List
+
+
+ +

This is the complete list of members for sf::VideoMode, including all inherited members.

+ + + + + + + + + + + + + + + +
bitsPerPixelsf::VideoMode
getDesktopMode()sf::VideoModestatic
getFullscreenModes()sf::VideoModestatic
heightsf::VideoMode
isValid() constsf::VideoMode
operator!=(const VideoMode &left, const VideoMode &right)sf::VideoModerelated
operator<(const VideoMode &left, const VideoMode &right)sf::VideoModerelated
operator<=(const VideoMode &left, const VideoMode &right)sf::VideoModerelated
operator==(const VideoMode &left, const VideoMode &right)sf::VideoModerelated
operator>(const VideoMode &left, const VideoMode &right)sf::VideoModerelated
operator>=(const VideoMode &left, const VideoMode &right)sf::VideoModerelated
VideoMode()sf::VideoMode
VideoMode(unsigned int modeWidth, unsigned int modeHeight, unsigned int modeBitsPerPixel=32)sf::VideoMode
widthsf::VideoMode
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1VideoMode.html b/Space-Invaders/sfml/doc/html/classsf_1_1VideoMode.html new file mode 100644 index 000000000..7676a989d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1VideoMode.html @@ -0,0 +1,681 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Static Public Member Functions | +Public Attributes | +Related Functions | +List of all members
+
sf::VideoMode Class Reference
Window module
+
+
+ +

VideoMode defines a video mode (width, height, bpp) + More...

+ +

#include <SFML/Window/VideoMode.hpp>

+ + + + + + + + + + + +

+Public Member Functions

 VideoMode ()
 Default constructor.
 
 VideoMode (unsigned int modeWidth, unsigned int modeHeight, unsigned int modeBitsPerPixel=32)
 Construct the video mode with its attributes.
 
bool isValid () const
 Tell whether or not the video mode is valid.
 
+ + + + + + + +

+Static Public Member Functions

static VideoMode getDesktopMode ()
 Get the current desktop video mode.
 
static const std::vector< VideoMode > & getFullscreenModes ()
 Retrieve all the video modes supported in fullscreen mode.
 
+ + + + + + + + + + +

+Public Attributes

unsigned int width
 Video mode width, in pixels.
 
unsigned int height
 Video mode height, in pixels.
 
unsigned int bitsPerPixel
 Video mode pixel depth, in bits per pixels.
 
+ + + + + + + + + + + + + + + + + + + + +

+Related Functions

(Note that these are not member functions.)

+
bool operator== (const VideoMode &left, const VideoMode &right)
 Overload of == operator to compare two video modes.
 
bool operator!= (const VideoMode &left, const VideoMode &right)
 Overload of != operator to compare two video modes.
 
bool operator< (const VideoMode &left, const VideoMode &right)
 Overload of < operator to compare video modes.
 
bool operator> (const VideoMode &left, const VideoMode &right)
 Overload of > operator to compare video modes.
 
bool operator<= (const VideoMode &left, const VideoMode &right)
 Overload of <= operator to compare video modes.
 
bool operator>= (const VideoMode &left, const VideoMode &right)
 Overload of >= operator to compare video modes.
 
+

Detailed Description

+

VideoMode defines a video mode (width, height, bpp)

+

A video mode is defined by a width and a height (in pixels) and a depth (in bits per pixel).

+

Video modes are used to setup windows (sf::Window) at creation time.

+

The main usage of video modes is for fullscreen mode: indeed you must use one of the valid video modes allowed by the OS (which are defined by what the monitor and the graphics card support), otherwise your window creation will just fail.

+

sf::VideoMode provides a static function for retrieving the list of all the video modes supported by the system: getFullscreenModes().

+

A custom video mode can also be checked directly for fullscreen compatibility with its isValid() function.

+

Additionally, sf::VideoMode provides a static function to get the mode currently used by the desktop: getDesktopMode(). This allows to build windows with the same size or pixel depth as the current resolution.

+

Usage example:

// Display the list of all the video modes available for fullscreen
+
std::vector<sf::VideoMode> modes = sf::VideoMode::getFullscreenModes();
+
for (std::size_t i = 0; i < modes.size(); ++i)
+
{
+
sf::VideoMode mode = modes[i];
+
std::cout << "Mode #" << i << ": "
+
<< mode.width << "x" << mode.height << " - "
+
<< mode.bitsPerPixel << " bpp" << std::endl;
+
}
+
+
// Create a window with the same pixel depth as the desktop
+
sf::VideoMode desktop = sf::VideoMode::getDesktopMode();
+
window.create(sf::VideoMode(1024, 768, desktop.bitsPerPixel), "SFML window");
+
sf::VideoMode
VideoMode defines a video mode (width, height, bpp)
Definition: VideoMode.hpp:42
+
sf::VideoMode::getFullscreenModes
static const std::vector< VideoMode > & getFullscreenModes()
Retrieve all the video modes supported in fullscreen mode.
+
sf::VideoMode::height
unsigned int height
Video mode height, in pixels.
Definition: VideoMode.hpp:103
+
sf::VideoMode::width
unsigned int width
Video mode width, in pixels.
Definition: VideoMode.hpp:102
+
sf::VideoMode::bitsPerPixel
unsigned int bitsPerPixel
Video mode pixel depth, in bits per pixels.
Definition: VideoMode.hpp:104
+
sf::VideoMode::getDesktopMode
static VideoMode getDesktopMode()
Get the current desktop video mode.
+
+

Definition at line 41 of file VideoMode.hpp.

+

Constructor & Destructor Documentation

+ +

◆ VideoMode() [1/2]

+ +
+
+ + + + + + + +
sf::VideoMode::VideoMode ()
+
+ +

Default constructor.

+

This constructors initializes all members to 0.

+ +
+
+ +

◆ VideoMode() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
sf::VideoMode::VideoMode (unsigned int modeWidth,
unsigned int modeHeight,
unsigned int modeBitsPerPixel = 32 
)
+
+ +

Construct the video mode with its attributes.

+
Parameters
+ + + + +
modeWidthWidth in pixels
modeHeightHeight in pixels
modeBitsPerPixelPixel depths in bits per pixel
+
+
+ +
+
+

Member Function Documentation

+ +

◆ getDesktopMode()

+ +
+
+ + + + + +
+ + + + + + + +
static VideoMode sf::VideoMode::getDesktopMode ()
+ 		+static
+
+ +

Get the current desktop video mode.

+
Returns
Current desktop video mode
+ +
+
+ +

◆ getFullscreenModes()

+ +
+
+ + + + + +
+ + + + + + + +
static const std::vector< VideoMode > & sf::VideoMode::getFullscreenModes ()
+ 		+static
+
+ +

Retrieve all the video modes supported in fullscreen mode.

+

When creating a fullscreen window, the video mode is restricted to be compatible with what the graphics driver and monitor support. This function returns the complete list of all video modes that can be used in fullscreen mode. The returned array is sorted from best to worst, so that the first element will always give the best mode (higher width, height and bits-per-pixel).

+
Returns
Array containing all the supported fullscreen modes
+ +
+
+ +

◆ isValid()

+ +
+
+ + + + + + + +
bool sf::VideoMode::isValid () const
+
+ +

Tell whether or not the video mode is valid.

+

The validity of video modes is only relevant when using fullscreen windows; otherwise any video mode can be used with no restriction.

+
Returns
True if the video mode is valid for fullscreen mode
+ +
+
+

Friends And Related Function Documentation

+ +

◆ operator!=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator!= (const VideoMode & left,
const VideoMode & right 
)
+ 		+related
+
+ +

Overload of != operator to compare two video modes.

+
Parameters
+ + + +
leftLeft operand (a video mode)
rightRight operand (a video mode)
+
+
+
Returns
True if modes are different
+ +
+
+ +

◆ operator<()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator< (const VideoMode & left,
const VideoMode & right 
)
+ 		+related
+
+ +

Overload of < operator to compare video modes.

+
Parameters
+ + + +
leftLeft operand (a video mode)
rightRight operand (a video mode)
+
+
+
Returns
True if left is lesser than right
+ +
+
+ +

◆ operator<=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator<= (const VideoMode & left,
const VideoMode & right 
)
+ 		+related
+
+ +

Overload of <= operator to compare video modes.

+
Parameters
+ + + +
leftLeft operand (a video mode)
rightRight operand (a video mode)
+
+
+
Returns
True if left is lesser or equal than right
+ +
+
+ +

◆ operator==()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator== (const VideoMode & left,
const VideoMode & right 
)
+ 		+related
+
+ +

Overload of == operator to compare two video modes.

+
Parameters
+ + + +
leftLeft operand (a video mode)
rightRight operand (a video mode)
+
+
+
Returns
True if modes are equal
+ +
+
+ +

◆ operator>()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator> (const VideoMode & left,
const VideoMode & right 
)
+ 		+related
+
+ +

Overload of > operator to compare video modes.

+
Parameters
+ + + +
leftLeft operand (a video mode)
rightRight operand (a video mode)
+
+
+
Returns
True if left is greater than right
+ +
+
+ +

◆ operator>=()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
bool operator>= (const VideoMode & left,
const VideoMode & right 
)
+ 		+related
+
+ +

Overload of >= operator to compare video modes.

+
Parameters
+ + + +
leftLeft operand (a video mode)
rightRight operand (a video mode)
+
+
+
Returns
True if left is greater or equal than right
+ +
+
+

Member Data Documentation

+ +

◆ bitsPerPixel

+ +
+
+ + + + +
unsigned int sf::VideoMode::bitsPerPixel
+
+ +

Video mode pixel depth, in bits per pixels.

+ +

Definition at line 104 of file VideoMode.hpp.

+ +
+
+ +

◆ height

+ +
+
+ + + + +
unsigned int sf::VideoMode::height
+
+ +

Video mode height, in pixels.

+ +

Definition at line 103 of file VideoMode.hpp.

+ +
+
+ +

◆ width

+ +
+
+ + + + +
unsigned int sf::VideoMode::width
+
+ +

Video mode width, in pixels.

+ +

Definition at line 102 of file VideoMode.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1View-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1View-members.html new file mode 100644 index 000000000..ed050a098 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1View-members.html @@ -0,0 +1,128 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::View Member List
+
+
+ +

This is the complete list of members for sf::View, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + +
getCenter() constsf::View
getInverseTransform() constsf::View
getRotation() constsf::View
getSize() constsf::View
getTransform() constsf::View
getViewport() constsf::View
move(float offsetX, float offsetY)sf::View
move(const Vector2f &offset)sf::View
reset(const FloatRect &rectangle)sf::View
rotate(float angle)sf::View
setCenter(float x, float y)sf::View
setCenter(const Vector2f &center)sf::View
setRotation(float angle)sf::View
setSize(float width, float height)sf::View
setSize(const Vector2f &size)sf::View
setViewport(const FloatRect &viewport)sf::View
View()sf::View
View(const FloatRect &rectangle)sf::Viewexplicit
View(const Vector2f &center, const Vector2f &size)sf::View
zoom(float factor)sf::View
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1View.html b/Space-Invaders/sfml/doc/html/classsf_1_1View.html new file mode 100644 index 000000000..903776c27 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1View.html @@ -0,0 +1,782 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +List of all members
+
sf::View Class Reference
Graphics module
+
+
+ +

2D camera that defines what region is shown on screen + More...

+ +

#include <SFML/Graphics/View.hpp>

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 View ()
 Default constructor.
 
 View (const FloatRect &rectangle)
 Construct the view from a rectangle.
 
 View (const Vector2f &center, const Vector2f &size)
 Construct the view from its center and size.
 
void setCenter (float x, float y)
 Set the center of the view.
 
void setCenter (const Vector2f &center)
 Set the center of the view.
 
void setSize (float width, float height)
 Set the size of the view.
 
void setSize (const Vector2f &size)
 Set the size of the view.
 
void setRotation (float angle)
 Set the orientation of the view.
 
void setViewport (const FloatRect &viewport)
 Set the target viewport.
 
void reset (const FloatRect &rectangle)
 Reset the view to the given rectangle.
 
const Vector2f & getCenter () const
 Get the center of the view.
 
const Vector2f & getSize () const
 Get the size of the view.
 
float getRotation () const
 Get the current orientation of the view.
 
const FloatRect & getViewport () const
 Get the target viewport rectangle of the view.
 
void move (float offsetX, float offsetY)
 Move the view relatively to its current position.
 
void move (const Vector2f &offset)
 Move the view relatively to its current position.
 
void rotate (float angle)
 Rotate the view relatively to its current orientation.
 
void zoom (float factor)
 Resize the view rectangle relatively to its current size.
 
const Transform & getTransform () const
 Get the projection transform of the view.
 
const Transform & getInverseTransform () const
 Get the inverse projection transform of the view.
 
+

Detailed Description

+

2D camera that defines what region is shown on screen

+

sf::View defines a camera in the 2D scene.

+

This is a very powerful concept: you can scroll, rotate or zoom the entire scene without altering the way that your drawable objects are drawn.

+

A view is composed of a source rectangle, which defines what part of the 2D scene is shown, and a target viewport, which defines where the contents of the source rectangle will be displayed on the render target (window or texture).

+

The viewport allows to map the scene to a custom part of the render target, and can be used for split-screen or for displaying a minimap, for example. If the source rectangle doesn't have the same size as the viewport, its contents will be stretched to fit in.

+

To apply a view, you have to assign it to the render target. Then, objects drawn in this render target will be affected by the view until you use another view.

+

Usage example:

sf::RenderWindow window;
+
sf::View view;
+
+
// Initialize the view to a rectangle located at (100, 100) and with a size of 400x200
+
view.reset(sf::FloatRect(100, 100, 400, 200));
+
+
// Rotate it by 45 degrees
+
view.rotate(45);
+
+
// Set its target viewport to be half of the window
+
view.setViewport(sf::FloatRect(0.f, 0.f, 0.5f, 1.f));
+
+
// Apply it
+
window.setView(view);
+
+
// Render stuff
+
window.draw(someSprite);
+
+
// Set the default view back
+
window.setView(window.getDefaultView());
+
+
// Render stuff not affected by the view
+
window.draw(someText);
+ +
sf::RenderTarget::setView
void setView(const View &view)
Change the current active view.
+
sf::RenderTarget::draw
void draw(const Drawable &drawable, const RenderStates &states=RenderStates::Default)
Draw a drawable object to the render target.
+
sf::RenderTarget::getDefaultView
const View & getDefaultView() const
Get the default view of the render target.
+
sf::RenderWindow
Window that can serve as a target for 2D drawing.
Definition: RenderWindow.hpp:45
+
sf::View
2D camera that defines what region is shown on screen
Definition: View.hpp:44
+
sf::View::rotate
void rotate(float angle)
Rotate the view relatively to its current orientation.
+
sf::View::setViewport
void setViewport(const FloatRect &viewport)
Set the target viewport.
+
sf::View::reset
void reset(const FloatRect &rectangle)
Reset the view to the given rectangle.
+

See also the note on coordinates and undistorted rendering in sf::Transformable.

+
See also
sf::RenderWindow, sf::RenderTexture
+ +

Definition at line 43 of file View.hpp.

+

Constructor & Destructor Documentation

+ +

◆ View() [1/3]

+ +
+
+ + + + + + + +
sf::View::View ()
+
+ +

Default constructor.

+

This constructor creates a default view of (0, 0, 1000, 1000)

+ +
+
+ +

◆ View() [2/3]

+ +
+
+ + + + + +
+ + + + + + + + +
sf::View::View (const FloatRect & rectangle)
+ 		+explicit
+
+ +

Construct the view from a rectangle.

+
Parameters
+ + +
rectangleRectangle defining the zone to display
+
+
+ +
+
+ +

◆ View() [3/3]

+ +
+
+ + + + + + + + + + + + + + + + + + +
sf::View::View (const Vector2f & center,
const Vector2f & size 
)
+
+ +

Construct the view from its center and size.

+
Parameters
+ + + +
centerCenter of the zone to display
sizeSize of zone to display
+
+
+ +
+
+

Member Function Documentation

+ +

◆ getCenter()

+ +
+
+ + + + + + + +
const Vector2f & sf::View::getCenter () const
+
+ +

Get the center of the view.

+
Returns
Center of the view
+
See also
getSize, setCenter
+ +
+
+ +

◆ getInverseTransform()

+ +
+
+ + + + + + + +
const Transform & sf::View::getInverseTransform () const
+
+ +

Get the inverse projection transform of the view.

+

This function is meant for internal use only.

+
Returns
Inverse of the projection transform defining the view
+
See also
getTransform
+ +
+
+ +

◆ getRotation()

+ +
+
+ + + + + + + +
float sf::View::getRotation () const
+
+ +

Get the current orientation of the view.

+
Returns
Rotation angle of the view, in degrees
+
See also
setRotation
+ +
+
+ +

◆ getSize()

+ +
+
+ + + + + + + +
const Vector2f & sf::View::getSize () const
+
+ +

Get the size of the view.

+
Returns
Size of the view
+
See also
getCenter, setSize
+ +
+
+ +

◆ getTransform()

+ +
+
+ + + + + + + +
const Transform & sf::View::getTransform () const
+
+ +

Get the projection transform of the view.

+

This function is meant for internal use only.

+
Returns
Projection transform defining the view
+
See also
getInverseTransform
+ +
+
+ +

◆ getViewport()

+ +
+
+ + + + + + + +
const FloatRect & sf::View::getViewport () const
+
+ +

Get the target viewport rectangle of the view.

+
Returns
Viewport rectangle, expressed as a factor of the target size
+
See also
setViewport
+ +
+
+ +

◆ move() [1/2]

+ +
+
+ + + + + + + + +
void sf::View::move (const Vector2f & offset)
+
+ +

Move the view relatively to its current position.

+
Parameters
+ + +
offsetMove offset
+
+
+
See also
setCenter, rotate, zoom
+ +
+
+ +

◆ move() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::View::move (float offsetX,
float offsetY 
)
+
+ +

Move the view relatively to its current position.

+
Parameters
+ + + +
offsetXX coordinate of the move offset
offsetYY coordinate of the move offset
+
+
+
See also
setCenter, rotate, zoom
+ +
+
+ +

◆ reset()

+ +
+
+ + + + + + + + +
void sf::View::reset (const FloatRect & rectangle)
+
+ +

Reset the view to the given rectangle.

+

Note that this function resets the rotation angle to 0.

+
Parameters
+ + +
rectangleRectangle defining the zone to display
+
+
+
See also
setCenter, setSize, setRotation
+ +
+
+ +

◆ rotate()

+ +
+
+ + + + + + + + +
void sf::View::rotate (float angle)
+
+ +

Rotate the view relatively to its current orientation.

+
Parameters
+ + +
angleAngle to rotate, in degrees
+
+
+
See also
setRotation, move, zoom
+ +
+
+ +

◆ setCenter() [1/2]

+ +
+
+ + + + + + + + +
void sf::View::setCenter (const Vector2f & center)
+
+ +

Set the center of the view.

+
Parameters
+ + +
centerNew center
+
+
+
See also
setSize, getCenter
+ +
+
+ +

◆ setCenter() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::View::setCenter (float x,
float y 
)
+
+ +

Set the center of the view.

+
Parameters
+ + + +
xX coordinate of the new center
yY coordinate of the new center
+
+
+
See also
setSize, getCenter
+ +
+
+ +

◆ setRotation()

+ +
+
+ + + + + + + + +
void sf::View::setRotation (float angle)
+
+ +

Set the orientation of the view.

+

The default rotation of a view is 0 degree.

+
Parameters
+ + +
angleNew angle, in degrees
+
+
+
See also
getRotation
+ +
+
+ +

◆ setSize() [1/2]

+ +
+
+ + + + + + + + +
void sf::View::setSize (const Vector2f & size)
+
+ +

Set the size of the view.

+
Parameters
+ + +
sizeNew size
+
+
+
See also
setCenter, getCenter
+ +
+
+ +

◆ setSize() [2/2]

+ +
+
+ + + + + + + + + + + + + + + + + + +
void sf::View::setSize (float width,
float height 
)
+
+ +

Set the size of the view.

+
Parameters
+ + + +
widthNew width of the view
heightNew height of the view
+
+
+
See also
setCenter, getCenter
+ +
+
+ +

◆ setViewport()

+ +
+
+ + + + + + + + +
void sf::View::setViewport (const FloatRect & viewport)
+
+ +

Set the target viewport.

+

The viewport is the rectangle into which the contents of the view are displayed, expressed as a factor (between 0 and 1) of the size of the RenderTarget to which the view is applied. For example, a view which takes the left side of the target would be defined with View.setViewport(sf::FloatRect(0, 0, 0.5, 1)). By default, a view has a viewport which covers the entire target.

+
Parameters
+ + +
viewportNew viewport rectangle
+
+
+
See also
getViewport
+ +
+
+ +

◆ zoom()

+ +
+
+ + + + + + + + +
void sf::View::zoom (float factor)
+
+ +

Resize the view rectangle relatively to its current size.

+

Resizing the view simulates a zoom, as the zone displayed on screen grows or shrinks. factor is a multiplier:

    +
  • 1 keeps the size unchanged
    • +
  • > 1 makes the view bigger (objects appear smaller)
    • +
  • < 1 makes the view smaller (objects appear bigger)
    • +
+
Parameters
+ + +
factorZoom factor to apply
+
+
+
See also
setSize, move, rotate
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Vulkan-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Vulkan-members.html new file mode 100644 index 000000000..b7f7eb243 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Vulkan-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Vulkan Member List
+
+
+ +

This is the complete list of members for sf::Vulkan, including all inherited members.

+ + + + +
getFunction(const char *name)sf::Vulkanstatic
getGraphicsRequiredInstanceExtensions()sf::Vulkanstatic
isAvailable(bool requireGraphics=true)sf::Vulkanstatic
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Vulkan.html b/Space-Invaders/sfml/doc/html/classsf_1_1Vulkan.html new file mode 100644 index 000000000..bed83aa86 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Vulkan.html @@ -0,0 +1,234 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Static Public Member Functions | +List of all members
+
sf::Vulkan Class Reference
Window module
+
+
+ +

Vulkan helper functions. + More...

+ +

#include <SFML/Window/Vulkan.hpp>

+ + + + + + + + + + + +

+Static Public Member Functions

static bool isAvailable (bool requireGraphics=true)
 Tell whether or not the system supports Vulkan.
 
static VulkanFunctionPointer getFunction (const char *name)
 Get the address of a Vulkan function.
 
static const std::vector< const char * > & getGraphicsRequiredInstanceExtensions ()
 Get Vulkan instance extensions required for graphics.
 
+

Detailed Description

+

Vulkan helper functions.

+ +

Definition at line 62 of file Vulkan.hpp.

+

Member Function Documentation

+ +

◆ getFunction()

+ +
+
+ + + + + +
+ + + + + + + + +
static VulkanFunctionPointer sf::Vulkan::getFunction (const char * name)
+ 		+static
+
+ +

Get the address of a Vulkan function.

+
Parameters
+ + +
nameName of the function to get the address of
+
+
+
Returns
Address of the Vulkan function, 0 on failure
+ +
+
+ +

◆ getGraphicsRequiredInstanceExtensions()

+ +
+
+ + + + + +
+ + + + + + + +
static const std::vector< const char * > & sf::Vulkan::getGraphicsRequiredInstanceExtensions ()
+ 		+static
+
+ +

Get Vulkan instance extensions required for graphics.

+
Returns
Vulkan instance extensions required for graphics
+ +
+
+ +

◆ isAvailable()

+ +
+
+ + + + + +
+ + + + + + + + +
static bool sf::Vulkan::isAvailable (bool requireGraphics = true)
+ 		+static
+
+ +

Tell whether or not the system supports Vulkan.

+

This function should always be called before using the Vulkan features. If it returns false, then any attempt to use Vulkan will fail.

+

If only compute is required, set requireGraphics to false to skip checking for the extensions necessary for graphics rendering.

+
Parameters
+ + +
requireGraphics
+
+
+
Returns
True if Vulkan is supported, false otherwise
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Window-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1Window-members.html new file mode 100644 index 000000000..66ab321ef --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Window-members.html @@ -0,0 +1,147 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::Window Member List
+
+
+ +

This is the complete list of members for sf::Window, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
close()sf::Windowvirtual
create(VideoMode mode, const String &title, Uint32 style=Style::Default)sf::Windowvirtual
create(VideoMode mode, const String &title, Uint32 style, const ContextSettings &settings)sf::Windowvirtual
create(WindowHandle handle)sf::Windowvirtual
create(WindowHandle handle, const ContextSettings &settings)sf::Windowvirtual
createVulkanSurface(const VkInstance &instance, VkSurfaceKHR &surface, const VkAllocationCallbacks *allocator=0)sf::WindowBase
display()sf::Window
getPosition() constsf::WindowBase
getSettings() constsf::Window
getSize() constsf::WindowBase
getSystemHandle() constsf::WindowBase
hasFocus() constsf::WindowBase
isOpen() constsf::WindowBase
onCreate()sf::WindowBaseprotectedvirtual
onResize()sf::WindowBaseprotectedvirtual
pollEvent(Event &event)sf::WindowBase
requestFocus()sf::WindowBase
setActive(bool active=true) constsf::Window
setFramerateLimit(unsigned int limit)sf::Window
setIcon(unsigned int width, unsigned int height, const Uint8 *pixels)sf::WindowBase
setJoystickThreshold(float threshold)sf::WindowBase
setKeyRepeatEnabled(bool enabled)sf::WindowBase
setMouseCursor(const Cursor &cursor)sf::WindowBase
setMouseCursorGrabbed(bool grabbed)sf::WindowBase
setMouseCursorVisible(bool visible)sf::WindowBase
setPosition(const Vector2i &position)sf::WindowBase
setSize(const Vector2u &size)sf::WindowBase
setTitle(const String &title)sf::WindowBase
setVerticalSyncEnabled(bool enabled)sf::Window
setVisible(bool visible)sf::WindowBase
waitEvent(Event &event)sf::WindowBase
Window()sf::Window
Window(VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())sf::Window
Window(WindowHandle handle, const ContextSettings &settings=ContextSettings())sf::Windowexplicit
WindowBase()sf::WindowBase
WindowBase(VideoMode mode, const String &title, Uint32 style=Style::Default)sf::WindowBase
WindowBase(WindowHandle handle)sf::WindowBaseexplicit
~Window()sf::Windowvirtual
~WindowBase()sf::WindowBasevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Window.html b/Space-Invaders/sfml/doc/html/classsf_1_1Window.html new file mode 100644 index 000000000..455517622 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1Window.html @@ -0,0 +1,1536 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Protected Member Functions | +List of all members
+
sf::Window Class Reference
Window module
+
+
+ +

Window that serves as a target for OpenGL rendering. + More...

+ +

#include <SFML/Window/Window.hpp>

+
+Inheritance diagram for sf::Window:
+
+
+ + +sf::WindowBase +sf::GlResource +sf::NonCopyable +sf::RenderWindow + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 Window ()
 Default constructor.
 
 Window (VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())
 Construct a new window.
 
 Window (WindowHandle handle, const ContextSettings &settings=ContextSettings())
 Construct the window from an existing control.
 
virtual ~Window ()
 Destructor.
 
virtual void create (VideoMode mode, const String &title, Uint32 style=Style::Default)
 Create (or recreate) the window.
 
virtual void create (VideoMode mode, const String &title, Uint32 style, const ContextSettings &settings)
 Create (or recreate) the window.
 
virtual void create (WindowHandle handle)
 Create (or recreate) the window from an existing control.
 
virtual void create (WindowHandle handle, const ContextSettings &settings)
 Create (or recreate) the window from an existing control.
 
virtual void close ()
 Close the window and destroy all the attached resources.
 
const ContextSettings & getSettings () const
 Get the settings of the OpenGL context of the window.
 
void setVerticalSyncEnabled (bool enabled)
 Enable or disable vertical synchronization.
 
void setFramerateLimit (unsigned int limit)
 Limit the framerate to a maximum fixed frequency.
 
bool setActive (bool active=true) const
 Activate or deactivate the window as the current target for OpenGL rendering.
 
void display ()
 Display on screen what has been rendered to the window so far.
 
bool isOpen () const
 Tell whether or not the window is open.
 
bool pollEvent (Event &event)
 Pop the event on top of the event queue, if any, and return it.
 
bool waitEvent (Event &event)
 Wait for an event and return it.
 
Vector2i getPosition () const
 Get the position of the window.
 
void setPosition (const Vector2i &position)
 Change the position of the window on screen.
 
Vector2u getSize () const
 Get the size of the rendering region of the window.
 
void setSize (const Vector2u &size)
 Change the size of the rendering region of the window.
 
void setTitle (const String &title)
 Change the title of the window.
 
void setIcon (unsigned int width, unsigned int height, const Uint8 *pixels)
 Change the window's icon.
 
void setVisible (bool visible)
 Show or hide the window.
 
void setMouseCursorVisible (bool visible)
 Show or hide the mouse cursor.
 
void setMouseCursorGrabbed (bool grabbed)
 Grab or release the mouse cursor.
 
void setMouseCursor (const Cursor &cursor)
 Set the displayed cursor to a native system cursor.
 
void setKeyRepeatEnabled (bool enabled)
 Enable or disable automatic key-repeat.
 
void setJoystickThreshold (float threshold)
 Change the joystick threshold.
 
void requestFocus ()
 Request the current window to be made the active foreground window.
 
bool hasFocus () const
 Check whether the window has the input focus.
 
WindowHandle getSystemHandle () const
 Get the OS-specific handle of the window.
 
bool createVulkanSurface (const VkInstance &instance, VkSurfaceKHR &surface, const VkAllocationCallbacks *allocator=0)
 Create a Vulkan rendering surface.
 
+ + + + + + + +

+Protected Member Functions

virtual void onCreate ()
 Function called after the window has been created.
 
virtual void onResize ()
 Function called after the window has been resized.
 
+

Detailed Description

+

Window that serves as a target for OpenGL rendering.

+

sf::Window is the main class of the Window module.

+

It defines an OS window that is able to receive an OpenGL rendering.

+

A sf::Window can create its own new window, or be embedded into an already existing control using the create(handle) function. This can be useful for embedding an OpenGL rendering area into a view which is part of a bigger GUI with existing windows, controls, etc. It can also serve as embedding an OpenGL rendering area into a window created by another (probably richer) GUI library like Qt or wxWidgets.

+

The sf::Window class provides a simple interface for manipulating the window: move, resize, show/hide, control mouse cursor, etc. It also provides event handling through its pollEvent() and waitEvent() functions.

+

Note that OpenGL experts can pass their own parameters (antialiasing level, bits for the depth and stencil buffers, etc.) to the OpenGL context attached to the window, with the sf::ContextSettings structure which is passed as an optional argument when creating the window.

+

On dual-graphics systems consisting of a low-power integrated GPU and a powerful discrete GPU, the driver picks which GPU will run an SFML application. In order to inform the driver that an SFML application can benefit from being run on the more powerful discrete GPU, SFML_DEFINE_DISCRETE_GPU_PREFERENCE can be placed in a source file that is compiled and linked into the final application. The macro should be placed outside of any scopes in the global namespace.

+

Usage example:

// Declare and create a new window
+
sf::Window window(sf::VideoMode(800, 600), "SFML window");
+
+
// Limit the framerate to 60 frames per second (this step is optional)
+
window.setFramerateLimit(60);
+
+
// The main loop - ends as soon as the window is closed
+
while (window.isOpen())
+
{
+
// Event processing
+
sf::Event event;
+
while (window.pollEvent(event))
+
{
+
// Request for closing the window
+
if (event.type == sf::Event::Closed)
+
window.close();
+
}
+
+
// Activate the window for OpenGL rendering
+
window.setActive();
+
+
// OpenGL drawing commands go here...
+
+
// End the current frame and display its contents on screen
+
window.display();
+
}
+
sf::Event
Defines a system event and its parameters.
Definition: Event.hpp:45
+
sf::Event::type
EventType type
Type of the event.
Definition: Event.hpp:220
+
sf::Event::Closed
@ Closed
The window requested to be closed (no data)
Definition: Event.hpp:190
+
sf::VideoMode
VideoMode defines a video mode (width, height, bpp)
Definition: VideoMode.hpp:42
+
sf::Window
Window that serves as a target for OpenGL rendering.
Definition: Window/Window.hpp:50
+
+

Definition at line 49 of file Window/Window.hpp.

+

Constructor & Destructor Documentation

+ +

◆ Window() [1/3]

+ +
+
+ + + + + + + +
sf::Window::Window ()
+
+ +

Default constructor.

+

This constructor doesn't actually create the window, use the other constructors or call create() to do so.

+ +
+
+ +

◆ Window() [2/3]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sf::Window::Window (VideoMode mode,
const String & title,
Uint32 style = Style::Default,
const ContextSettings & settings = ContextSettings() 
)
+
+ +

Construct a new window.

+

This constructor creates the window with the size and pixel depth defined in mode. An optional style can be passed to customize the look and behavior of the window (borders, title bar, resizable, closable, ...). If style contains Style::Fullscreen, then mode must be a valid video mode.

+

The fourth parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

+
Parameters
+ + + + + +
modeVideo mode to use (defines the width, height and depth of the rendering area of the window)
titleTitle of the window
styleWindow style, a bitwise OR combination of sf::Style enumerators
settingsAdditional settings for the underlying OpenGL context
+
+
+ +
+
+ +

◆ Window() [3/3]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
sf::Window::Window (WindowHandle handle,
const ContextSettings & settings = ContextSettings() 
)
+ 		+explicit
+
+ +

Construct the window from an existing control.

+

Use this constructor if you want to create an OpenGL rendering area into an already existing control.

+

The second parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

+
Parameters
+ + + +
handlePlatform-specific handle of the control
settingsAdditional settings for the underlying OpenGL context
+
+
+ +
+
+ +

◆ ~Window()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::Window::~Window ()
+ 		+virtual
+
+ +

Destructor.

+

Closes the window and frees all the resources attached to it.

+ +
+
+

Member Function Documentation

+ +

◆ close()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::Window::close ()
+ 		+virtual
+
+ +

Close the window and destroy all the attached resources.

+

After calling this function, the sf::Window instance remains valid and you can call create() to recreate the window. All other functions such as pollEvent() or display() will still work (i.e. you don't have to test isOpen() every time), and will have no effect on closed windows.

+ +

Reimplemented from sf::WindowBase.

+ +
+
+ +

◆ create() [1/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
virtual void sf::Window::create (VideoMode mode,
const String & title,
Uint32 style,
const ContextSettings & settings 
)
+ 		+virtual
+
+ +

Create (or recreate) the window.

+

If the window was already created, it closes it first. If style contains Style::Fullscreen, then mode must be a valid video mode.

+

The fourth parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

+
Parameters
+ + + + + +
modeVideo mode to use (defines the width, height and depth of the rendering area of the window)
titleTitle of the window
styleWindow style, a bitwise OR combination of sf::Style enumerators
settingsAdditional settings for the underlying OpenGL context
+
+
+ +
+
+ +

◆ create() [2/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
virtual void sf::Window::create (VideoMode mode,
const String & title,
Uint32 style = Style::Default 
)
+ 		+virtual
+
+ +

Create (or recreate) the window.

+

If the window was already created, it closes it first. If style contains Style::Fullscreen, then mode must be a valid video mode.

+
Parameters
+ + + + +
modeVideo mode to use (defines the width, height and depth of the rendering area of the window)
titleTitle of the window
styleWindow style, a bitwise OR combination of sf::Style enumerators
+
+
+ +

Reimplemented from sf::WindowBase.

+ +
+
+ +

◆ create() [3/4]

+ +
+
+ + + + + +
+ + + + + + + + +
virtual void sf::Window::create (WindowHandle handle)
+ 		+virtual
+
+ +

Create (or recreate) the window from an existing control.

+

Use this function if you want to create an OpenGL rendering area into an already existing control. If the window was already created, it closes it first.

+
Parameters
+ + +
handlePlatform-specific handle of the control
+
+
+ +

Reimplemented from sf::WindowBase.

+ +
+
+ +

◆ create() [4/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
virtual void sf::Window::create (WindowHandle handle,
const ContextSettings & settings 
)
+ 		+virtual
+
+ +

Create (or recreate) the window from an existing control.

+

Use this function if you want to create an OpenGL rendering area into an already existing control. If the window was already created, it closes it first.

+

The second parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

+
Parameters
+ + + +
handlePlatform-specific handle of the control
settingsAdditional settings for the underlying OpenGL context
+
+
+ +
+
+ +

◆ createVulkanSurface()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::WindowBase::createVulkanSurface (const VkInstance & instance,
VkSurfaceKHR & surface,
const VkAllocationCallbacks * allocator = 0 
)
+ 		+inherited
+
+ +

Create a Vulkan rendering surface.

+
Parameters
+ + + + +
instanceVulkan instance
surfaceCreated surface
allocatorAllocator to use
+
+
+
Returns
True if surface creation was successful, false otherwise
+ +
+
+ +

◆ display()

+ +
+
+ + + + + + + +
void sf::Window::display ()
+
+ +

Display on screen what has been rendered to the window so far.

+

This function is typically called after all OpenGL rendering has been done for the current frame, in order to show it on screen.

+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + +
+ + + + + + + +
Vector2i sf::WindowBase::getPosition () const
+ 		+inherited
+
+ +

Get the position of the window.

+
Returns
Position of the window, in pixels
+
See also
setPosition
+ +
+
+ +

◆ getSettings()

+ +
+
+ + + + + + + +
const ContextSettings & sf::Window::getSettings () const
+
+ +

Get the settings of the OpenGL context of the window.

+

Note that these settings may be different from what was passed to the constructor or the create() function, if one or more settings were not supported. In this case, SFML chose the closest match.

+
Returns
Structure containing the OpenGL context settings
+ +
+
+ +

◆ getSize()

+ +
+
+ + + + + +
+ + + + + + + +
Vector2u sf::WindowBase::getSize () const
+ 		+inherited
+
+ +

Get the size of the rendering region of the window.

+

The size doesn't include the titlebar and borders of the window.

+
Returns
Size in pixels
+
See also
setSize
+ +
+
+ +

◆ getSystemHandle()

+ +
+
+ + + + + +
+ + + + + + + +
WindowHandle sf::WindowBase::getSystemHandle () const
+ 		+inherited
+
+ +

Get the OS-specific handle of the window.

+

The type of the returned handle is sf::WindowHandle, which is a typedef to the handle type defined by the OS. You shouldn't need to use this function, unless you have very specific stuff to implement that SFML doesn't support, or implement a temporary workaround until a bug is fixed.

+
Returns
System handle of the window
+ +
+
+ +

◆ hasFocus()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::WindowBase::hasFocus () const
+ 		+inherited
+
+ +

Check whether the window has the input focus.

+

At any given time, only one window may have the input focus to receive input events such as keystrokes or most mouse events.

+
Returns
True if window has focus, false otherwise
+
See also
requestFocus
+ +
+
+ +

◆ isOpen()

+ +
+
+ + + + + +
+ + + + + + + +
bool sf::WindowBase::isOpen () const
+ 		+inherited
+
+ +

Tell whether or not the window is open.

+

This function returns whether or not the window exists. Note that a hidden window (setVisible(false)) is open (therefore this function would return true).

+
Returns
True if the window is open, false if it has been closed
+ +
+
+ +

◆ onCreate()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::WindowBase::onCreate ()
+ 		+protectedvirtualinherited
+
+ +

Function called after the window has been created.

+

This function is called so that derived classes can perform their own specific initialization as soon as the window is created.

+ +

Reimplemented in sf::RenderWindow.

+ +
+
+ +

◆ onResize()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::WindowBase::onResize ()
+ 		+protectedvirtualinherited
+
+ +

Function called after the window has been resized.

+

This function is called so that derived classes can perform custom actions when the size of the window changes.

+ +

Reimplemented in sf::RenderWindow.

+ +
+
+ +

◆ pollEvent()

+ +
+
+ + + + + +
+ + + + + + + + +
bool sf::WindowBase::pollEvent (Event & event)
+ 		+inherited
+
+ +

Pop the event on top of the event queue, if any, and return it.

+

This function is not blocking: if there's no pending event then it will return false and leave event unmodified. Note that more than one event may be present in the event queue, thus you should always call this function in a loop to make sure that you process every pending event.

sf::Event event;
+
while (window.pollEvent(event))
+
{
+
// process event...
+
}
+
Parameters
+ + +
eventEvent to be returned
+
+
+
Returns
True if an event was returned, or false if the event queue was empty
+
See also
waitEvent
+ +
+
+ +

◆ requestFocus()

+ +
+
+ + + + + +
+ + + + + + + +
void sf::WindowBase::requestFocus ()
+ 		+inherited
+
+ +

Request the current window to be made the active foreground window.

+

At any given time, only one window may have the input focus to receive input events such as keystrokes or mouse events. If a window requests focus, it only hints to the operating system, that it would like to be focused. The operating system is free to deny the request. This is not to be confused with setActive().

+
See also
hasFocus
+ +
+
+ +

◆ setActive()

+ +
+
+ + + + + + + + +
bool sf::Window::setActive (bool active = true) const
+
+ +

Activate or deactivate the window as the current target for OpenGL rendering.

+

A window is active only on the current thread, if you want to make it active on another thread you have to deactivate it on the previous thread first if it was active. Only one window can be active on a thread at a time, thus the window previously active (if any) automatically gets deactivated. This is not to be confused with requestFocus().

+
Parameters
+ + +
activeTrue to activate, false to deactivate
+
+
+
Returns
True if operation was successful, false otherwise
+ +
+
+ +

◆ setFramerateLimit()

+ +
+
+ + + + + + + + +
void sf::Window::setFramerateLimit (unsigned int limit)
+
+ +

Limit the framerate to a maximum fixed frequency.

+

If a limit is set, the window will use a small delay after each call to display() to ensure that the current frame lasted long enough to match the framerate limit. SFML will try to match the given limit as much as it can, but since it internally uses sf::sleep, whose precision depends on the underlying OS, the results may be a little unprecise as well (for example, you can get 65 FPS when requesting 60).

+
Parameters
+ + +
limitFramerate limit, in frames per seconds (use 0 to disable limit)
+
+
+ +
+
+ +

◆ setIcon()

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::WindowBase::setIcon (unsigned int width,
unsigned int height,
const Uint8 * pixels 
)
+ 		+inherited
+
+ +

Change the window's icon.

+

pixels must be an array of width x height pixels in 32-bits RGBA format.

+

The OS default icon is used by default.

+
Parameters
+ + + + +
widthIcon's width, in pixels
heightIcon's height, in pixels
pixelsPointer to the array of pixels in memory. The pixels are copied, so you need not keep the source alive after calling this function.
+
+
+
See also
setTitle
+ +
+
+ +

◆ setJoystickThreshold()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setJoystickThreshold (float threshold)
+ 		+inherited
+
+ +

Change the joystick threshold.

+

The joystick threshold is the value below which no JoystickMoved event will be generated.

+

The threshold value is 0.1 by default.

+
Parameters
+ + +
thresholdNew threshold, in the range [0, 100]
+
+
+ +
+
+ +

◆ setKeyRepeatEnabled()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setKeyRepeatEnabled (bool enabled)
+ 		+inherited
+
+ +

Enable or disable automatic key-repeat.

+

If key repeat is enabled, you will receive repeated KeyPressed events while keeping a key pressed. If it is disabled, you will only get a single event when the key is pressed.

+

Key repeat is enabled by default.

+
Parameters
+ + +
enabledTrue to enable, false to disable
+
+
+ +
+
+ +

◆ setMouseCursor()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setMouseCursor (const Cursor & cursor)
+ 		+inherited
+
+ +

Set the displayed cursor to a native system cursor.

+

Upon window creation, the arrow cursor is used by default.

+
Warning
The cursor must not be destroyed while in use by the window.
+
+Features related to Cursor are not supported on iOS and Android.
+
Parameters
+ + +
cursorNative system cursor type to display
+
+
+
See also
sf::Cursor::loadFromSystem
+
+sf::Cursor::loadFromPixels
+ +
+
+ +

◆ setMouseCursorGrabbed()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setMouseCursorGrabbed (bool grabbed)
+ 		+inherited
+
+ +

Grab or release the mouse cursor.

+

If set, grabs the mouse cursor inside this window's client area so it may no longer be moved outside its bounds. Note that grabbing is only active while the window has focus.

+
Parameters
+ + +
grabbedTrue to enable, false to disable
+
+
+ +
+
+ +

◆ setMouseCursorVisible()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setMouseCursorVisible (bool visible)
+ 		+inherited
+
+ +

Show or hide the mouse cursor.

+

The mouse cursor is visible by default.

+
Parameters
+ + +
visibleTrue to show the mouse cursor, false to hide it
+
+
+ +
+
+ +

◆ setPosition()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setPosition (const Vector2i & position)
+ 		+inherited
+
+ +

Change the position of the window on screen.

+

This function only works for top-level windows (i.e. it will be ignored for windows created from the handle of a child window/control).

+
Parameters
+ + +
positionNew position, in pixels
+
+
+
See also
getPosition
+ +
+
+ +

◆ setSize()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setSize (const Vector2u & size)
+ 		+inherited
+
+ +

Change the size of the rendering region of the window.

+
Parameters
+ + +
sizeNew size, in pixels
+
+
+
See also
getSize
+ +
+
+ +

◆ setTitle()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setTitle (const String & title)
+ 		+inherited
+
+ +

Change the title of the window.

+
Parameters
+ + +
titleNew title
+
+
+
See also
setIcon
+ +
+
+ +

◆ setVerticalSyncEnabled()

+ +
+
+ + + + + + + + +
void sf::Window::setVerticalSyncEnabled (bool enabled)
+
+ +

Enable or disable vertical synchronization.

+

Activating vertical synchronization will limit the number of frames displayed to the refresh rate of the monitor. This can avoid some visual artifacts, and limit the framerate to a good value (but not constant across different computers).

+

Vertical synchronization is disabled by default.

+
Parameters
+ + +
enabledTrue to enable v-sync, false to deactivate it
+
+
+ +
+
+ +

◆ setVisible()

+ +
+
+ + + + + +
+ + + + + + + + +
void sf::WindowBase::setVisible (bool visible)
+ 		+inherited
+
+ +

Show or hide the window.

+

The window is shown by default.

+
Parameters
+ + +
visibleTrue to show the window, false to hide it
+
+
+ +
+
+ +

◆ waitEvent()

+ +
+
+ + + + + +
+ + + + + + + + +
bool sf::WindowBase::waitEvent (Event & event)
+ 		+inherited
+
+ +

Wait for an event and return it.

+

This function is blocking: if there's no pending event then it will wait until an event is received. After this function returns (and no error occurred), the event object is always valid and filled properly. This function is typically used when you have a thread that is dedicated to events handling: you want to make this thread sleep as long as no new event is received.

sf::Event event;
+
if (window.waitEvent(event))
+
{
+
// process event...
+
}
+
Parameters
+ + +
eventEvent to be returned
+
+
+
Returns
False if any error occurred
+
See also
pollEvent
+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1Window.png b/Space-Invaders/sfml/doc/html/classsf_1_1Window.png new file mode 100644 index 000000000..cc890dace Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1Window.png differ diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1WindowBase-members.html b/Space-Invaders/sfml/doc/html/classsf_1_1WindowBase-members.html new file mode 100644 index 000000000..932183af0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1WindowBase-members.html @@ -0,0 +1,137 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
sf::WindowBase Member List
+
+
+ +

This is the complete list of members for sf::WindowBase, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
close()sf::WindowBasevirtual
create(VideoMode mode, const String &title, Uint32 style=Style::Default)sf::WindowBasevirtual
create(WindowHandle handle)sf::WindowBasevirtual
createVulkanSurface(const VkInstance &instance, VkSurfaceKHR &surface, const VkAllocationCallbacks *allocator=0)sf::WindowBase
getPosition() constsf::WindowBase
getSize() constsf::WindowBase
getSystemHandle() constsf::WindowBase
hasFocus() constsf::WindowBase
isOpen() constsf::WindowBase
onCreate()sf::WindowBaseprotectedvirtual
onResize()sf::WindowBaseprotectedvirtual
pollEvent(Event &event)sf::WindowBase
requestFocus()sf::WindowBase
setIcon(unsigned int width, unsigned int height, const Uint8 *pixels)sf::WindowBase
setJoystickThreshold(float threshold)sf::WindowBase
setKeyRepeatEnabled(bool enabled)sf::WindowBase
setMouseCursor(const Cursor &cursor)sf::WindowBase
setMouseCursorGrabbed(bool grabbed)sf::WindowBase
setMouseCursorVisible(bool visible)sf::WindowBase
setPosition(const Vector2i &position)sf::WindowBase
setSize(const Vector2u &size)sf::WindowBase
setTitle(const String &title)sf::WindowBase
setVisible(bool visible)sf::WindowBase
waitEvent(Event &event)sf::WindowBase
Window (defined in sf::WindowBase)sf::WindowBasefriend
WindowBase()sf::WindowBase
WindowBase(VideoMode mode, const String &title, Uint32 style=Style::Default)sf::WindowBase
WindowBase(WindowHandle handle)sf::WindowBaseexplicit
~WindowBase()sf::WindowBasevirtual
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1WindowBase.html b/Space-Invaders/sfml/doc/html/classsf_1_1WindowBase.html new file mode 100644 index 000000000..d6d824c8a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/classsf_1_1WindowBase.html @@ -0,0 +1,1127 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Public Member Functions | +Protected Member Functions | +Friends | +List of all members
+
sf::WindowBase Class Reference
Window module
+
+
+ +

Window that serves as a base for other windows. + More...

+ +

#include <SFML/Window/WindowBase.hpp>

+
+Inheritance diagram for sf::WindowBase:
+
+
+ + +sf::NonCopyable +sf::Window +sf::RenderWindow + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 WindowBase ()
 Default constructor.
 
 WindowBase (VideoMode mode, const String &title, Uint32 style=Style::Default)
 Construct a new window.
 
 WindowBase (WindowHandle handle)
 Construct the window from an existing control.
 
virtual ~WindowBase ()
 Destructor.
 
virtual void create (VideoMode mode, const String &title, Uint32 style=Style::Default)
 Create (or recreate) the window.
 
virtual void create (WindowHandle handle)
 Create (or recreate) the window from an existing control.
 
virtual void close ()
 Close the window and destroy all the attached resources.
 
bool isOpen () const
 Tell whether or not the window is open.
 
bool pollEvent (Event &event)
 Pop the event on top of the event queue, if any, and return it.
 
bool waitEvent (Event &event)
 Wait for an event and return it.
 
Vector2i getPosition () const
 Get the position of the window.
 
void setPosition (const Vector2i &position)
 Change the position of the window on screen.
 
Vector2u getSize () const
 Get the size of the rendering region of the window.
 
void setSize (const Vector2u &size)
 Change the size of the rendering region of the window.
 
void setTitle (const String &title)
 Change the title of the window.
 
void setIcon (unsigned int width, unsigned int height, const Uint8 *pixels)
 Change the window's icon.
 
void setVisible (bool visible)
 Show or hide the window.
 
void setMouseCursorVisible (bool visible)
 Show or hide the mouse cursor.
 
void setMouseCursorGrabbed (bool grabbed)
 Grab or release the mouse cursor.
 
void setMouseCursor (const Cursor &cursor)
 Set the displayed cursor to a native system cursor.
 
void setKeyRepeatEnabled (bool enabled)
 Enable or disable automatic key-repeat.
 
void setJoystickThreshold (float threshold)
 Change the joystick threshold.
 
void requestFocus ()
 Request the current window to be made the active foreground window.
 
bool hasFocus () const
 Check whether the window has the input focus.
 
WindowHandle getSystemHandle () const
 Get the OS-specific handle of the window.
 
bool createVulkanSurface (const VkInstance &instance, VkSurfaceKHR &surface, const VkAllocationCallbacks *allocator=0)
 Create a Vulkan rendering surface.
 
+ + + + + + + +

+Protected Member Functions

virtual void onCreate ()
 Function called after the window has been created.
 
virtual void onResize ()
 Function called after the window has been resized.
 
+ + + +

+Friends

class Window
 
+

Detailed Description

+

Window that serves as a base for other windows.

+

sf::WindowBase serves as the base class for all Windows.

+

A sf::WindowBase can create its own new window, or be embedded into an already existing control using the create(handle) function.

+

The sf::WindowBase class provides a simple interface for manipulating the window: move, resize, show/hide, control mouse cursor, etc. It also provides event handling through its pollEvent() and waitEvent() functions.

+

Usage example:

// Declare and create a new window
+
sf::WindowBase window(sf::VideoMode(800, 600), "SFML window");
+
+
// The main loop - ends as soon as the window is closed
+
while (window.isOpen())
+
{
+
// Event processing
+
sf::Event event;
+
while (window.pollEvent(event))
+
{
+
// Request for closing the window
+
if (event.type == sf::Event::Closed)
+
window.close();
+
}
+
+
// Do things with the window here...
+
}
+
sf::Event
Defines a system event and its parameters.
Definition: Event.hpp:45
+
sf::Event::type
EventType type
Type of the event.
Definition: Event.hpp:220
+
sf::Event::Closed
@ Closed
The window requested to be closed (no data)
Definition: Event.hpp:190
+
sf::VideoMode
VideoMode defines a video mode (width, height, bpp)
Definition: VideoMode.hpp:42
+
sf::WindowBase
Window that serves as a base for other windows.
Definition: WindowBase.hpp:57
+
+

Definition at line 56 of file WindowBase.hpp.

+

Constructor & Destructor Documentation

+ +

◆ WindowBase() [1/3]

+ +
+
+ + + + + + + +
sf::WindowBase::WindowBase ()
+
+ +

Default constructor.

+

This constructor doesn't actually create the window, use the other constructors or call create() to do so.

+ +
+
+ +

◆ WindowBase() [2/3]

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
sf::WindowBase::WindowBase (VideoMode mode,
const String & title,
Uint32 style = Style::Default 
)
+
+ +

Construct a new window.

+

This constructor creates the window with the size and pixel depth defined in mode. An optional style can be passed to customize the look and behavior of the window (borders, title bar, resizable, closable, ...). If style contains Style::Fullscreen, then mode must be a valid video mode.

+
Parameters
+ + + + +
modeVideo mode to use (defines the width, height and depth of the rendering area of the window)
titleTitle of the window
styleWindow style, a bitwise OR combination of sf::Style enumerators
+
+
+ +
+
+ +

◆ WindowBase() [3/3]

+ +
+
+ + + + + +
+ + + + + + + + +
sf::WindowBase::WindowBase (WindowHandle handle)
+ 		+explicit
+
+ +

Construct the window from an existing control.

+
Parameters
+ + +
handlePlatform-specific handle of the control
+
+
+ +
+
+ +

◆ ~WindowBase()

+ +
+
+ + + + + +
+ + + + + + + +
virtual sf::WindowBase::~WindowBase ()
+ 		+virtual
+
+ +

Destructor.

+

Closes the window and frees all the resources attached to it.

+ +
+
+

Member Function Documentation

+ +

◆ close()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::WindowBase::close ()
+ 		+virtual
+
+ +

Close the window and destroy all the attached resources.

+

After calling this function, the sf::Window instance remains valid and you can call create() to recreate the window. All other functions such as pollEvent() or display() will still work (i.e. you don't have to test isOpen() every time), and will have no effect on closed windows.

+ +

Reimplemented in sf::Window.

+ +
+
+ +

◆ create() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
virtual void sf::WindowBase::create (VideoMode mode,
const String & title,
Uint32 style = Style::Default 
)
+ 		+virtual
+
+ +

Create (or recreate) the window.

+

If the window was already created, it closes it first. If style contains Style::Fullscreen, then mode must be a valid video mode.

+
Parameters
+ + + + +
modeVideo mode to use (defines the width, height and depth of the rendering area of the window)
titleTitle of the window
styleWindow style, a bitwise OR combination of sf::Style enumerators
+
+
+ +

Reimplemented in sf::Window.

+ +
+
+ +

◆ create() [2/2]

+ +
+
+ + + + + +
+ + + + + + + + +
virtual void sf::WindowBase::create (WindowHandle handle)
+ 		+virtual
+
+ +

Create (or recreate) the window from an existing control.

+
Parameters
+ + +
handlePlatform-specific handle of the control
+
+
+ +

Reimplemented in sf::Window.

+ +
+
+ +

◆ createVulkanSurface()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool sf::WindowBase::createVulkanSurface (const VkInstance & instance,
VkSurfaceKHR & surface,
const VkAllocationCallbacks * allocator = 0 
)
+
+ +

Create a Vulkan rendering surface.

+
Parameters
+ + + + +
instanceVulkan instance
surfaceCreated surface
allocatorAllocator to use
+
+
+
Returns
True if surface creation was successful, false otherwise
+ +
+
+ +

◆ getPosition()

+ +
+
+ + + + + + + +
Vector2i sf::WindowBase::getPosition () const
+
+ +

Get the position of the window.

+
Returns
Position of the window, in pixels
+
See also
setPosition
+ +
+
+ +

◆ getSize()

+ +
+
+ + + + + + + +
Vector2u sf::WindowBase::getSize () const
+
+ +

Get the size of the rendering region of the window.

+

The size doesn't include the titlebar and borders of the window.

+
Returns
Size in pixels
+
See also
setSize
+ +
+
+ +

◆ getSystemHandle()

+ +
+
+ + + + + + + +
WindowHandle sf::WindowBase::getSystemHandle () const
+
+ +

Get the OS-specific handle of the window.

+

The type of the returned handle is sf::WindowHandle, which is a typedef to the handle type defined by the OS. You shouldn't need to use this function, unless you have very specific stuff to implement that SFML doesn't support, or implement a temporary workaround until a bug is fixed.

+
Returns
System handle of the window
+ +
+
+ +

◆ hasFocus()

+ +
+
+ + + + + + + +
bool sf::WindowBase::hasFocus () const
+
+ +

Check whether the window has the input focus.

+

At any given time, only one window may have the input focus to receive input events such as keystrokes or most mouse events.

+
Returns
True if window has focus, false otherwise
+
See also
requestFocus
+ +
+
+ +

◆ isOpen()

+ +
+
+ + + + + + + +
bool sf::WindowBase::isOpen () const
+
+ +

Tell whether or not the window is open.

+

This function returns whether or not the window exists. Note that a hidden window (setVisible(false)) is open (therefore this function would return true).

+
Returns
True if the window is open, false if it has been closed
+ +
+
+ +

◆ onCreate()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::WindowBase::onCreate ()
+ 		+protectedvirtual
+
+ +

Function called after the window has been created.

+

This function is called so that derived classes can perform their own specific initialization as soon as the window is created.

+ +

Reimplemented in sf::RenderWindow.

+ +
+
+ +

◆ onResize()

+ +
+
+ + + + + +
+ + + + + + + +
virtual void sf::WindowBase::onResize ()
+ 		+protectedvirtual
+
+ +

Function called after the window has been resized.

+

This function is called so that derived classes can perform custom actions when the size of the window changes.

+ +

Reimplemented in sf::RenderWindow.

+ +
+
+ +

◆ pollEvent()

+ +
+
+ + + + + + + + +
bool sf::WindowBase::pollEvent (Event & event)
+
+ +

Pop the event on top of the event queue, if any, and return it.

+

This function is not blocking: if there's no pending event then it will return false and leave event unmodified. Note that more than one event may be present in the event queue, thus you should always call this function in a loop to make sure that you process every pending event.

sf::Event event;
+
while (window.pollEvent(event))
+
{
+
// process event...
+
}
+
Parameters
+ + +
eventEvent to be returned
+
+
+
Returns
True if an event was returned, or false if the event queue was empty
+
See also
waitEvent
+ +
+
+ +

◆ requestFocus()

+ +
+
+ + + + + + + +
void sf::WindowBase::requestFocus ()
+
+ +

Request the current window to be made the active foreground window.

+

At any given time, only one window may have the input focus to receive input events such as keystrokes or mouse events. If a window requests focus, it only hints to the operating system, that it would like to be focused. The operating system is free to deny the request. This is not to be confused with setActive().

+
See also
hasFocus
+ +
+
+ +

◆ setIcon()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void sf::WindowBase::setIcon (unsigned int width,
unsigned int height,
const Uint8 * pixels 
)
+
+ +

Change the window's icon.

+

pixels must be an array of width x height pixels in 32-bits RGBA format.

+

The OS default icon is used by default.

+
Parameters
+ + + + +
widthIcon's width, in pixels
heightIcon's height, in pixels
pixelsPointer to the array of pixels in memory. The pixels are copied, so you need not keep the source alive after calling this function.
+
+
+
See also
setTitle
+ +
+
+ +

◆ setJoystickThreshold()

+ +
+
+ + + + + + + + +
void sf::WindowBase::setJoystickThreshold (float threshold)
+
+ +

Change the joystick threshold.

+

The joystick threshold is the value below which no JoystickMoved event will be generated.

+

The threshold value is 0.1 by default.

+
Parameters
+ + +
thresholdNew threshold, in the range [0, 100]
+
+
+ +
+
+ +

◆ setKeyRepeatEnabled()

+ +
+
+ + + + + + + + +
void sf::WindowBase::setKeyRepeatEnabled (bool enabled)
+
+ +

Enable or disable automatic key-repeat.

+

If key repeat is enabled, you will receive repeated KeyPressed events while keeping a key pressed. If it is disabled, you will only get a single event when the key is pressed.

+

Key repeat is enabled by default.

+
Parameters
+ + +
enabledTrue to enable, false to disable
+
+
+ +
+
+ +

◆ setMouseCursor()

+ +
+
+ + + + + + + + +
void sf::WindowBase::setMouseCursor (const Cursor & cursor)
+
+ +

Set the displayed cursor to a native system cursor.

+

Upon window creation, the arrow cursor is used by default.

+
Warning
The cursor must not be destroyed while in use by the window.
+
+Features related to Cursor are not supported on iOS and Android.
+
Parameters
+ + +
cursorNative system cursor type to display
+
+
+
See also
sf::Cursor::loadFromSystem
+
+sf::Cursor::loadFromPixels
+ +
+
+ +

◆ setMouseCursorGrabbed()

+ +
+
+ + + + + + + + +
void sf::WindowBase::setMouseCursorGrabbed (bool grabbed)
+
+ +

Grab or release the mouse cursor.

+

If set, grabs the mouse cursor inside this window's client area so it may no longer be moved outside its bounds. Note that grabbing is only active while the window has focus.

+
Parameters
+ + +
grabbedTrue to enable, false to disable
+
+
+ +
+
+ +

◆ setMouseCursorVisible()

+ +
+
+ + + + + + + + +
void sf::WindowBase::setMouseCursorVisible (bool visible)
+
+ +

Show or hide the mouse cursor.

+

The mouse cursor is visible by default.

+
Parameters
+ + +
visibleTrue to show the mouse cursor, false to hide it
+
+
+ +
+
+ +

◆ setPosition()

+ +
+
+ + + + + + + + +
void sf::WindowBase::setPosition (const Vector2i & position)
+
+ +

Change the position of the window on screen.

+

This function only works for top-level windows (i.e. it will be ignored for windows created from the handle of a child window/control).

+
Parameters
+ + +
positionNew position, in pixels
+
+
+
See also
getPosition
+ +
+
+ +

◆ setSize()

+ +
+
+ + + + + + + + +
void sf::WindowBase::setSize (const Vector2u & size)
+
+ +

Change the size of the rendering region of the window.

+
Parameters
+ + +
sizeNew size, in pixels
+
+
+
See also
getSize
+ +
+
+ +

◆ setTitle()

+ +
+
+ + + + + + + + +
void sf::WindowBase::setTitle (const String & title)
+
+ +

Change the title of the window.

+
Parameters
+ + +
titleNew title
+
+
+
See also
setIcon
+ +
+
+ +

◆ setVisible()

+ +
+
+ + + + + + + + +
void sf::WindowBase::setVisible (bool visible)
+
+ +

Show or hide the window.

+

The window is shown by default.

+
Parameters
+ + +
visibleTrue to show the window, false to hide it
+
+
+ +
+
+ +

◆ waitEvent()

+ +
+
+ + + + + + + + +
bool sf::WindowBase::waitEvent (Event & event)
+
+ +

Wait for an event and return it.

+

This function is blocking: if there's no pending event then it will wait until an event is received. After this function returns (and no error occurred), the event object is always valid and filled properly. This function is typically used when you have a thread that is dedicated to events handling: you want to make this thread sleep as long as no new event is received.

sf::Event event;
+
if (window.waitEvent(event))
+
{
+
// process event...
+
}
+
Parameters
+ + +
eventEvent to be returned
+
+
+
Returns
False if any error occurred
+
See also
pollEvent
+ +
+
+

Friends And Related Function Documentation

+ +

◆ Window

+ +
+
+ + + + + +
+ + + + +
friend class Window
+ 		+friend
+
+ +

Definition at line 432 of file WindowBase.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/classsf_1_1WindowBase.png b/Space-Invaders/sfml/doc/html/classsf_1_1WindowBase.png new file mode 100644 index 000000000..817a5385c Binary files /dev/null and b/Space-Invaders/sfml/doc/html/classsf_1_1WindowBase.png differ diff --git a/Space-Invaders/sfml/doc/html/closed.png b/Space-Invaders/sfml/doc/html/closed.png new file mode 100644 index 000000000..98cc2c909 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/closed.png differ diff --git a/Space-Invaders/sfml/doc/html/deprecated.html b/Space-Invaders/sfml/doc/html/deprecated.html new file mode 100644 index 000000000..92d9ba6e2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/deprecated.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+
Deprecated List
+
+
+
+
Class sf::Event::MouseWheelEvent
+
This event is deprecated and potentially inaccurate. Use MouseWheelScrollEvent instead.
+
Member sf::Keyboard::BackSlash
+
Use Backslash instead
+
Member sf::Keyboard::BackSpace
+
Use Backspace instead
+
Member sf::Keyboard::Dash
+
Use Hyphen instead
+
Member sf::Keyboard::Quote
+
Use Apostrophe instead
+
Member sf::Keyboard::Return
+
Use Enter instead
+
Member sf::Keyboard::SemiColon
+
Use Semicolon instead
+
Member sf::Keyboard::Tilde
+
Use Grave instead
+
Member sf::LinesStrip
+
Use LineStrip instead
+
Member sf::RenderTexture::create (unsigned int width, unsigned int height, bool depthBuffer)
+
Use create(unsigned int, unsigned int, const ContextSettings&) instead.
+
Member sf::RenderWindow::capture () const
+
Use a sf::Texture and its sf::Texture::update(const Window&) function and copy its contents into an sf::Image instead.
+
Member sf::Shader::setParameter (const std::string &name, float x)
+
Use setUniform(const std::string&, float) instead.
+
Member sf::Shader::setParameter (const std::string &name, float x, float y)
+
Use setUniform(const std::string&, const Glsl::Vec2&) instead.
+
Member sf::Shader::setParameter (const std::string &name, float x, float y, float z)
+
Use setUniform(const std::string&, const Glsl::Vec3&) instead.
+
Member sf::Shader::setParameter (const std::string &name, float x, float y, float z, float w)
+
Use setUniform(const std::string&, const Glsl::Vec4&) instead.
+
Member sf::Shader::setParameter (const std::string &name, const Vector2f &vector)
+
Use setUniform(const std::string&, const Glsl::Vec2&) instead.
+
Member sf::Shader::setParameter (const std::string &name, const Vector3f &vector)
+
Use setUniform(const std::string&, const Glsl::Vec3&) instead.
+
Member sf::Shader::setParameter (const std::string &name, const Color &color)
+
Use setUniform(const std::string&, const Glsl::Vec4&) instead.
+
Member sf::Shader::setParameter (const std::string &name, const Transform &transform)
+
Use setUniform(const std::string&, const Glsl::Mat4&) instead.
+
Member sf::Shader::setParameter (const std::string &name, const Texture &texture)
+
Use setUniform(const std::string&, const Texture&) instead.
+
Member sf::Shader::setParameter (const std::string &name, CurrentTextureType)
+
Use setUniform(const std::string&, CurrentTextureType) instead.
+
Member sf::Text::getColor () const
+
There is now fill and outline colors instead of a single global color. Use getFillColor() or getOutlineColor() instead.
+
Member sf::Text::setColor (const Color &color)
+
There is now fill and outline colors instead of a single global color. Use setFillColor() or setOutlineColor() instead.
+
Member sf::TrianglesFan
+
Use TriangleFan instead
+
Member sf::TrianglesStrip
+
Use TriangleStrip instead
+
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/dir_5cf786e58cbf7297a26339ae6e44357c.html b/Space-Invaders/sfml/doc/html/dir_5cf786e58cbf7297a26339ae6e44357c.html new file mode 100644 index 000000000..bcbf85a06 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/dir_5cf786e58cbf7297a26339ae6e44357c.html @@ -0,0 +1,143 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Window Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Files

file  Clipboard.hpp [code]
 
file  Context.hpp [code]
 
file  ContextSettings.hpp [code]
 
file  Cursor.hpp [code]
 
file  Event.hpp [code]
 
file  Window/Export.hpp [code]
 
file  GlResource.hpp [code]
 
file  Joystick.hpp [code]
 
file  Keyboard.hpp [code]
 
file  Mouse.hpp [code]
 
file  Sensor.hpp [code]
 
file  Touch.hpp [code]
 
file  VideoMode.hpp [code]
 
file  Vulkan.hpp [code]
 
file  Window/Window.hpp [code]
 
file  WindowBase.hpp [code]
 
file  WindowHandle.hpp [code]
 
file  WindowStyle.hpp [code]
 
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/dir_83d50c0b1f1eceb6f182949162e90861.html b/Space-Invaders/sfml/doc/html/dir_83d50c0b1f1eceb6f182949162e90861.html new file mode 100644 index 000000000..76433e9dd --- /dev/null +++ b/Space-Invaders/sfml/doc/html/dir_83d50c0b1f1eceb6f182949162e90861.html @@ -0,0 +1,145 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
System Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Files

file  Clock.hpp [code]
 
file  Err.hpp [code]
 
file  System/Export.hpp [code]
 
file  FileInputStream.hpp [code]
 
file  InputStream.hpp [code]
 
file  Lock.hpp [code]
 
file  MemoryInputStream.hpp [code]
 
file  Mutex.hpp [code]
 
file  NativeActivity.hpp [code]
 
file  NonCopyable.hpp [code]
 
file  Sleep.hpp [code]
 
file  String.hpp [code]
 
file  Thread.hpp [code]
 
file  ThreadLocal.hpp [code]
 
file  ThreadLocalPtr.hpp [code]
 
file  Time.hpp [code]
 
file  Utf.hpp [code]
 
file  Vector2.hpp [code]
 
file  Vector3.hpp [code]
 
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/dir_89e9fb32471ae291b179a889144513db.html b/Space-Invaders/sfml/doc/html/dir_89e9fb32471ae291b179a889144513db.html new file mode 100644 index 000000000..ba664ac17 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/dir_89e9fb32471ae291b179a889144513db.html @@ -0,0 +1,129 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Network Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Files

file  Network/Export.hpp [code]
 
file  Ftp.hpp [code]
 
file  Http.hpp [code]
 
file  IpAddress.hpp [code]
 
file  Packet.hpp [code]
 
file  Socket.hpp [code]
 
file  SocketHandle.hpp [code]
 
file  SocketSelector.hpp [code]
 
file  TcpListener.hpp [code]
 
file  TcpSocket.hpp [code]
 
file  UdpSocket.hpp [code]
 
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/dir_c0a853e81d6f1c1f0a3eb7a27dc24256.html b/Space-Invaders/sfml/doc/html/dir_c0a853e81d6f1c1f0a3eb7a27dc24256.html new file mode 100644 index 000000000..1d50cae6f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/dir_c0a853e81d6f1c1f0a3eb7a27dc24256.html @@ -0,0 +1,139 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
SFML Directory Reference
+
+
+ + + + + + + + + + + + +

+Directories

directory  Audio
 
directory  Graphics
 
directory  Network
 
directory  System
 
directory  Window
 
+ + + + + + + + + + + + + + + + + + + + +

+Files

file  Audio.hpp [code]
 
file  Config.hpp [code]
 
file  GpuPreference.hpp [code]
 Headers.
 
file  Graphics.hpp [code]
 
file  Main.hpp [code]
 
file  Network.hpp [code]
 
file  OpenGL.hpp [code]
 
file  System.hpp [code]
 
file  Window.hpp [code]
 
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/dir_d44c64559bbebec7f509842c48db8b23.html b/Space-Invaders/sfml/doc/html/dir_d44c64559bbebec7f509842c48db8b23.html new file mode 100644 index 000000000..4aa143e63 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/dir_d44c64559bbebec7f509842c48db8b23.html @@ -0,0 +1,109 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
include Directory Reference
+
+
+ + + + +

+Directories

directory  SFML
 
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/dir_dd49ddb3ba8035e4a328f8c5f31cda7e.html b/Space-Invaders/sfml/doc/html/dir_dd49ddb3ba8035e4a328f8c5f31cda7e.html new file mode 100644 index 000000000..403c8128f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/dir_dd49ddb3ba8035e4a328f8c5f31cda7e.html @@ -0,0 +1,137 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Audio Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Files

file  AlResource.hpp [code]
 
file  Audio/Export.hpp [code]
 
file  InputSoundFile.hpp [code]
 
file  Listener.hpp [code]
 
file  Music.hpp [code]
 
file  OutputSoundFile.hpp [code]
 
file  Sound.hpp [code]
 
file  SoundBuffer.hpp [code]
 
file  SoundBufferRecorder.hpp [code]
 
file  SoundFileFactory.hpp [code]
 
file  SoundFileReader.hpp [code]
 
file  SoundFileWriter.hpp [code]
 
file  SoundRecorder.hpp [code]
 
file  SoundSource.hpp [code]
 
file  SoundStream.hpp [code]
 
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/dir_e68e8157741866f444e17edd764ebbae.html b/Space-Invaders/sfml/doc/html/dir_e68e8157741866f444e17edd764ebbae.html new file mode 100644 index 000000000..46183166b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/dir_e68e8157741866f444e17edd764ebbae.html @@ -0,0 +1,109 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
doc Directory Reference
+
+
+ + + + +

+Files

file  mainpage.hpp [code]
 
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/dir_e71ec51a9abd604c65f6abb639f6ea75.html b/Space-Invaders/sfml/doc/html/dir_e71ec51a9abd604c65f6abb639f6ea75.html new file mode 100644 index 000000000..e6639bd3d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/dir_e71ec51a9abd604c65f6abb639f6ea75.html @@ -0,0 +1,163 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
Graphics Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Files

file  BlendMode.hpp [code]
 
file  CircleShape.hpp [code]
 
file  Color.hpp [code]
 
file  ConvexShape.hpp [code]
 
file  Drawable.hpp [code]
 
file  Graphics/Export.hpp [code]
 
file  Font.hpp [code]
 
file  Glsl.hpp [code]
 
file  Glyph.hpp [code]
 
file  Image.hpp [code]
 
file  PrimitiveType.hpp [code]
 
file  Rect.hpp [code]
 
file  RectangleShape.hpp [code]
 
file  RenderStates.hpp [code]
 
file  RenderTarget.hpp [code]
 
file  RenderTexture.hpp [code]
 
file  RenderWindow.hpp [code]
 
file  Shader.hpp [code]
 
file  Shape.hpp [code]
 
file  Sprite.hpp [code]
 
file  Text.hpp [code]
 
file  Texture.hpp [code]
 
file  Transform.hpp [code]
 
file  Transformable.hpp [code]
 
file  Vertex.hpp [code]
 
file  VertexArray.hpp [code]
 
file  VertexBuffer.hpp [code]
 
file  View.hpp [code]
 
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/doc.png b/Space-Invaders/sfml/doc/html/doc.png new file mode 100644 index 000000000..17edabff9 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/doc.png differ diff --git a/Space-Invaders/sfml/doc/html/docd.png b/Space-Invaders/sfml/doc/html/docd.png new file mode 100644 index 000000000..d7c94fda9 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/docd.png differ diff --git a/Space-Invaders/sfml/doc/html/doxygen.css b/Space-Invaders/sfml/doc/html/doxygen.css new file mode 100644 index 000000000..632fbbaab --- /dev/null +++ b/Space-Invaders/sfml/doc/html/doxygen.css @@ -0,0 +1,1458 @@ +/* The standard CSS for doxygen */ + +/* @group Heading Levels */ + +div.contents .textblock h1 { + text-align: left; + font-size: 20pt; + font-weight: normal; + margin-top: 1.5em; + padding: 0 0 0.4em 0; + border-bottom: 1px solid #999; + border-top-width: 0; + border-left-width: 0; + border-right-width: 0; + background-color: transparent; +} + +h1.groupheader { + font-size: 150%; +} + +.title { + font-size: 20pt; + font-weight: normal; + margin: 10px 2px; +} + +dt { + font-weight: bold; +} + +div.multicol { + -moz-column-gap: 1em; + -webkit-column-gap: 1em; + -moz-column-count: 3; + -webkit-column-count: 3; +} + +p.startli, p.startdd, p.starttd { + margin-top: 2px; +} + +p.endli { + margin-bottom: 0px; +} + +p.enddd { + margin-bottom: 4px; +} + +p.endtd { + margin-bottom: 2px; +} + +/* @end */ + +caption { + font-weight: bold; +} + +span.legend { + font-size: 70%; + text-align: center; +} + +h3.version { + font-size: 90%; + text-align: center; +} + +div.qindex { + margin-bottom: 1em; +} + +div.qindex, div.navtab{ + background-color: #eee; + border: 1px solid #999; + text-align: center; +} + +div.qindex, div.navpath { + width: 100%; + line-height: 140%; +} + +div.navtab { + margin-right: 15px; +} + +/* @group Link Styling */ + +a.qindex { + font-weight: bold; +} + +a.qindexHL { + font-weight: bold; + background-color: #9CAFD4; + color: #ffffff; + border: 1px double #869DCA; +} + +/* @end */ + +dl.el { + margin-left: -1cm; +} + +a.el { + padding: 1px; + text-decoration: none; + color: #577E25; +} + +a.el:hover { + text-decoration: underline; +} + +pre.fragment { + /*border: 1px solid #C4CFE5; + background-color: #FBFCFD; + padding: 4px 6px; + margin: 4px 8px 4px 2px; + overflow: auto; + word-wrap: break-word; + font-size: 9pt; + line-height: 125%; + font-family: monospace, fixed; + font-size: 105%;*/ + font-family: Consolas, "Liberation Mono", Courier, monospace; + font-size: 10pt; + padding: 0.5em 1em; + background-color: #f5f5f5; + border: 1px solid #bbb; + border-radius(5px); +} + +div.fragment { + /*margin: 0 0 0 5px; + padding: 0.5em 1em; + font-family: Consolas, "Liberation Mono", Courier, monospace; + font-size: 10pt; + background-color: #eef7e3; + border-left: 3px solid #8DC841; + border-right: 0; + border-bottom: 0;*/ + + font-family: Consolas, "Liberation Mono", Courier, monospace; + font-size: 10pt; + padding: 0.5em 1em; + background-color: #f5f5f5; + border: 1px solid #bbb; + border-radius(5px); +} + +div.line { + min-height: 13px; + text-wrap: unrestricted; + white-space: -moz-pre-wrap; /* Moz */ + white-space: -pre-wrap; /* Opera 4-6 */ + white-space: -o-pre-wrap; /* Opera 7 */ + white-space: pre-wrap; /* CSS3 */ + word-wrap: break-word; /* IE 5.5+ */ + text-indent: -53px; + padding-left: 53px; + padding-bottom: 0px; + margin: 0px; + line-height: normal; +} + +span.lineno { + padding-right: 4px; + text-align: right; + background-color: #E8E8E8; + white-space: pre; +} + +div.ah { + width: 100%; + background-color: #eee; + font-weight: bold; + color: #000; + margin-bottom: 1px; + margin-top: 1px; + border: solid 1px #999; +} + +div.groupHeader { + margin-left: 16px; + margin-top: 12px; + font-weight: bold; +} + +div.groupText { + margin-left: 16px; + font-style: italic; +} + +body { + background-color: white; + color: black; + margin: 0; +} + +div.contents { + width: 950px; + margin: 0 auto; +} + +td.indexkey { + background-color: #EBEFF6; + font-weight: bold; + border: 1px solid #C4CFE5; + margin: 2px 0px 2px 0; + padding: 2px 10px; + white-space: nowrap; + vertical-align: top; +} + +td.indexvalue { + background-color: #EBEFF6; + border: 1px solid #C4CFE5; + padding: 2px 10px; + margin: 2px 0px; +} + +tr.memlist { + background-color: #EEF1F7; +} + +p.formulaDsp { + text-align: center; +} + +img.formulaDsp { + +} + +img.formulaInl { + vertical-align: middle; +} + +div.center { + text-align: center; + margin-top: 0px; + margin-bottom: 0px; + padding: 0px; +} + +div.center img { + border: 0px; +} + +address.footer { + text-align: right; + padding-right: 12px; +} + +img.footer { + border: 0px; + vertical-align: middle; +} + +/* @group Code Colorization */ + +span.keyword { + color: #008000 +} + +span.keywordtype { + color: #604020 +} + +span.keywordflow { + color: #e08000 +} + +span.comment { + color: #800000 +} + +span.preprocessor { + color: #806020 +} + +span.stringliteral { + color: #002080 +} + +span.charliteral { + color: #008080 +} + +span.vhdldigit { + color: #ff00ff +} + +span.vhdlchar { + color: #000000 +} + +span.vhdlkeyword { + color: #700070 +} + +span.vhdllogic { + color: #ff0000 +} + +blockquote { + background-color: #F7F8FB; + border-left: 2px solid #9CAFD4; + margin: 0 24px 0 4px; + padding: 0 12px 0 16px; +} + +/* @end */ + +td.tiny { + font-size: 75%; +} + +.dirtab { + padding: 4px; + border-collapse: collapse; + border: 1px solid #A3B4D7; +} + +th.dirtab { + background: #EBEFF6; + font-weight: bold; +} + +hr { + display: none; + height: 0px; + border: none; + border-top: 1px solid #4A6AAA; +} + +hr.footer { + height: 1px; +} + +/* @group Member Descriptions */ + +table.memberdecls { + border-spacing: 0px; + padding: 0px; +} + +.memberdecls td, .fieldtable tr { + -webkit-transition-property: background-color, box-shadow; + -webkit-transition-duration: 0.5s; + -moz-transition-property: background-color, box-shadow; + -moz-transition-duration: 0.5s; + -ms-transition-property: background-color, box-shadow; + -ms-transition-duration: 0.5s; + -o-transition-property: background-color, box-shadow; + -o-transition-duration: 0.5s; + transition-property: background-color, box-shadow; + transition-duration: 0.5s; +} + +.memberdecls td.glow, .fieldtable tr.glow { + background-color: cyan; + /*box-shadow: 0 0 15px cyan;*/ +} + +.mdescLeft, .mdescRight, +.memItemLeft, .memItemRight, +.memTemplItemLeft, .memTemplItemRight, .memTemplParams { + background-color: #F9FAFC; + border: none; + margin: 4px; + padding: 1px 0 0 8px; +} + +.mdescLeft, .mdescRight { + padding: 0px 8px 4px 8px; + color: #555; +} + +.memSeparator { + border-bottom: 1px solid #DEE4F0; + line-height: 1px; + margin: 0px; + padding: 0px; +} + +.memItemLeft, .memTemplItemLeft { + white-space: nowrap; +} + +.memItemRight { + width: 100%; +} + +.memTemplParams { + color: #4665A2; + white-space: nowrap; + font-size: 80%; +} + +/* @end */ + +/* @group Member Details */ + +/* Styles for detailed member documentation */ + +.memtemplate { + font-size: 80%; + color: #4665A2; + font-weight: normal; + margin-left: 9px; +} + +.memtitle { + display: none; +} + +.memnav { + background-color: #EBEFF6; + border: 1px solid #A3B4D7; + text-align: center; + margin: 2px; + margin-right: 15px; + padding: 2px; +} + +.mempage { + width: 100%; +} + +.memitem { + padding: 0; + /*margin-bottom: 10px;*/ + margin-right: 5px; + display: table !important; + width: 100%; +} + +.memname { + font-weight: bold; + margin-left: 6px; +} + +.memname td { + vertical-align: bottom; +} + +.memproto, dl.reflist dt { + border-top: 1px solid #A8B8D9; + border-left: 1px solid #A8B8D9; + border-right: 1px solid #A8B8D9; + padding: 6px 0px 6px 0px; + color: #000; + font-weight: bold; + text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); + background-color: #eee; + border-top-right-radius: 4px; + border-top-left-radius: 4px; + -moz-border-radius-topright: 4px; + -moz-border-radius-topleft: 4px; + -webkit-border-top-right-radius: 4px; + -webkit-border-top-left-radius: 4px; + +} + +.memdoc, dl.reflist dd { + border: 1px solid #A8B8D9; + padding: 6px 10px 2px 10px; + background-color: #FBFCFD; + background-color: #FFFFFF; + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; + -moz-border-radius-bottomleft: 4px; + -moz-border-radius-bottomright: 4px; + -webkit-border-bottom-left-radius: 4px; + -webkit-border-bottom-right-radius: 4px; +} + +dl.reflist dt { + padding: 5px; +} + +dl.reflist dd { + margin: 0px 0px 10px 0px; + padding: 5px; +} + +.paramkey { + text-align: right; +} + +.paramtype { + white-space: nowrap; +} + +.paramname { + color: #602020; + white-space: nowrap; +} +.paramname em { + font-style: normal; +} +.paramname code { + line-height: 14px; +} + +.params, .retval, .exception, .tparams { + margin-left: 0px; + padding-left: 0px; +} + +.params .paramname, .retval .paramname { + font-weight: bold; + vertical-align: top; +} + +.params .paramtype { + font-style: italic; + vertical-align: top; +} + +.params .paramdir { + font-family: "courier new",courier,monospace; + vertical-align: top; +} + +table.mlabels { + border-spacing: 0px; +} + +td.mlabels-left { + width: 100%; + padding: 0px; +} + +td.mlabels-right { + vertical-align: bottom; + padding: 0px; + white-space: nowrap; +} + +span.mlabels { + margin-left: 8px; +} + +span.mlabel { + background-color: #728DC1; + border-top:1px solid #5373B4; + border-left:1px solid #5373B4; + border-right:1px solid #C4CFE5; + border-bottom:1px solid #C4CFE5; + text-shadow: none; + color: white; + margin-right: 4px; + padding: 2px 3px; + border-radius: 3px; + font-size: 7pt; + white-space: nowrap; + vertical-align: middle; +} + + + +/* @end */ + +/* these are for tree view when not used as main index */ + +div.directory { + margin: 10px 0px; + border-top: 1px solid #bbb; + width: 100%; +} + +.directory table { + border-collapse:collapse; +} + +.directory td { + margin: 0px; + padding: 0px; + vertical-align: top; +} + +.directory td.entry { + white-space: nowrap; + padding: 5px 5px 5px 0; +} + +.directory td.entry a { + outline:none; +} + +.directory td.entry a img { + border: none; +} + +.directory td.desc { + width: 100%; + padding-left: 6px; + padding-right: 6px; + padding-top: 3px; + /*border-left: 1px solid rgba(0,0,0,0.05);*/ +} + +.directory tr.even { + padding-left: 6px; + background-color: #F7F8FB; +} + +.directory img { + vertical-align: -30%; +} + +.directory .levels { + white-space: nowrap; + width: 100%; + text-align: right; + font-size: 9pt; +} + +.directory .levels span { + cursor: pointer; + padding-left: 2px; + padding-right: 2px; + color: #3D578C; +} + +div.dynheader { + margin-top: 8px; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +address { + font-style: normal; + color: #2A3D61; +} + +table table { + width: 90%; +} + +.memitem table table { + width: auto; +} + +table.doxtable { + border-collapse:collapse; + margin-top: 4px; + margin-bottom: 4px; +} + +table.doxtable td, table.doxtable th { + border: 1px solid #2D4068; + padding: 3px 7px 2px; +} + +table.doxtable th { + background-color: #374F7F; + color: #FFFFFF; + font-size: 110%; + padding-bottom: 4px; + padding-top: 5px; +} + +table.fieldtable { + width: 100%; + margin-bottom: 10px; + border: 1px solid #A8B8D9; + border-spacing: 0px; + -moz-border-radius: 4px; + -webkit-border-radius: 4px; + border-radius: 4px; +} + +.fieldtable td, .fieldtable th { + padding: 3px 7px 2px; +} + +.fieldtable td.fieldtype, .fieldtable td.fieldname { + white-space: nowrap; + border-right: 1px solid #A8B8D9; + border-bottom: 1px solid #A8B8D9; + vertical-align: top; +} + +.fieldtable td.fielddoc { + border-bottom: 1px solid #A8B8D9; + width: 100%; +} + +.fieldtable tr:last-child td { + border-bottom: none; +} + +.fieldtable th { + background-color: #E2E8F2; + font-size: 90%; + color: #253555; + padding-bottom: 4px; + padding-top: 5px; + text-align:left; + -moz-border-radius-topleft: 4px; + -moz-border-radius-topright: 4px; + -webkit-border-top-left-radius: 4px; + -webkit-border-top-right-radius: 4px; + border-top-left-radius: 4px; + border-top-right-radius: 4px; + border-bottom: 1px solid #A8B8D9; +} + + +.tabsearch { + top: 0px; + left: 10px; + height: 36px; + z-index: 101; + overflow: hidden; + font-size: 13px; +} + +.navpath { + display: none; +} + +.navpath ul { + font-size: 11px; + height:30px; + line-height:30px; + color:#8AA0CC; + border:solid 1px #C2CDE4; + overflow:hidden; + margin:0px; + padding:0px; +} + +.navpath li { + list-style-type:none; + float:left; + padding-left:10px; + padding-right:15px; + color:#364D7C; +} + +.navpath li.navelem a { + height:32px; + display:block; + text-decoration: none; + outline: none; + color: #283A5D; + font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif; + text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); + text-decoration: none; +} + +.navpath li.navelem a:hover { + color:#6884BD; +} + +.navpath li.footer { + list-style-type:none; + float:right; + padding-left:10px; + padding-right:15px; + background-image:none; + background-repeat:no-repeat; + background-position:right; + color:#364D7C; + font-size: 8pt; +} + + +div.summary { + font-size: 8pt; + padding-right: 5px; +} + +div.summary a { + white-space: nowrap; + padding: 1px; + text-decoration: none; + color: #577E25; +} + +div.summary a:hover { + text-decoration: underline; +} + +div.ingroups { + font-size: 8pt; + width: 50%; + text-align: left; +} + +div.ingroups a { + white-space: nowrap; +} + +div.header { + width: 950px; + margin: 2em auto; + border-bottom: 1px solid #999; +} + +dl { + padding: 0 0 0 10px; +} + +/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug */ +dl.section { + margin-left: 0px; + padding-left: 0px; +} + +dl.note { + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #D0C000; +} + +dl.warning, dl.attention { + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #FF0000; +} + +dl.pre, dl.post, dl.invariant { + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #00D000; +} + +dl.deprecated { + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #505050; +} + +dl.todo { + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #00C0E0; +} + +dl.test { + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #3030E0; +} + +dl.bug { + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #C08050; +} + +dl.section dd { + margin-bottom: 6px; +} + + +#projectlogo { + text-align: center; + vertical-align: bottom; + border-collapse: separate; +} + +#projectlogo img { + border: 0px none; +} + +#projectname { + font: 300% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 2px 0px; +} + +#projectbrief { + font: 120% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 0px; +} + +#projectnumber { + font: 50% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 0px; +} + +#titlearea { + padding: 0px; + margin: 0px; + width: 100%; + border-bottom: 1px solid #5373B4; +} + +.image { + text-align: center; +} + +.dotgraph { + text-align: center; +} + +.mscgraph { + text-align: center; +} + +.caption { + font-weight: bold; +} + +div.zoom { + border: 1px solid #90A5CE; +} + +dl.citelist { + margin-bottom:50px; +} + +dl.citelist dt { + color:#334975; + float:left; + font-weight:bold; + margin-right:10px; + padding:5px; +} + +dl.citelist dd { + margin:2px 0; + padding:5px 0; +} + +div.toc { + padding: 14px 25px; + background-color: #F4F6FA; + border: 1px solid #D8DFEE; + border-radius: 7px 7px 7px 7px; + float: right; + height: auto; + margin: 0 20px 10px 10px; + width: 200px; +} + +div.toc li { + font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif; + margin-top: 5px; + padding-left: 10px; + padding-top: 2px; +} + +div.toc h3 { + font: bold 12px/1.2 Arial,FreeSans,sans-serif; + color: #4665A2; + border-bottom: 0 none; + margin: 0; +} + +div.toc ul { + list-style: none outside none; + border: medium none; + padding: 0px; +} + +div.toc li.level1 { + margin-left: 0px; +} + +div.toc li.level2 { + margin-left: 15px; +} + +div.toc li.level3 { + margin-left: 30px; +} + +div.toc li.level4 { + margin-left: 45px; +} + +.inherit_header { + font-weight: bold; + color: gray; + cursor: pointer; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +.inherit_header td { + padding: 6px 0px 2px 5px; +} + +.inherit { + display: none; +} + +tr.heading h2 { + margin-top: 12px; + margin-bottom: 4px; +} + +@media print { + #top { display: none; } + #side-nav { display: none; } + #nav-path { display: none; } + body { overflow:visible; } + h1, h2, h3, h4, h5, h6 { page-break-after: avoid; } + .summary { display: none; } + .memitem { page-break-inside: avoid; } + + #doc-content { + margin-left:0 !important; + height:auto !important; + width:auto !important; + overflow:inherit; + display:inline; + } +} + +/* tabs.css */ +.tabs, .tabs2, .tabs3 { + width: 100%; + z-index: 101; + font-size: 11pt; + background-color: #EAF5DB; + border-left: 1px solid #999; + border-right: 1px solid #999; + border-bottom: 1px solid #999; + padding: 0; + margin: 0; +} + +.tabs2 { + font-size: 10pt; +} +.tabs3 { + font-size: 9pt; +} + +#navrow1 .tablist, #navrow2 .tablist, #navrow3 .tablist, #navrow4 .tablist { + margin: 0; + padding: 0; + display: table; +} + +.tablist { + width: 100%; +} + +.tablist li { + float: left; + display: table-cell; + list-style: none; +} + +#navrow1 .tablist li:last-child { + float: right; +} + +#navrow1 { + border-top: 1px solid #999; + margin-top: 2em; +} + +#navrow1 .tablist a:not(#MSearchClose), #navrow2 .tablist a, #navrow3 .tablist a, #navrow4 .tablist a { + display: block; + margin: 8px 0; + padding: 0 8px; + border-right: 1px solid #bbb; +} + +.tablist li { + margin-bottom: 0 !important; +} + +.tablist li.current a { + font-weight: bold; +} + + + + + +/* SFML css */ +body { + font-family: 'Ubuntu', 'Arial', sans-serif; + line-height: 140%; + margin: 0 0 2em 0; + padding: 0; +} + +#banner-container { + width: 100%; + margin-top: 25px; + border-top: 2px solid #999; + border-bottom: 2px solid #999; + background-color: rgb(140, 200, 65); +} + +#banner { + width: 950px; + height: 60px; + line-height: 54px; + margin: 0 auto; + text-align: center; +} + +#banner #sfml { + display: inline; + vertical-align: top; + margin-left: 15px; + color: #fff; + font-size: 50pt; + text-shadow: rgba(0, 0, 0, 0.5) 1px 1px 5px; +} + +#footer-container { + clear: both; + width: 100%; + margin-top: 50px; + border-top: 1px solid #999; +} + +#footer { + width: 950px; + margin: 10px auto; + text-align: center; + font-size: 10pt; + color: #555; +} + +#footer a { + padding: 1px; + text-decoration: none; + color: rgb(70, 100, 30); +} + +#footer a:hover { + text-decoration: underline; +} + +div.contents, #content { + width: 950px; + margin: 0 auto; + padding: 0; +} + +div.contents h1 { + color: #333; + padding: 0.5em 0; + margin-top: 30px; + margin-bottom: 0; + text-align: center; + font-size: 26pt; + font-weight: normal; +} + +div.contents h2 { + font-size: 20pt; + font-weight: normal; + margin-top: 1.5em; + padding-bottom: 0.4em; + border-bottom: 1px solid #999; +} + +div.contents h3 { + font-size: 16pt; + font-weight: normal; +} + +div.contents p { + color: #333; + text-align: justify; +} + +div.contents a, #content a { + padding: 1px; + text-decoration: none; + color: rgb(70, 100, 30); +} + +div.contents a:hover, #content a:hover { + text-decoration: underline; +} + +div.contents code { + font-size: 11pt; + font-family: Consolas, "Liberation Mono", Courier, monospace; +} + +div.contents pre code { + font-family: Consolas, "Liberation Mono", Courier, monospace; + font-size: 10pt; + padding: 0.5em 1em; + background-color: #f5f5f5; + border: 1px solid #bbb; +} + +div.contents ul { + list-style-type: square; + list-style-position: outside; + margin: 0 0 0 1.5em; + padding: 0; +} + +div.contents ul li { + color: #333; + margin: 0 0 0.3em 0; +} + + +.icon { + font-family: Arial, Helvetica; + font-weight: bold; + font-size: 12px; + height: 14px; + width: 16px; + display: inline-block; + background-color: #8cc445; + color: white; + text-align: center; + border-radius: 4px; + margin-left: 2px; + margin-right: 2px; + line-height: normal; +} + +.icona { + width: 24px; + height: 22px; + display: inline-block; +} + +.iconfopen { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('folderopen.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +.iconfclosed { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('folderclosed.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +.icondoc { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('doc.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +/* tooltip related style info */ + +.ttc { + position: absolute; + display: none; +} + +#powerTip { + cursor: default; + white-space: nowrap; + background-color: white; + border: 1px solid gray; + border-radius: 4px 4px 4px 4px; + box-shadow: 1px 1px 7px gray; + display: none; + font-size: smaller; + max-width: 80%; + opacity: 0.9; + padding: 1ex 1em 1em; + position: absolute; + z-index: 2147483647; +} + +#powerTip div.ttdoc { + color: grey; + font-style: italic; +} + +#powerTip div.ttname a { + font-weight: bold; +} + +#powerTip div.ttname { + font-weight: bold; +} + +#powerTip div.ttdeci { + color: #006318; +} + +#powerTip div { + margin: 0px; + padding: 0px; + font: 12px/16px Roboto,sans-serif; +} + +#powerTip:before, #powerTip:after { + content: ""; + position: absolute; + margin: 0px; +} + +#powerTip.n:after, #powerTip.n:before, +#powerTip.s:after, #powerTip.s:before, +#powerTip.w:after, #powerTip.w:before, +#powerTip.e:after, #powerTip.e:before, +#powerTip.ne:after, #powerTip.ne:before, +#powerTip.se:after, #powerTip.se:before, +#powerTip.nw:after, #powerTip.nw:before, +#powerTip.sw:after, #powerTip.sw:before { + border: solid transparent; + content: " "; + height: 0; + width: 0; + position: absolute; +} + +#powerTip.n:after, #powerTip.s:after, +#powerTip.w:after, #powerTip.e:after, +#powerTip.nw:after, #powerTip.ne:after, +#powerTip.sw:after, #powerTip.se:after { + border-color: rgba(255, 255, 255, 0); +} + +#powerTip.n:before, #powerTip.s:before, +#powerTip.w:before, #powerTip.e:before, +#powerTip.nw:before, #powerTip.ne:before, +#powerTip.sw:before, #powerTip.se:before { + border-color: rgba(128, 128, 128, 0); +} + +#powerTip.n:after, #powerTip.n:before, +#powerTip.ne:after, #powerTip.ne:before, +#powerTip.nw:after, #powerTip.nw:before { + top: 100%; +} + +#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after { + border-top-color: #ffffff; + border-width: 10px; + margin: 0px -10px; +} +#powerTip.n:before { + border-top-color: #808080; + border-width: 11px; + margin: 0px -11px; +} +#powerTip.n:after, #powerTip.n:before { + left: 50%; +} + +#powerTip.nw:after, #powerTip.nw:before { + right: 14px; +} + +#powerTip.ne:after, #powerTip.ne:before { + left: 14px; +} + +#powerTip.s:after, #powerTip.s:before, +#powerTip.se:after, #powerTip.se:before, +#powerTip.sw:after, #powerTip.sw:before { + bottom: 100%; +} + +#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after { + border-bottom-color: #ffffff; + border-width: 10px; + margin: 0px -10px; +} + +#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before { + border-bottom-color: #808080; + border-width: 11px; + margin: 0px -11px; +} + +#powerTip.s:after, #powerTip.s:before { + left: 50%; +} + +#powerTip.sw:after, #powerTip.sw:before { + right: 14px; +} + +#powerTip.se:after, #powerTip.se:before { + left: 14px; +} + +#powerTip.e:after, #powerTip.e:before { + left: 100%; +} +#powerTip.e:after { + border-left-color: #ffffff; + border-width: 10px; + top: 50%; + margin-top: -10px; +} +#powerTip.e:before { + border-left-color: #808080; + border-width: 11px; + top: 50%; + margin-top: -11px; +} + +#powerTip.w:after, #powerTip.w:before { + right: 100%; +} +#powerTip.w:after { + border-right-color: #ffffff; + border-width: 10px; + top: 50%; + margin-top: -10px; +} +#powerTip.w:before { + border-right-color: #808080; + border-width: 11px; + top: 50%; + margin-top: -11px; +} +.arrow { + cursor: pointer; +} diff --git a/Space-Invaders/sfml/doc/html/doxygen.svg b/Space-Invaders/sfml/doc/html/doxygen.svg new file mode 100644 index 000000000..d42dad52d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/doxygen.svg @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Space-Invaders/sfml/doc/html/dynsections.js b/Space-Invaders/sfml/doc/html/dynsections.js new file mode 100644 index 000000000..1f4cd14a6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/dynsections.js @@ -0,0 +1,130 @@ +/* + @licstart The following is the entire license notice for the JavaScript code in this file. + + The MIT License (MIT) + + Copyright (C) 1997-2020 by Dimitri van Heesch + + Permission is hereby granted, free of charge, to any person obtaining a copy of this software + and associated documentation files (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, publish, distribute, + sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all copies or + substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + @licend The above is the entire license notice for the JavaScript code in this file + */ +function toggleVisibility(linkObj) +{ + var base = $(linkObj).attr('id'); + var summary = $('#'+base+'-summary'); + var content = $('#'+base+'-content'); + var trigger = $('#'+base+'-trigger'); + var src=$(trigger).attr('src'); + if (content.is(':visible')===true) { + content.hide(); + summary.show(); + $(linkObj).addClass('closed').removeClass('opened'); + $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png'); + } else { + content.show(); + summary.hide(); + $(linkObj).removeClass('closed').addClass('opened'); + $(trigger).attr('src',src.substring(0,src.length-10)+'open.png'); + } + return false; +} + +function updateStripes() +{ + $('table.directory tr'). + removeClass('even').filter(':visible:even').addClass('even'); + $('table.directory tr'). + removeClass('odd').filter(':visible:odd').addClass('odd'); +} + +function toggleLevel(level) +{ + $('table.directory tr').each(function() { + var l = this.id.split('_').length-1; + var i = $('#img'+this.id.substring(3)); + var a = $('#arr'+this.id.substring(3)); + if (l + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
File List
+
+
+
Here is a list of all documented files with brief descriptions:
+
[detail level 1234]
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ▼ doc
 mainpage.hpp
 ▼ include
 ▼ SFML
 ► Audio
 ► Graphics
 ► Network
 ► System
 ► Window
 Audio.hpp
 Config.hpp
 GpuPreference.hppHeaders
 Graphics.hpp
 Main.hpp
 Network.hpp
 OpenGL.hpp
 System.hpp
 Window.hpp
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/folderclosed.png b/Space-Invaders/sfml/doc/html/folderclosed.png new file mode 100644 index 000000000..bb8ab35ed Binary files /dev/null and b/Space-Invaders/sfml/doc/html/folderclosed.png differ diff --git a/Space-Invaders/sfml/doc/html/folderopen.png b/Space-Invaders/sfml/doc/html/folderopen.png new file mode 100644 index 000000000..d6c7f676a Binary files /dev/null and b/Space-Invaders/sfml/doc/html/folderopen.png differ diff --git a/Space-Invaders/sfml/doc/html/functions.html b/Space-Invaders/sfml/doc/html/functions.html new file mode 100644 index 000000000..2e4d0d467 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions.html @@ -0,0 +1,174 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- a -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_b.html b/Space-Invaders/sfml/doc/html/functions_b.html new file mode 100644 index 000000000..3afdd5724 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_b.html @@ -0,0 +1,169 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- b -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_c.html b/Space-Invaders/sfml/doc/html/functions_c.html new file mode 100644 index 000000000..66c1b3d08 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_c.html @@ -0,0 +1,196 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- c -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_d.html b/Space-Invaders/sfml/doc/html/functions_d.html new file mode 100644 index 000000000..4472e6ad9 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_d.html @@ -0,0 +1,174 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- d -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_e.html b/Space-Invaders/sfml/doc/html/functions_e.html new file mode 100644 index 000000000..f3f618b2a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_e.html @@ -0,0 +1,161 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- e -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_enum.html b/Space-Invaders/sfml/doc/html/functions_enum.html new file mode 100644 index 000000000..44c57cfc7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_enum.html @@ -0,0 +1,127 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval.html b/Space-Invaders/sfml/doc/html/functions_eval.html new file mode 100644 index 000000000..3ab27de60 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval.html @@ -0,0 +1,154 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- a -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_b.html b/Space-Invaders/sfml/doc/html/functions_eval_b.html new file mode 100644 index 000000000..2a4397b69 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_b.html @@ -0,0 +1,156 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- b -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_c.html b/Space-Invaders/sfml/doc/html/functions_eval_c.html new file mode 100644 index 000000000..36f24f8d1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_c.html @@ -0,0 +1,159 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- c -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_d.html b/Space-Invaders/sfml/doc/html/functions_eval_d.html new file mode 100644 index 000000000..f7426ded0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_d.html @@ -0,0 +1,160 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- d -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_e.html b/Space-Invaders/sfml/doc/html/functions_eval_e.html new file mode 100644 index 000000000..6fbcab09d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_e.html @@ -0,0 +1,152 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- e -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_f.html b/Space-Invaders/sfml/doc/html/functions_eval_f.html new file mode 100644 index 000000000..dca84aa65 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_f.html @@ -0,0 +1,177 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- f -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_g.html b/Space-Invaders/sfml/doc/html/functions_eval_g.html new file mode 100644 index 000000000..aadd6d99f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_g.html @@ -0,0 +1,151 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- g -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_h.html b/Space-Invaders/sfml/doc/html/functions_eval_h.html new file mode 100644 index 000000000..7d9db225a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_h.html @@ -0,0 +1,152 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- h -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_i.html b/Space-Invaders/sfml/doc/html/functions_eval_i.html new file mode 100644 index 000000000..00a1c636a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_i.html @@ -0,0 +1,150 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- i -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_j.html b/Space-Invaders/sfml/doc/html/functions_eval_j.html new file mode 100644 index 000000000..a9443277c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_j.html @@ -0,0 +1,149 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- j -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_k.html b/Space-Invaders/sfml/doc/html/functions_eval_k.html new file mode 100644 index 000000000..99b974962 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_k.html @@ -0,0 +1,147 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- k -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_l.html b/Space-Invaders/sfml/doc/html/functions_eval_l.html new file mode 100644 index 000000000..fc3e02a7e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_l.html @@ -0,0 +1,157 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- l -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_m.html b/Space-Invaders/sfml/doc/html/functions_eval_m.html new file mode 100644 index 000000000..4a03b0fe2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_m.html @@ -0,0 +1,166 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- m -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_n.html b/Space-Invaders/sfml/doc/html/functions_eval_n.html new file mode 100644 index 000000000..a07be67bc --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_n.html @@ -0,0 +1,187 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- n -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_o.html b/Space-Invaders/sfml/doc/html/functions_eval_o.html new file mode 100644 index 000000000..a9d917843 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_o.html @@ -0,0 +1,152 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- o -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_p.html b/Space-Invaders/sfml/doc/html/functions_eval_p.html new file mode 100644 index 000000000..3a4be5122 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_p.html @@ -0,0 +1,163 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- p -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_q.html b/Space-Invaders/sfml/doc/html/functions_eval_q.html new file mode 100644 index 000000000..b8e3c13d2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_q.html @@ -0,0 +1,145 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- q -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_r.html b/Space-Invaders/sfml/doc/html/functions_eval_r.html new file mode 100644 index 000000000..5c8ed4d17 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_r.html @@ -0,0 +1,159 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- r -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_s.html b/Space-Invaders/sfml/doc/html/functions_eval_s.html new file mode 100644 index 000000000..93ec03503 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_s.html @@ -0,0 +1,181 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- s -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_t.html b/Space-Invaders/sfml/doc/html/functions_eval_t.html new file mode 100644 index 000000000..6d0168c3e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_t.html @@ -0,0 +1,153 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- t -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_u.html b/Space-Invaders/sfml/doc/html/functions_eval_u.html new file mode 100644 index 000000000..01fe0fd4b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_u.html @@ -0,0 +1,151 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- u -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_v.html b/Space-Invaders/sfml/doc/html/functions_eval_v.html new file mode 100644 index 000000000..49c899f25 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_v.html @@ -0,0 +1,150 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- v -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_w.html b/Space-Invaders/sfml/doc/html/functions_eval_w.html new file mode 100644 index 000000000..d4c51815d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_w.html @@ -0,0 +1,145 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- w -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_x.html b/Space-Invaders/sfml/doc/html/functions_eval_x.html new file mode 100644 index 000000000..8a8496077 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_x.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- x -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_y.html b/Space-Invaders/sfml/doc/html/functions_eval_y.html new file mode 100644 index 000000000..25ef06584 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_y.html @@ -0,0 +1,144 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- y -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_eval_z.html b/Space-Invaders/sfml/doc/html/functions_eval_z.html new file mode 100644 index 000000000..61585be6f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_eval_z.html @@ -0,0 +1,145 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- z -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_f.html b/Space-Invaders/sfml/doc/html/functions_f.html new file mode 100644 index 000000000..47e7dda43 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_f.html @@ -0,0 +1,193 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- f -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func.html b/Space-Invaders/sfml/doc/html/functions_func.html new file mode 100644 index 000000000..1f93ecf77 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func.html @@ -0,0 +1,147 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- a -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_b.html b/Space-Invaders/sfml/doc/html/functions_func_b.html new file mode 100644 index 000000000..5db55977d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_b.html @@ -0,0 +1,143 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- b -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_c.html b/Space-Invaders/sfml/doc/html/functions_func_c.html new file mode 100644 index 000000000..38196e304 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_c.html @@ -0,0 +1,165 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- c -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_d.html b/Space-Invaders/sfml/doc/html/functions_func_d.html new file mode 100644 index 000000000..040421741 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_d.html @@ -0,0 +1,151 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- d -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_e.html b/Space-Invaders/sfml/doc/html/functions_func_e.html new file mode 100644 index 000000000..f38c0df7c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_e.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- e -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_f.html b/Space-Invaders/sfml/doc/html/functions_func_f.html new file mode 100644 index 000000000..de5fe1c1e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_f.html @@ -0,0 +1,152 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- f -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_g.html b/Space-Invaders/sfml/doc/html/functions_func_g.html new file mode 100644 index 000000000..2c7f9d53b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_g.html @@ -0,0 +1,241 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- g -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_h.html b/Space-Invaders/sfml/doc/html/functions_func_h.html new file mode 100644 index 000000000..617e2654b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_h.html @@ -0,0 +1,144 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- h -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_i.html b/Space-Invaders/sfml/doc/html/functions_func_i.html new file mode 100644 index 000000000..4f49fb8d2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_i.html @@ -0,0 +1,163 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- i -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_k.html b/Space-Invaders/sfml/doc/html/functions_func_k.html new file mode 100644 index 000000000..f87b0407c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_k.html @@ -0,0 +1,141 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- k -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_l.html b/Space-Invaders/sfml/doc/html/functions_func_l.html new file mode 100644 index 000000000..303fd11b0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_l.html @@ -0,0 +1,154 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- l -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_m.html b/Space-Invaders/sfml/doc/html/functions_func_m.html new file mode 100644 index 000000000..c024419f1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_m.html @@ -0,0 +1,148 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- m -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_n.html b/Space-Invaders/sfml/doc/html/functions_func_n.html new file mode 100644 index 000000000..a20bba954 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_n.html @@ -0,0 +1,142 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- n -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_o.html b/Space-Invaders/sfml/doc/html/functions_func_o.html new file mode 100644 index 000000000..7b738f0e0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_o.html @@ -0,0 +1,180 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- o -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_p.html b/Space-Invaders/sfml/doc/html/functions_func_p.html new file mode 100644 index 000000000..7cf7d3db2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_p.html @@ -0,0 +1,147 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- p -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_r.html b/Space-Invaders/sfml/doc/html/functions_func_r.html new file mode 100644 index 000000000..6dbb39d67 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_r.html @@ -0,0 +1,163 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- r -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_s.html b/Space-Invaders/sfml/doc/html/functions_func_s.html new file mode 100644 index 000000000..2a3f00a86 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_s.html @@ -0,0 +1,232 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- s -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_t.html b/Space-Invaders/sfml/doc/html/functions_func_t.html new file mode 100644 index 000000000..a3a6292d7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_t.html @@ -0,0 +1,166 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- t -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_u.html b/Space-Invaders/sfml/doc/html/functions_func_u.html new file mode 100644 index 000000000..e160a2b83 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_u.html @@ -0,0 +1,147 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- u -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_v.html b/Space-Invaders/sfml/doc/html/functions_func_v.html new file mode 100644 index 000000000..acffc68fb --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_v.html @@ -0,0 +1,147 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- v -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_w.html b/Space-Invaders/sfml/doc/html/functions_func_w.html new file mode 100644 index 000000000..12efcb3a3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_w.html @@ -0,0 +1,145 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- w -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_z.html b/Space-Invaders/sfml/doc/html/functions_func_z.html new file mode 100644 index 000000000..647bde8bc --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_z.html @@ -0,0 +1,141 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- z -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_func_~.html b/Space-Invaders/sfml/doc/html/functions_func_~.html new file mode 100644 index 000000000..5dad9ef9f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_func_~.html @@ -0,0 +1,180 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- ~ -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_g.html b/Space-Invaders/sfml/doc/html/functions_g.html new file mode 100644 index 000000000..190523569 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_g.html @@ -0,0 +1,255 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- g -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_h.html b/Space-Invaders/sfml/doc/html/functions_h.html new file mode 100644 index 000000000..9839620df --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_h.html @@ -0,0 +1,158 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- h -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_i.html b/Space-Invaders/sfml/doc/html/functions_i.html new file mode 100644 index 000000000..1a52864a5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_i.html @@ -0,0 +1,177 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- i -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_j.html b/Space-Invaders/sfml/doc/html/functions_j.html new file mode 100644 index 000000000..5e62d4b2c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_j.html @@ -0,0 +1,154 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- j -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_k.html b/Space-Invaders/sfml/doc/html/functions_k.html new file mode 100644 index 000000000..a3132d222 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_k.html @@ -0,0 +1,151 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- k -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_l.html b/Space-Invaders/sfml/doc/html/functions_l.html new file mode 100644 index 000000000..eea813150 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_l.html @@ -0,0 +1,176 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- l -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_m.html b/Space-Invaders/sfml/doc/html/functions_m.html new file mode 100644 index 000000000..8abd5fc76 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_m.html @@ -0,0 +1,184 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- m -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_n.html b/Space-Invaders/sfml/doc/html/functions_n.html new file mode 100644 index 000000000..8741ba8e4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_n.html @@ -0,0 +1,192 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- n -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_o.html b/Space-Invaders/sfml/doc/html/functions_o.html new file mode 100644 index 000000000..322c9d6d0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_o.html @@ -0,0 +1,194 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- o -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_p.html b/Space-Invaders/sfml/doc/html/functions_p.html new file mode 100644 index 000000000..1075f00ac --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_p.html @@ -0,0 +1,173 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- p -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_q.html b/Space-Invaders/sfml/doc/html/functions_q.html new file mode 100644 index 000000000..6157b4cbe --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_q.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- q -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_r.html b/Space-Invaders/sfml/doc/html/functions_r.html new file mode 100644 index 000000000..50c24e705 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_r.html @@ -0,0 +1,186 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- r -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_rela.html b/Space-Invaders/sfml/doc/html/functions_rela.html new file mode 100644 index 000000000..ecb33c1aa --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_rela.html @@ -0,0 +1,112 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_s.html b/Space-Invaders/sfml/doc/html/functions_s.html new file mode 100644 index 000000000..4095ad3bb --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_s.html @@ -0,0 +1,288 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- s -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_t.html b/Space-Invaders/sfml/doc/html/functions_t.html new file mode 100644 index 000000000..78944ed75 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_t.html @@ -0,0 +1,192 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- t -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_type.html b/Space-Invaders/sfml/doc/html/functions_type.html new file mode 100644 index 000000000..de9a8c0b1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_type.html @@ -0,0 +1,113 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_u.html b/Space-Invaders/sfml/doc/html/functions_u.html new file mode 100644 index 000000000..bcd1dce8b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_u.html @@ -0,0 +1,161 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- u -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_v.html b/Space-Invaders/sfml/doc/html/functions_v.html new file mode 100644 index 000000000..ec2802b65 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_v.html @@ -0,0 +1,158 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- v -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_vars.html b/Space-Invaders/sfml/doc/html/functions_vars.html new file mode 100644 index 000000000..89e8c32a0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_vars.html @@ -0,0 +1,325 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  + +

- a -

+ + +

- b -

+ + +

- c -

+ + +

- d -

+ + +

- f -

+ + +

- g -

+ + +

- h -

+ + +

- i -

+ + +

- j -

+ + +

- k -

+ + +

- l -

+ + +

- m -

+ + +

- n -

+ + +

- o -

+ + +

- p -

+ + +

- r -

+ + +

- s -

+ + +

- t -

+ + +

- u -

+ + +

- v -

+ + +

- w -

+ + +

- x -

+ + +

- y -

+ + +

- z -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_w.html b/Space-Invaders/sfml/doc/html/functions_w.html new file mode 100644 index 000000000..4a037ed97 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_w.html @@ -0,0 +1,155 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- w -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_x.html b/Space-Invaders/sfml/doc/html/functions_x.html new file mode 100644 index 000000000..618e9cd02 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_x.html @@ -0,0 +1,149 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- x -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_y.html b/Space-Invaders/sfml/doc/html/functions_y.html new file mode 100644 index 000000000..789a4b3e5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_y.html @@ -0,0 +1,148 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- y -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_z.html b/Space-Invaders/sfml/doc/html/functions_z.html new file mode 100644 index 000000000..f3363097d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_z.html @@ -0,0 +1,149 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- z -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/functions_~.html b/Space-Invaders/sfml/doc/html/functions_~.html new file mode 100644 index 000000000..90136181d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/functions_~.html @@ -0,0 +1,184 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented class members with links to the class documentation for each member:
+ +

- ~ -

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/globals.html b/Space-Invaders/sfml/doc/html/globals.html new file mode 100644 index 000000000..138aa88a5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/globals.html @@ -0,0 +1,105 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented file members with links to the documentation:
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/globals_defs.html b/Space-Invaders/sfml/doc/html/globals_defs.html new file mode 100644 index 000000000..d45d1c528 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/globals_defs.html @@ -0,0 +1,105 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/group__audio.html b/Space-Invaders/sfml/doc/html/group__audio.html new file mode 100644 index 000000000..75c5f5fd8 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/group__audio.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Classes
+
Audio module
+
+
+ +

Sounds, streaming (musics or custom sources), recording, spatialization. +More...

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Classes

class  sf::AlResource
 Base class for classes that require an OpenAL context. More...
 
class  sf::InputSoundFile
 Provide read access to sound files. More...
 
class  sf::Listener
 The audio listener is the point in the scene from where all the sounds are heard. More...
 
class  sf::Music
 Streamed music played from an audio file. More...
 
class  sf::OutputSoundFile
 Provide write access to sound files. More...
 
class  sf::Sound
 Regular sound that can be played in the audio environment. More...
 
class  sf::SoundBuffer
 Storage for audio samples defining a sound. More...
 
class  sf::SoundBufferRecorder
 Specialized SoundRecorder which stores the captured audio data into a sound buffer. More...
 
class  sf::SoundFileFactory
 Manages and instantiates sound file readers and writers. More...
 
class  sf::SoundFileReader
 Abstract base class for sound file decoding. More...
 
class  sf::SoundFileWriter
 Abstract base class for sound file encoding. More...
 
class  sf::SoundRecorder
 Abstract base class for capturing sound data. More...
 
class  sf::SoundSource
 Base class defining a sound's properties. More...
 
class  sf::SoundStream
 Abstract base class for streamed audio sources. More...
 
+

Detailed Description

+

Sounds, streaming (musics or custom sources), recording, spatialization.

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/group__graphics.html b/Space-Invaders/sfml/doc/html/group__graphics.html new file mode 100644 index 000000000..dd95475c3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/group__graphics.html @@ -0,0 +1,249 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Namespaces | +Classes | +Enumerations
+
Graphics module
+
+
+ +

2D graphics module: sprites, text, shapes, ... +More...

+ + + + + +

+Namespaces

namespace  sf::Glsl
 Namespace with GLSL types.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Classes

class  sf::BlendMode
 Blending modes for drawing. More...
 
class  sf::CircleShape
 Specialized shape representing a circle. More...
 
class  sf::Color
 Utility class for manipulating RGBA colors. More...
 
class  sf::ConvexShape
 Specialized shape representing a convex polygon. More...
 
class  sf::Drawable
 Abstract base class for objects that can be drawn to a render target. More...
 
class  sf::Font
 Class for loading and manipulating character fonts. More...
 
class  sf::Glyph
 Structure describing a glyph. More...
 
class  sf::Image
 Class for loading, manipulating and saving images. More...
 
class  sf::Rect< T >
 Utility class for manipulating 2D axis aligned rectangles. More...
 
class  sf::RectangleShape
 Specialized shape representing a rectangle. More...
 
class  sf::RenderStates
 Define the states used for drawing to a RenderTarget. More...
 
class  sf::RenderTarget
 Base class for all render targets (window, texture, ...) More...
 
class  sf::RenderTexture
 Target for off-screen 2D rendering into a texture. More...
 
class  sf::RenderWindow
 Window that can serve as a target for 2D drawing. More...
 
class  sf::Shader
 Shader class (vertex, geometry and fragment) More...
 
class  sf::Shape
 Base class for textured shapes with outline. More...
 
class  sf::Sprite
 Drawable representation of a texture, with its own transformations, color, etc. More...
 
class  sf::Text
 Graphical text that can be drawn to a render target. More...
 
class  sf::Texture
 Image living on the graphics card that can be used for drawing. More...
 
class  sf::Transform
 Define a 3x3 transform matrix. More...
 
class  sf::Transformable
 Decomposed transform defined by a position, a rotation and a scale. More...
 
class  sf::Vertex
 Define a point with color and texture coordinates. More...
 
class  sf::VertexArray
 Define a set of one or more 2D primitives. More...
 
class  sf::VertexBuffer
 Vertex buffer storage for one or more 2D primitives. More...
 
class  sf::View
 2D camera that defines what region is shown on screen More...
 
+ + + + +

+Enumerations

enum  sf::PrimitiveType {
+  sf::Points +, sf::Lines +, sf::LineStrip +, sf::Triangles +,
+  sf::TriangleStrip +, sf::TriangleFan +, sf::Quads +, sf::LinesStrip = LineStrip +,
+  sf::TrianglesStrip = TriangleStrip +, sf::TrianglesFan = TriangleFan +
+ }
 Types of primitives that a sf::VertexArray can render. More...
 
+

Detailed Description

+

2D graphics module: sprites, text, shapes, ...

+

Enumeration Type Documentation

+ +

◆ PrimitiveType

+ +
+
+ + + + +
enum sf::PrimitiveType
+
+ +

Types of primitives that a sf::VertexArray can render.

+

Points and lines have no area, therefore their thickness will always be 1 pixel, regardless the current transform and view.

+ + + + + + + + + + + +
Enumerator
Points 

List of individual points.

+
Lines 

List of individual lines.

+
LineStrip 

List of connected lines, a point uses the previous point to form a line.

+
Triangles 

List of individual triangles.

+
TriangleStrip 

List of connected triangles, a point uses the two previous points to form a triangle.

+
TriangleFan 

List of connected triangles, a point uses the common center and the previous point to form a triangle.

+
Quads 

List of individual quads (deprecated, don't work with OpenGL ES)

+
LinesStrip 
Deprecated:
Use LineStrip instead
+
TrianglesStrip 
Deprecated:
Use TriangleStrip instead
+
TrianglesFan 
Deprecated:
Use TriangleFan instead
+
+ +

Definition at line 39 of file PrimitiveType.hpp.

+ +
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/group__network.html b/Space-Invaders/sfml/doc/html/group__network.html new file mode 100644 index 000000000..0eb57fa93 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/group__network.html @@ -0,0 +1,131 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Classes
+
Network module
+
+
+ +

Socket-based communication, utilities and higher-level network protocols (HTTP, FTP). +More...

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Classes

class  sf::Ftp
 A FTP client. More...
 
class  sf::Http
 A HTTP client. More...
 
class  sf::IpAddress
 Encapsulate an IPv4 network address. More...
 
class  sf::Packet
 Utility class to build blocks of data to transfer over the network. More...
 
class  sf::Socket
 Base class for all the socket types. More...
 
class  sf::SocketSelector
 Multiplexer that allows to read from multiple sockets. More...
 
class  sf::TcpListener
 Socket that listens to new TCP connections. More...
 
class  sf::TcpSocket
 Specialized socket using the TCP protocol. More...
 
class  sf::UdpSocket
 Specialized socket using the UDP protocol. More...
 
+

Detailed Description

+

Socket-based communication, utilities and higher-level network protocols (HTTP, FTP).

+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/group__system.html b/Space-Invaders/sfml/doc/html/group__system.html new file mode 100644 index 000000000..4546a4807 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/group__system.html @@ -0,0 +1,249 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Classes | +Functions
+
System module
+
+
+ +

Base module of SFML, defining various utilities. +More...

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Classes

class  sf::Clock
 Utility class that measures the elapsed time. More...
 
class  sf::FileInputStream
 Implementation of input stream based on a file. More...
 
class  sf::InputStream
 Abstract class for custom file input streams. More...
 
class  sf::Lock
 Automatic wrapper for locking and unlocking mutexes. More...
 
class  sf::MemoryInputStream
 Implementation of input stream based on a memory chunk. More...
 
class  sf::Mutex
 Blocks concurrent access to shared resources from multiple threads. More...
 
class  sf::NonCopyable
 Utility class that makes any derived class non-copyable. More...
 
class  sf::String
 Utility string class that automatically handles conversions between types and encodings. More...
 
class  sf::Thread
 Utility class to manipulate threads. More...
 
class  sf::ThreadLocal
 Defines variables with thread-local storage. More...
 
class  sf::ThreadLocalPtr< T >
 Pointer to a thread-local variable. More...
 
class  sf::Time
 Represents a time value. More...
 
class  sf::Utf< N >
 Utility class providing generic functions for UTF conversions. More...
 
class  sf::Vector2< T >
 Utility template class for manipulating 2-dimensional vectors. More...
 
class  sf::Vector3< T >
 Utility template class for manipulating 3-dimensional vectors. More...
 
+ + + + + + + + + + +

+Functions

ANativeActivity * sf::getNativeActivity ()
 Return a pointer to the Android native activity.
 
void sf::sleep (Time duration)
 Make the current thread sleep for a given duration.
 
std::ostream & sf::err ()
 Standard stream used by SFML to output warnings and errors.
 
+

Detailed Description

+

Base module of SFML, defining various utilities.

+

It provides vector classes, Unicode strings and conversion functions, threads and mutexes, timing classes.

+

Function Documentation

+ +

◆ err()

+ +
+
+ + + + + + + +
sf::err ()
+
+ +

Standard stream used by SFML to output warnings and errors.

+

By default, sf::err() outputs to the same location as std::cerr, (-> the stderr descriptor) which is the console if there's one available.

+

It is a standard std::ostream instance, so it supports all the insertion operations defined by the STL (operator <<, manipulators, etc.).

+

sf::err() can be redirected to write to another output, independently of std::cerr, by using the rdbuf() function provided by the std::ostream class.

+

Example:

// Redirect to a file
+
std::ofstream file("sfml-log.txt");
+
std::streambuf* previous = sf::err().rdbuf(file.rdbuf());
+
+
// Redirect to nothing
+
sf::err().rdbuf(NULL);
+
+
// Restore the original output
+
sf::err().rdbuf(previous);
+
sf::err
std::ostream & err()
Standard stream used by SFML to output warnings and errors.
+
Returns
Reference to std::ostream representing the SFML error stream
+ +
+
+ +

◆ getNativeActivity()

+ +
+
+ + + + + + + +
ANativeActivity * sf::getNativeActivity ()
+
+ +

Return a pointer to the Android native activity.

+

You shouldn't have to use this function, unless you want to implement very specific details, that SFML doesn't support, or to use a workaround for a known issue.

+
Returns
Pointer to Android native activity structure
+
+
Platform Limitation
+
This is only available on Android and to use it, you'll have to specifically include SFML/System/NativeActivity.hpp in your code.
+
+ +
+
+ +

◆ sleep()

+ +
+
+ + + + + + + + +
void sf::sleep (Time duration)
+
+ +

Make the current thread sleep for a given duration.

+

sf::sleep is the best way to block a program or one of its threads, as it doesn't consume any CPU power.

+
Parameters
+ + +
durationTime to sleep
+
+
+ +
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/group__window.html b/Space-Invaders/sfml/doc/html/group__window.html new file mode 100644 index 000000000..442b09a61 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/group__window.html @@ -0,0 +1,240 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Classes | +Typedefs | +Enumerations
+
Window module
+
+
+ +

Provides OpenGL-based windows, and abstractions for events and input handling. +More...

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Classes

class  sf::Clipboard
 Give access to the system clipboard. More...
 
class  sf::Context
 Class holding a valid drawing context. More...
 
class  sf::ContextSettings
 Structure defining the settings of the OpenGL context attached to a window. More...
 
class  sf::Cursor
 Cursor defines the appearance of a system cursor. More...
 
class  sf::Event
 Defines a system event and its parameters. More...
 
class  sf::GlResource
 Base class for classes that require an OpenGL context. More...
 
class  sf::Joystick
 Give access to the real-time state of the joysticks. More...
 
class  sf::Keyboard
 Give access to the real-time state of the keyboard. More...
 
class  sf::Mouse
 Give access to the real-time state of the mouse. More...
 
class  sf::Sensor
 Give access to the real-time state of the sensors. More...
 
class  sf::Touch
 Give access to the real-time state of the touches. More...
 
class  sf::VideoMode
 VideoMode defines a video mode (width, height, bpp) More...
 
class  sf::Vulkan
 Vulkan helper functions. More...
 
class  sf::Window
 Window that serves as a target for OpenGL rendering. More...
 
class  sf::WindowBase
 Window that serves as a base for other windows. More...
 
+ + + + +

+Typedefs

typedef platform specific sf::WindowHandle
 Define a low-level window handle type, specific to each platform.
 
+ + + + +

+Enumerations

enum  {
+  sf::Style::None = 0 +, sf::Style::Titlebar = 1 << 0 +, sf::Style::Resize = 1 << 1 +, sf::Style::Close = 1 << 2 +,
+  sf::Style::Fullscreen = 1 << 3 +, sf::Style::Default = Titlebar | Resize | Close +
+ }
 Enumeration of the window styles. More...
 
+

Detailed Description

+

Provides OpenGL-based windows, and abstractions for events and input handling.

+

Typedef Documentation

+ +

◆ WindowHandle

+ +
+
+ + + + +
sf::WindowHandle
+
+ +

Define a low-level window handle type, specific to each platform.

+ + + + + + + + + + + + + +
Platform Type
Windows HWND
Linux/FreeBSD Window
Mac OS X either NSWindow* or NSView*, disguised as void*
iOS UIWindow*
Android ANativeWindow*
+
Mac OS X Specification
+

On Mac OS X, a sf::Window can be created either from an existing NSWindow* or an NSView*. When the window is created from a window, SFML will use its content view as the OpenGL area. sf::Window::getSystemHandle() will return the handle that was used to create the window, which is a NSWindow* by default.

+ +

Definition at line 68 of file WindowHandle.hpp.

+ +
+
+

Enumeration Type Documentation

+ +

◆ anonymous enum

+ +
+
+ + + + +
anonymous enum
+
+ +

Enumeration of the window styles.

+ + + + + + + +
Enumerator
None 

No border / title bar (this flag and all others are mutually exclusive)

+
Titlebar 

Title bar + fixed border.

+
Resize 

Title bar + resizable border + maximize button.

+
Close 

Title bar + close button.

+
Fullscreen 

Fullscreen mode (this flag and all others are mutually exclusive)

+
Default 

Default window style.

+
+ +

Definition at line 38 of file WindowStyle.hpp.

+ +
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/hierarchy.html b/Space-Invaders/sfml/doc/html/hierarchy.html new file mode 100644 index 000000000..b6f8f8684 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/hierarchy.html @@ -0,0 +1,225 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Class Hierarchy
+
+
+
This inheritance list is sorted roughly, but not completely, alphabetically:
+
[detail level 1234]
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ►Csf::AlResourceBase class for classes that require an OpenAL context
 Csf::BlendModeBlending modes for drawing
 Csf::SoundStream::ChunkStructure defining a chunk of audio data to stream
 Csf::ClipboardGive access to the system clipboard
 Csf::ClockUtility class that measures the elapsed time
 Csf::ColorUtility class for manipulating RGBA colors
 Csf::ContextSettingsStructure defining the settings of the OpenGL context attached to a window
 Csf::Shader::CurrentTextureTypeSpecial type that can be passed to setUniform(), and that represents the texture of the object being drawn
 ►Csf::DrawableAbstract base class for objects that can be drawn to a render target
 Csf::EventDefines a system event and its parameters
 Csf::FontClass for loading and manipulating character fonts
 ►Csf::GlResourceBase class for classes that require an OpenGL context
 Csf::GlyphStructure describing a glyph
 Csf::Joystick::IdentificationStructure holding a joystick's identification
 Csf::ImageClass for loading, manipulating and saving images
 Csf::Font::InfoHolds various information about a font
 Csf::SoundFileReader::InfoStructure holding the audio properties of a sound file
 ►Csf::InputStreamAbstract class for custom file input streams
 Csf::IpAddressEncapsulate an IPv4 network address
 Csf::JoystickGive access to the real-time state of the joysticks
 Csf::Event::JoystickButtonEventJoystick buttons events parameters (JoystickButtonPressed, JoystickButtonReleased)
 Csf::Event::JoystickConnectEventJoystick connection events parameters (JoystickConnected, JoystickDisconnected)
 Csf::Event::JoystickMoveEventJoystick axis move event parameters (JoystickMoved)
 Csf::KeyboardGive access to the real-time state of the keyboard
 Csf::Event::KeyEventKeyboard event parameters (KeyPressed, KeyReleased)
 Csf::ListenerThe audio listener is the point in the scene from where all the sounds are heard
 Csf::MouseGive access to the real-time state of the mouse
 Csf::Event::MouseButtonEventMouse buttons events parameters (MouseButtonPressed, MouseButtonReleased)
 Csf::Event::MouseMoveEventMouse move event parameters (MouseMoved)
 Csf::Event::MouseWheelEventMouse wheel events parameters (MouseWheelMoved)
 Csf::Event::MouseWheelScrollEventMouse wheel events parameters (MouseWheelScrolled)
 ►Csf::NonCopyableUtility class that makes any derived class non-copyable
 Csf::PacketUtility class to build blocks of data to transfer over the network
 Csf::Rect< T >Utility class for manipulating 2D axis aligned rectangles
 Csf::Rect< float >
 Csf::Rect< int >
 Csf::RenderStatesDefine the states used for drawing to a RenderTarget
 Csf::Http::RequestDefine a HTTP request
 ►Csf::Ftp::ResponseDefine a FTP response
 Csf::Http::ResponseDefine a HTTP response
 Csf::Keyboard::ScanScancodes
 Csf::SensorGive access to the real-time state of the sensors
 Csf::Event::SensorEventSensor event parameters (SensorChanged)
 Csf::Event::SizeEventSize events parameters (Resized)
 Csf::SocketSelectorMultiplexer that allows to read from multiple sockets
 Csf::SoundFileFactoryManages and instantiates sound file readers and writers
 Csf::SoundFileReaderAbstract base class for sound file decoding
 Csf::SoundFileWriterAbstract base class for sound file encoding
 Csf::Music::Span< T >Structure defining a time range using the template type
 Csf::Music::Span< Uint64 >
 Csf::StringUtility string class that automatically handles conversions between types and encodings
 Csf::Event::TextEventText event parameters (TextEntered)
 Csf::TimeRepresents a time value
 Csf::TouchGive access to the real-time state of the touches
 Csf::Event::TouchEventTouch events parameters (TouchBegan, TouchMoved, TouchEnded)
 Csf::TransformDefine a 3x3 transform matrix
 ►Csf::TransformableDecomposed transform defined by a position, a rotation and a scale
 Csf::Utf< N >Utility class providing generic functions for UTF conversions
 Csf::Utf< 16 >Specialization of the Utf template for UTF-16
 Csf::Utf< 32 >Specialization of the Utf template for UTF-32
 Csf::Utf< 8 >Specialization of the Utf template for UTF-8
 Csf::Vector2< T >Utility template class for manipulating 2-dimensional vectors
 Csf::Vector2< float >
 Csf::Vector2< unsigned int >
 Csf::Vector3< T >Utility template class for manipulating 3-dimensional vectors
 Csf::VertexDefine a point with color and texture coordinates
 Csf::VideoModeVideoMode defines a video mode (width, height, bpp)
 Csf::View2D camera that defines what region is shown on screen
 Csf::VulkanVulkan helper functions
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/index.html b/Space-Invaders/sfml/doc/html/index.html new file mode 100644 index 000000000..12e4f8298 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/index.html @@ -0,0 +1,170 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
SFML Documentation
+
+
+

+Welcome

+

Welcome to the official SFML documentation. Here you will find a detailed view of all the SFML classes and functions.
+ If you are looking for tutorials, you can visit the official website at www.sfml-dev.org.

+

+Short example

+

Here is a short example, to show you how simple it is to use SFML:

+
#include <SFML/Audio.hpp>
+
#include <SFML/Graphics.hpp>
+
+
int main()
+
{
+
// Create the main window
+
sf::RenderWindow window(sf::VideoMode(800, 600), "SFML window");
+
+
// Load a sprite to display
+
sf::Texture texture;
+
if (!texture.loadFromFile("cute_image.jpg"))
+
return EXIT_FAILURE;
+
sf::Sprite sprite(texture);
+
+
// Create a graphical text to display
+
sf::Font font;
+
if (!font.loadFromFile("arial.ttf"))
+
return EXIT_FAILURE;
+
sf::Text text("Hello SFML", font, 50);
+
+
// Load a music to play
+
sf::Music music;
+
if (!music.openFromFile("nice_music.ogg"))
+
return EXIT_FAILURE;
+
+
// Play the music
+
music.play();
+
+
// Start the game loop
+
while (window.isOpen())
+
{
+
// Process events
+
sf::Event event;
+
while (window.pollEvent(event))
+
{
+
// Close window: exit
+
if (event.type == sf::Event::Closed)
+
window.close();
+
}
+
+
// Clear screen
+
window.clear();
+
+
// Draw the sprite
+
window.draw(sprite);
+
+
// Draw the string
+
window.draw(text);
+
+
// Update the window
+
window.display();
+
}
+
+
return EXIT_SUCCESS;
+
}
+
sf::Event
Defines a system event and its parameters.
Definition: Event.hpp:45
+
sf::Event::type
EventType type
Type of the event.
Definition: Event.hpp:220
+
sf::Event::Closed
@ Closed
The window requested to be closed (no data)
Definition: Event.hpp:190
+
sf::Font
Class for loading and manipulating character fonts.
Definition: Font.hpp:49
+
sf::Font::loadFromFile
bool loadFromFile(const std::string &filename)
Load the font from a file.
+
sf::Music
Streamed music played from an audio file.
Definition: Music.hpp:49
+
sf::Music::openFromFile
bool openFromFile(const std::string &filename)
Open a music from an audio file.
+
sf::RenderWindow
Window that can serve as a target for 2D drawing.
Definition: RenderWindow.hpp:45
+
sf::SoundStream::play
void play()
Start or resume playing the audio stream.
+
sf::Sprite
Drawable representation of a texture, with its own transformations, color, etc.
Definition: Sprite.hpp:48
+
sf::Text
Graphical text that can be drawn to a render target.
Definition: Text.hpp:49
+
sf::Texture
Image living on the graphics card that can be used for drawing.
Definition: Texture.hpp:49
+
sf::Texture::loadFromFile
bool loadFromFile(const std::string &filename, const IntRect &area=IntRect())
Load the texture from a file on disk.
+
sf::VideoMode
VideoMode defines a video mode (width, height, bpp)
Definition: VideoMode.hpp:42
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/jquery.js b/Space-Invaders/sfml/doc/html/jquery.js new file mode 100644 index 000000000..1dffb65b5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/jquery.js @@ -0,0 +1,34 @@ +/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */ +!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="",y.option=!!ce.lastChild;var ge={thead:[1,"","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n",""]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="
",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0",options:{classes:{},disabled:!1,create:null},_createWidget:function(t,e){e=y(e||this.defaultElement||this)[0],this.element=y(e),this.uuid=i++,this.eventNamespace="."+this.widgetName+this.uuid,this.bindings=y(),this.hoverable=y(),this.focusable=y(),this.classesElementLookup={},e!==this&&(y.data(e,this.widgetFullName,this),this._on(!0,this.element,{remove:function(t){t.target===e&&this.destroy()}}),this.document=y(e.style?e.ownerDocument:e.document||e),this.window=y(this.document[0].defaultView||this.document[0].parentWindow)),this.options=y.widget.extend({},this.options,this._getCreateOptions(),t),this._create(),this.options.disabled&&this._setOptionDisabled(this.options.disabled),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:function(){return{}},_getCreateEventData:y.noop,_create:y.noop,_init:y.noop,destroy:function(){var i=this;this._destroy(),y.each(this.classesElementLookup,function(t,e){i._removeClass(e,t)}),this.element.off(this.eventNamespace).removeData(this.widgetFullName),this.widget().off(this.eventNamespace).removeAttr("aria-disabled"),this.bindings.off(this.eventNamespace)},_destroy:y.noop,widget:function(){return this.element},option:function(t,e){var i,s,n,o=t;if(0===arguments.length)return y.widget.extend({},this.options);if("string"==typeof t)if(o={},t=(i=t.split(".")).shift(),i.length){for(s=o[t]=y.widget.extend({},this.options[t]),n=0;n
"),i=e.children()[0];return y("body").append(e),t=i.offsetWidth,e.css("overflow","scroll"),t===(i=i.offsetWidth)&&(i=e[0].clientWidth),e.remove(),s=t-i},getScrollInfo:function(t){var e=t.isWindow||t.isDocument?"":t.element.css("overflow-x"),i=t.isWindow||t.isDocument?"":t.element.css("overflow-y"),e="scroll"===e||"auto"===e&&t.widthx(D(s),D(n))?o.important="horizontal":o.important="vertical",p.using.call(this,t,o)}),h.offset(y.extend(l,{using:t}))})},y.ui.position={fit:{left:function(t,e){var i=e.within,s=i.isWindow?i.scrollLeft:i.offset.left,n=i.width,o=t.left-e.collisionPosition.marginLeft,h=s-o,a=o+e.collisionWidth-n-s;e.collisionWidth>n?0n?0=this.options.distance},_mouseDelayMet:function(){return this.mouseDelayMet},_mouseStart:function(){},_mouseDrag:function(){},_mouseStop:function(){},_mouseCapture:function(){return!0}}),y.ui.plugin={add:function(t,e,i){var s,n=y.ui[t].prototype;for(s in i)n.plugins[s]=n.plugins[s]||[],n.plugins[s].push([e,i[s]])},call:function(t,e,i,s){var n,o=t.plugins[e];if(o&&(s||t.element[0].parentNode&&11!==t.element[0].parentNode.nodeType))for(n=0;n").css({overflow:"hidden",position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")})),this.element=this.element.parent().data("ui-resizable",this.element.resizable("instance")),this.elementIsWrapper=!0,t={marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom"),marginLeft:this.originalElement.css("marginLeft")},this.element.css(t),this.originalElement.css("margin",0),this.originalResizeStyle=this.originalElement.css("resize"),this.originalElement.css("resize","none"),this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"})),this.originalElement.css(t),this._proportionallyResize()),this._setupHandles(),e.autoHide&&y(this.element).on("mouseenter",function(){e.disabled||(i._removeClass("ui-resizable-autohide"),i._handles.show())}).on("mouseleave",function(){e.disabled||i.resizing||(i._addClass("ui-resizable-autohide"),i._handles.hide())}),this._mouseInit()},_destroy:function(){this._mouseDestroy(),this._addedHandles.remove();function t(t){y(t).removeData("resizable").removeData("ui-resizable").off(".resizable")}var e;return this.elementIsWrapper&&(t(this.element),e=this.element,this.originalElement.css({position:e.css("position"),width:e.outerWidth(),height:e.outerHeight(),top:e.css("top"),left:e.css("left")}).insertAfter(e),e.remove()),this.originalElement.css("resize",this.originalResizeStyle),t(this.originalElement),this},_setOption:function(t,e){switch(this._super(t,e),t){case"handles":this._removeHandles(),this._setupHandles();break;case"aspectRatio":this._aspectRatio=!!e}},_setupHandles:function(){var t,e,i,s,n,o=this.options,h=this;if(this.handles=o.handles||(y(".ui-resizable-handle",this.element).length?{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"}:"e,s,se"),this._handles=y(),this._addedHandles=y(),this.handles.constructor===String)for("all"===this.handles&&(this.handles="n,e,s,w,se,sw,ne,nw"),i=this.handles.split(","),this.handles={},e=0;e"),this._addClass(n,"ui-resizable-handle "+s),n.css({zIndex:o.zIndex}),this.handles[t]=".ui-resizable-"+t,this.element.children(this.handles[t]).length||(this.element.append(n),this._addedHandles=this._addedHandles.add(n));this._renderAxis=function(t){var e,i,s;for(e in t=t||this.element,this.handles)this.handles[e].constructor===String?this.handles[e]=this.element.children(this.handles[e]).first().show():(this.handles[e].jquery||this.handles[e].nodeType)&&(this.handles[e]=y(this.handles[e]),this._on(this.handles[e],{mousedown:h._mouseDown})),this.elementIsWrapper&&this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)&&(i=y(this.handles[e],this.element),s=/sw|ne|nw|se|n|s/.test(e)?i.outerHeight():i.outerWidth(),i=["padding",/ne|nw|n/.test(e)?"Top":/se|sw|s/.test(e)?"Bottom":/^e$/.test(e)?"Right":"Left"].join(""),t.css(i,s),this._proportionallyResize()),this._handles=this._handles.add(this.handles[e])},this._renderAxis(this.element),this._handles=this._handles.add(this.element.find(".ui-resizable-handle")),this._handles.disableSelection(),this._handles.on("mouseover",function(){h.resizing||(this.className&&(n=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)),h.axis=n&&n[1]?n[1]:"se")}),o.autoHide&&(this._handles.hide(),this._addClass("ui-resizable-autohide"))},_removeHandles:function(){this._addedHandles.remove()},_mouseCapture:function(t){var e,i,s=!1;for(e in this.handles)(i=y(this.handles[e])[0])!==t.target&&!y.contains(i,t.target)||(s=!0);return!this.options.disabled&&s},_mouseStart:function(t){var e,i,s=this.options,n=this.element;return this.resizing=!0,this._renderProxy(),e=this._num(this.helper.css("left")),i=this._num(this.helper.css("top")),s.containment&&(e+=y(s.containment).scrollLeft()||0,i+=y(s.containment).scrollTop()||0),this.offset=this.helper.offset(),this.position={left:e,top:i},this.size=this._helper?{width:this.helper.width(),height:this.helper.height()}:{width:n.width(),height:n.height()},this.originalSize=this._helper?{width:n.outerWidth(),height:n.outerHeight()}:{width:n.width(),height:n.height()},this.sizeDiff={width:n.outerWidth()-n.width(),height:n.outerHeight()-n.height()},this.originalPosition={left:e,top:i},this.originalMousePosition={left:t.pageX,top:t.pageY},this.aspectRatio="number"==typeof s.aspectRatio?s.aspectRatio:this.originalSize.width/this.originalSize.height||1,s=y(".ui-resizable-"+this.axis).css("cursor"),y("body").css("cursor","auto"===s?this.axis+"-resize":s),this._addClass("ui-resizable-resizing"),this._propagate("start",t),!0},_mouseDrag:function(t){var e=this.originalMousePosition,i=this.axis,s=t.pageX-e.left||0,e=t.pageY-e.top||0,i=this._change[i];return this._updatePrevProperties(),i&&(e=i.apply(this,[t,s,e]),this._updateVirtualBoundaries(t.shiftKey),(this._aspectRatio||t.shiftKey)&&(e=this._updateRatio(e,t)),e=this._respectSize(e,t),this._updateCache(e),this._propagate("resize",t),e=this._applyChanges(),!this._helper&&this._proportionallyResizeElements.length&&this._proportionallyResize(),y.isEmptyObject(e)||(this._updatePrevProperties(),this._trigger("resize",t,this.ui()),this._applyChanges())),!1},_mouseStop:function(t){this.resizing=!1;var e,i,s,n=this.options,o=this;return this._helper&&(s=(e=(i=this._proportionallyResizeElements).length&&/textarea/i.test(i[0].nodeName))&&this._hasScroll(i[0],"left")?0:o.sizeDiff.height,i=e?0:o.sizeDiff.width,e={width:o.helper.width()-i,height:o.helper.height()-s},i=parseFloat(o.element.css("left"))+(o.position.left-o.originalPosition.left)||null,s=parseFloat(o.element.css("top"))+(o.position.top-o.originalPosition.top)||null,n.animate||this.element.css(y.extend(e,{top:s,left:i})),o.helper.height(o.size.height),o.helper.width(o.size.width),this._helper&&!n.animate&&this._proportionallyResize()),y("body").css("cursor","auto"),this._removeClass("ui-resizable-resizing"),this._propagate("stop",t),this._helper&&this.helper.remove(),!1},_updatePrevProperties:function(){this.prevPosition={top:this.position.top,left:this.position.left},this.prevSize={width:this.size.width,height:this.size.height}},_applyChanges:function(){var t={};return this.position.top!==this.prevPosition.top&&(t.top=this.position.top+"px"),this.position.left!==this.prevPosition.left&&(t.left=this.position.left+"px"),this.size.width!==this.prevSize.width&&(t.width=this.size.width+"px"),this.size.height!==this.prevSize.height&&(t.height=this.size.height+"px"),this.helper.css(t),t},_updateVirtualBoundaries:function(t){var e,i,s=this.options,n={minWidth:this._isNumber(s.minWidth)?s.minWidth:0,maxWidth:this._isNumber(s.maxWidth)?s.maxWidth:1/0,minHeight:this._isNumber(s.minHeight)?s.minHeight:0,maxHeight:this._isNumber(s.maxHeight)?s.maxHeight:1/0};(this._aspectRatio||t)&&(e=n.minHeight*this.aspectRatio,i=n.minWidth/this.aspectRatio,s=n.maxHeight*this.aspectRatio,t=n.maxWidth/this.aspectRatio,e>n.minWidth&&(n.minWidth=e),i>n.minHeight&&(n.minHeight=i),st.width,h=this._isNumber(t.height)&&e.minHeight&&e.minHeight>t.height,a=this.originalPosition.left+this.originalSize.width,r=this.originalPosition.top+this.originalSize.height,l=/sw|nw|w/.test(i),i=/nw|ne|n/.test(i);return o&&(t.width=e.minWidth),h&&(t.height=e.minHeight),s&&(t.width=e.maxWidth),n&&(t.height=e.maxHeight),o&&l&&(t.left=a-e.minWidth),s&&l&&(t.left=a-e.maxWidth),h&&i&&(t.top=r-e.minHeight),n&&i&&(t.top=r-e.maxHeight),t.width||t.height||t.left||!t.top?t.width||t.height||t.top||!t.left||(t.left=null):t.top=null,t},_getPaddingPlusBorderDimensions:function(t){for(var e=0,i=[],s=[t.css("borderTopWidth"),t.css("borderRightWidth"),t.css("borderBottomWidth"),t.css("borderLeftWidth")],n=[t.css("paddingTop"),t.css("paddingRight"),t.css("paddingBottom"),t.css("paddingLeft")];e<4;e++)i[e]=parseFloat(s[e])||0,i[e]+=parseFloat(n[e])||0;return{height:i[0]+i[2],width:i[1]+i[3]}},_proportionallyResize:function(){if(this._proportionallyResizeElements.length)for(var t,e=0,i=this.helper||this.element;e").css({overflow:"hidden"}),this._addClass(this.helper,this._helper),this.helper.css({width:this.element.outerWidth(),height:this.element.outerHeight(),position:"absolute",left:this.elementOffset.left+"px",top:this.elementOffset.top+"px",zIndex:++e.zIndex}),this.helper.appendTo("body").disableSelection()):this.helper=this.element},_change:{e:function(t,e){return{width:this.originalSize.width+e}},w:function(t,e){var i=this.originalSize;return{left:this.originalPosition.left+e,width:i.width-e}},n:function(t,e,i){var s=this.originalSize;return{top:this.originalPosition.top+i,height:s.height-i}},s:function(t,e,i){return{height:this.originalSize.height+i}},se:function(t,e,i){return y.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[t,e,i]))},sw:function(t,e,i){return y.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[t,e,i]))},ne:function(t,e,i){return y.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[t,e,i]))},nw:function(t,e,i){return y.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[t,e,i]))}},_propagate:function(t,e){y.ui.plugin.call(this,t,[e,this.ui()]),"resize"!==t&&this._trigger(t,e,this.ui())},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}}),y.ui.plugin.add("resizable","animate",{stop:function(e){var i=y(this).resizable("instance"),t=i.options,s=i._proportionallyResizeElements,n=s.length&&/textarea/i.test(s[0].nodeName),o=n&&i._hasScroll(s[0],"left")?0:i.sizeDiff.height,h=n?0:i.sizeDiff.width,n={width:i.size.width-h,height:i.size.height-o},h=parseFloat(i.element.css("left"))+(i.position.left-i.originalPosition.left)||null,o=parseFloat(i.element.css("top"))+(i.position.top-i.originalPosition.top)||null;i.element.animate(y.extend(n,o&&h?{top:o,left:h}:{}),{duration:t.animateDuration,easing:t.animateEasing,step:function(){var t={width:parseFloat(i.element.css("width")),height:parseFloat(i.element.css("height")),top:parseFloat(i.element.css("top")),left:parseFloat(i.element.css("left"))};s&&s.length&&y(s[0]).css({width:t.width,height:t.height}),i._updateCache(t),i._propagate("resize",e)}})}}),y.ui.plugin.add("resizable","containment",{start:function(){var i,s,n=y(this).resizable("instance"),t=n.options,e=n.element,o=t.containment,h=o instanceof y?o.get(0):/parent/.test(o)?e.parent().get(0):o;h&&(n.containerElement=y(h),/document/.test(o)||o===document?(n.containerOffset={left:0,top:0},n.containerPosition={left:0,top:0},n.parentData={element:y(document),left:0,top:0,width:y(document).width(),height:y(document).height()||document.body.parentNode.scrollHeight}):(i=y(h),s=[],y(["Top","Right","Left","Bottom"]).each(function(t,e){s[t]=n._num(i.css("padding"+e))}),n.containerOffset=i.offset(),n.containerPosition=i.position(),n.containerSize={height:i.innerHeight()-s[3],width:i.innerWidth()-s[1]},t=n.containerOffset,e=n.containerSize.height,o=n.containerSize.width,o=n._hasScroll(h,"left")?h.scrollWidth:o,e=n._hasScroll(h)?h.scrollHeight:e,n.parentData={element:h,left:t.left,top:t.top,width:o,height:e}))},resize:function(t){var e=y(this).resizable("instance"),i=e.options,s=e.containerOffset,n=e.position,o=e._aspectRatio||t.shiftKey,h={top:0,left:0},a=e.containerElement,t=!0;a[0]!==document&&/static/.test(a.css("position"))&&(h=s),n.left<(e._helper?s.left:0)&&(e.size.width=e.size.width+(e._helper?e.position.left-s.left:e.position.left-h.left),o&&(e.size.height=e.size.width/e.aspectRatio,t=!1),e.position.left=i.helper?s.left:0),n.top<(e._helper?s.top:0)&&(e.size.height=e.size.height+(e._helper?e.position.top-s.top:e.position.top),o&&(e.size.width=e.size.height*e.aspectRatio,t=!1),e.position.top=e._helper?s.top:0),i=e.containerElement.get(0)===e.element.parent().get(0),n=/relative|absolute/.test(e.containerElement.css("position")),i&&n?(e.offset.left=e.parentData.left+e.position.left,e.offset.top=e.parentData.top+e.position.top):(e.offset.left=e.element.offset().left,e.offset.top=e.element.offset().top),n=Math.abs(e.sizeDiff.width+(e._helper?e.offset.left-h.left:e.offset.left-s.left)),s=Math.abs(e.sizeDiff.height+(e._helper?e.offset.top-h.top:e.offset.top-s.top)),n+e.size.width>=e.parentData.width&&(e.size.width=e.parentData.width-n,o&&(e.size.height=e.size.width/e.aspectRatio,t=!1)),s+e.size.height>=e.parentData.height&&(e.size.height=e.parentData.height-s,o&&(e.size.width=e.size.height*e.aspectRatio,t=!1)),t||(e.position.left=e.prevPosition.left,e.position.top=e.prevPosition.top,e.size.width=e.prevSize.width,e.size.height=e.prevSize.height)},stop:function(){var t=y(this).resizable("instance"),e=t.options,i=t.containerOffset,s=t.containerPosition,n=t.containerElement,o=y(t.helper),h=o.offset(),a=o.outerWidth()-t.sizeDiff.width,o=o.outerHeight()-t.sizeDiff.height;t._helper&&!e.animate&&/relative/.test(n.css("position"))&&y(this).css({left:h.left-s.left-i.left,width:a,height:o}),t._helper&&!e.animate&&/static/.test(n.css("position"))&&y(this).css({left:h.left-s.left-i.left,width:a,height:o})}}),y.ui.plugin.add("resizable","alsoResize",{start:function(){var t=y(this).resizable("instance").options;y(t.alsoResize).each(function(){var t=y(this);t.data("ui-resizable-alsoresize",{width:parseFloat(t.width()),height:parseFloat(t.height()),left:parseFloat(t.css("left")),top:parseFloat(t.css("top"))})})},resize:function(t,i){var e=y(this).resizable("instance"),s=e.options,n=e.originalSize,o=e.originalPosition,h={height:e.size.height-n.height||0,width:e.size.width-n.width||0,top:e.position.top-o.top||0,left:e.position.left-o.left||0};y(s.alsoResize).each(function(){var t=y(this),s=y(this).data("ui-resizable-alsoresize"),n={},e=t.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];y.each(e,function(t,e){var i=(s[e]||0)+(h[e]||0);i&&0<=i&&(n[e]=i||null)}),t.css(n)})},stop:function(){y(this).removeData("ui-resizable-alsoresize")}}),y.ui.plugin.add("resizable","ghost",{start:function(){var t=y(this).resizable("instance"),e=t.size;t.ghost=t.originalElement.clone(),t.ghost.css({opacity:.25,display:"block",position:"relative",height:e.height,width:e.width,margin:0,left:0,top:0}),t._addClass(t.ghost,"ui-resizable-ghost"),!1!==y.uiBackCompat&&"string"==typeof t.options.ghost&&t.ghost.addClass(this.options.ghost),t.ghost.appendTo(t.helper)},resize:function(){var t=y(this).resizable("instance");t.ghost&&t.ghost.css({position:"relative",height:t.size.height,width:t.size.width})},stop:function(){var t=y(this).resizable("instance");t.ghost&&t.helper&&t.helper.get(0).removeChild(t.ghost.get(0))}}),y.ui.plugin.add("resizable","grid",{resize:function(){var t,e=y(this).resizable("instance"),i=e.options,s=e.size,n=e.originalSize,o=e.originalPosition,h=e.axis,a="number"==typeof i.grid?[i.grid,i.grid]:i.grid,r=a[0]||1,l=a[1]||1,u=Math.round((s.width-n.width)/r)*r,p=Math.round((s.height-n.height)/l)*l,d=n.width+u,c=n.height+p,f=i.maxWidth&&i.maxWidthd,s=i.minHeight&&i.minHeight>c;i.grid=a,m&&(d+=r),s&&(c+=l),f&&(d-=r),g&&(c-=l),/^(se|s|e)$/.test(h)?(e.size.width=d,e.size.height=c):/^(ne)$/.test(h)?(e.size.width=d,e.size.height=c,e.position.top=o.top-p):/^(sw)$/.test(h)?(e.size.width=d,e.size.height=c,e.position.left=o.left-u):((c-l<=0||d-r<=0)&&(t=e._getPaddingPlusBorderDimensions(this)),0=f[g]?0:Math.min(f[g],n));!a&&1-1){targetElements.on(evt+EVENT_NAMESPACE,function elementToggle(event){$.powerTip.toggle(this,event)})}else{targetElements.on(evt+EVENT_NAMESPACE,function elementOpen(event){$.powerTip.show(this,event)})}});$.each(options.closeEvents,function(idx,evt){if($.inArray(evt,options.openEvents)<0){targetElements.on(evt+EVENT_NAMESPACE,function elementClose(event){$.powerTip.hide(this,!isMouseEvent(event))})}});targetElements.on("keydown"+EVENT_NAMESPACE,function elementKeyDown(event){if(event.keyCode===27){$.powerTip.hide(this,true)}})}return targetElements};$.fn.powerTip.defaults={fadeInTime:200,fadeOutTime:100,followMouse:false,popupId:"powerTip",popupClass:null,intentSensitivity:7,intentPollInterval:100,closeDelay:100,placement:"n",smartPlacement:false,offset:10,mouseOnToPopup:false,manual:false,openEvents:["mouseenter","focus"],closeEvents:["mouseleave","blur"]};$.fn.powerTip.smartPlacementLists={n:["n","ne","nw","s"],e:["e","ne","se","w","nw","sw","n","s","e"],s:["s","se","sw","n"],w:["w","nw","sw","e","ne","se","n","s","w"],nw:["nw","w","sw","n","s","se","nw"],ne:["ne","e","se","n","s","sw","ne"],sw:["sw","w","nw","s","n","ne","sw"],se:["se","e","ne","s","n","nw","se"],"nw-alt":["nw-alt","n","ne-alt","sw-alt","s","se-alt","w","e"],"ne-alt":["ne-alt","n","nw-alt","se-alt","s","sw-alt","e","w"],"sw-alt":["sw-alt","s","se-alt","nw-alt","n","ne-alt","w","e"],"se-alt":["se-alt","s","sw-alt","ne-alt","n","nw-alt","e","w"]};$.powerTip={show:function apiShowTip(element,event){if(isMouseEvent(event)){trackMouse(event);session.previousX=event.pageX;session.previousY=event.pageY;$(element).data(DATA_DISPLAYCONTROLLER).show()}else{$(element).first().data(DATA_DISPLAYCONTROLLER).show(true,true)}return element},reposition:function apiResetPosition(element){$(element).first().data(DATA_DISPLAYCONTROLLER).resetPosition();return element},hide:function apiCloseTip(element,immediate){var displayController;immediate=element?immediate:true;if(element){displayController=$(element).first().data(DATA_DISPLAYCONTROLLER)}else if(session.activeHover){displayController=session.activeHover.data(DATA_DISPLAYCONTROLLER)}if(displayController){displayController.hide(immediate)}return element},toggle:function apiToggle(element,event){if(session.activeHover&&session.activeHover.is(element)){$.powerTip.hide(element,!isMouseEvent(event))}else{$.powerTip.show(element,event)}return element}};$.powerTip.showTip=$.powerTip.show;$.powerTip.closeTip=$.powerTip.hide;function CSSCoordinates(){var me=this;me.top="auto";me.left="auto";me.right="auto";me.bottom="auto";me.set=function(property,value){if($.isNumeric(value)){me[property]=Math.round(value)}}}function DisplayController(element,options,tipController){var hoverTimer=null,myCloseDelay=null;function openTooltip(immediate,forceOpen){cancelTimer();if(!element.data(DATA_HASACTIVEHOVER)){if(!immediate){session.tipOpenImminent=true;hoverTimer=setTimeout(function intentDelay(){hoverTimer=null;checkForIntent()},options.intentPollInterval)}else{if(forceOpen){element.data(DATA_FORCEDOPEN,true)}closeAnyDelayed();tipController.showTip(element)}}else{cancelClose()}}function closeTooltip(disableDelay){if(myCloseDelay){myCloseDelay=session.closeDelayTimeout=clearTimeout(myCloseDelay);session.delayInProgress=false}cancelTimer();session.tipOpenImminent=false;if(element.data(DATA_HASACTIVEHOVER)){element.data(DATA_FORCEDOPEN,false);if(!disableDelay){session.delayInProgress=true;session.closeDelayTimeout=setTimeout(function closeDelay(){session.closeDelayTimeout=null;tipController.hideTip(element);session.delayInProgress=false;myCloseDelay=null},options.closeDelay);myCloseDelay=session.closeDelayTimeout}else{tipController.hideTip(element)}}}function checkForIntent(){var xDifference=Math.abs(session.previousX-session.currentX),yDifference=Math.abs(session.previousY-session.currentY),totalDifference=xDifference+yDifference;if(totalDifference",{id:options.popupId});if($body.length===0){$body=$("body")}$body.append(tipElement);session.tooltips=session.tooltips?session.tooltips.add(tipElement):tipElement}if(options.followMouse){if(!tipElement.data(DATA_HASMOUSEMOVE)){$document.on("mousemove"+EVENT_NAMESPACE,positionTipOnCursor);$window.on("scroll"+EVENT_NAMESPACE,positionTipOnCursor);tipElement.data(DATA_HASMOUSEMOVE,true)}}function beginShowTip(element){element.data(DATA_HASACTIVEHOVER,true);tipElement.queue(function queueTipInit(next){showTip(element);next()})}function showTip(element){var tipContent;if(!element.data(DATA_HASACTIVEHOVER)){return}if(session.isTipOpen){if(!session.isClosing){hideTip(session.activeHover)}tipElement.delay(100).queue(function queueTipAgain(next){showTip(element);next()});return}element.trigger("powerTipPreRender");tipContent=getTooltipContent(element);if(tipContent){tipElement.empty().append(tipContent)}else{return}element.trigger("powerTipRender");session.activeHover=element;session.isTipOpen=true;tipElement.data(DATA_MOUSEONTOTIP,options.mouseOnToPopup);tipElement.addClass(options.popupClass);if(!options.followMouse||element.data(DATA_FORCEDOPEN)){positionTipOnElement(element);session.isFixedTipOpen=true}else{positionTipOnCursor()}if(!element.data(DATA_FORCEDOPEN)&&!options.followMouse){$document.on("click"+EVENT_NAMESPACE,function documentClick(event){var target=event.target;if(target!==element[0]){if(options.mouseOnToPopup){if(target!==tipElement[0]&&!$.contains(tipElement[0],target)){$.powerTip.hide()}}else{$.powerTip.hide()}}})}if(options.mouseOnToPopup&&!options.manual){tipElement.on("mouseenter"+EVENT_NAMESPACE,function tipMouseEnter(){if(session.activeHover){session.activeHover.data(DATA_DISPLAYCONTROLLER).cancel()}});tipElement.on("mouseleave"+EVENT_NAMESPACE,function tipMouseLeave(){if(session.activeHover){session.activeHover.data(DATA_DISPLAYCONTROLLER).hide()}})}tipElement.fadeIn(options.fadeInTime,function fadeInCallback(){if(!session.desyncTimeout){session.desyncTimeout=setInterval(closeDesyncedTip,500)}element.trigger("powerTipOpen")})}function hideTip(element){session.isClosing=true;session.isTipOpen=false;session.desyncTimeout=clearInterval(session.desyncTimeout);element.data(DATA_HASACTIVEHOVER,false);element.data(DATA_FORCEDOPEN,false);$document.off("click"+EVENT_NAMESPACE);tipElement.off(EVENT_NAMESPACE);tipElement.fadeOut(options.fadeOutTime,function fadeOutCallback(){var coords=new CSSCoordinates;session.activeHover=null;session.isClosing=false;session.isFixedTipOpen=false;tipElement.removeClass();coords.set("top",session.currentY+options.offset);coords.set("left",session.currentX+options.offset);tipElement.css(coords);element.trigger("powerTipClose")})}function positionTipOnCursor(){var tipWidth,tipHeight,coords,collisions,collisionCount;if(!session.isFixedTipOpen&&(session.isTipOpen||session.tipOpenImminent&&tipElement.data(DATA_HASMOUSEMOVE))){tipWidth=tipElement.outerWidth();tipHeight=tipElement.outerHeight();coords=new CSSCoordinates;coords.set("top",session.currentY+options.offset);coords.set("left",session.currentX+options.offset);collisions=getViewportCollisions(coords,tipWidth,tipHeight);if(collisions!==Collision.none){collisionCount=countFlags(collisions);if(collisionCount===1){if(collisions===Collision.right){coords.set("left",session.scrollLeft+session.windowWidth-tipWidth)}else if(collisions===Collision.bottom){coords.set("top",session.scrollTop+session.windowHeight-tipHeight)}}else{coords.set("left",session.currentX-tipWidth-options.offset);coords.set("top",session.currentY-tipHeight-options.offset)}}tipElement.css(coords)}}function positionTipOnElement(element){var priorityList,finalPlacement;if(options.smartPlacement||options.followMouse&&element.data(DATA_FORCEDOPEN)){priorityList=$.fn.powerTip.smartPlacementLists[options.placement];$.each(priorityList,function(idx,pos){var collisions=getViewportCollisions(placeTooltip(element,pos),tipElement.outerWidth(),tipElement.outerHeight());finalPlacement=pos;return collisions!==Collision.none})}else{placeTooltip(element,options.placement);finalPlacement=options.placement}tipElement.removeClass("w nw sw e ne se n s w se-alt sw-alt ne-alt nw-alt");tipElement.addClass(finalPlacement)}function placeTooltip(element,placement){var iterationCount=0,tipWidth,tipHeight,coords=new CSSCoordinates;coords.set("top",0);coords.set("left",0);tipElement.css(coords);do{tipWidth=tipElement.outerWidth();tipHeight=tipElement.outerHeight();coords=placementCalculator.compute(element,placement,tipWidth,tipHeight,options.offset);tipElement.css(coords)}while(++iterationCount<=5&&(tipWidth!==tipElement.outerWidth()||tipHeight!==tipElement.outerHeight()));return coords}function closeDesyncedTip(){var isDesynced=false,hasDesyncableCloseEvent=$.grep(["mouseleave","mouseout","blur","focusout"],function(eventType){return $.inArray(eventType,options.closeEvents)!==-1}).length>0;if(session.isTipOpen&&!session.isClosing&&!session.delayInProgress&&hasDesyncableCloseEvent){if(session.activeHover.data(DATA_HASACTIVEHOVER)===false||session.activeHover.is(":disabled")){isDesynced=true}else if(!isMouseOver(session.activeHover)&&!session.activeHover.is(":focus")&&!session.activeHover.data(DATA_FORCEDOPEN)){if(tipElement.data(DATA_MOUSEONTOTIP)){if(!isMouseOver(tipElement)){isDesynced=true}}else{isDesynced=true}}if(isDesynced){hideTip(session.activeHover)}}}this.showTip=beginShowTip;this.hideTip=hideTip;this.resetPosition=positionTipOnElement}function isSvgElement(element){return Boolean(window.SVGElement&&element[0]instanceof SVGElement)}function isMouseEvent(event){return Boolean(event&&$.inArray(event.type,MOUSE_EVENTS)>-1&&typeof event.pageX==="number")}function initTracking(){if(!session.mouseTrackingActive){session.mouseTrackingActive=true;getViewportDimensions();$(getViewportDimensions);$document.on("mousemove"+EVENT_NAMESPACE,trackMouse);$window.on("resize"+EVENT_NAMESPACE,trackResize);$window.on("scroll"+EVENT_NAMESPACE,trackScroll)}}function getViewportDimensions(){session.scrollLeft=$window.scrollLeft();session.scrollTop=$window.scrollTop();session.windowWidth=$window.width();session.windowHeight=$window.height()}function trackResize(){session.windowWidth=$window.width();session.windowHeight=$window.height()}function trackScroll(){var x=$window.scrollLeft(),y=$window.scrollTop();if(x!==session.scrollLeft){session.currentX+=x-session.scrollLeft;session.scrollLeft=x}if(y!==session.scrollTop){session.currentY+=y-session.scrollTop;session.scrollTop=y}}function trackMouse(event){session.currentX=event.pageX;session.currentY=event.pageY}function isMouseOver(element){var elementPosition=element.offset(),elementBox=element[0].getBoundingClientRect(),elementWidth=elementBox.right-elementBox.left,elementHeight=elementBox.bottom-elementBox.top;return session.currentX>=elementPosition.left&&session.currentX<=elementPosition.left+elementWidth&&session.currentY>=elementPosition.top&&session.currentY<=elementPosition.top+elementHeight}function getTooltipContent(element){var tipText=element.data(DATA_POWERTIP),tipObject=element.data(DATA_POWERTIPJQ),tipTarget=element.data(DATA_POWERTIPTARGET),targetElement,content;if(tipText){if($.isFunction(tipText)){tipText=tipText.call(element[0])}content=tipText}else if(tipObject){if($.isFunction(tipObject)){tipObject=tipObject.call(element[0])}if(tipObject.length>0){content=tipObject.clone(true,true)}}else if(tipTarget){targetElement=$("#"+tipTarget);if(targetElement.length>0){content=targetElement.html()}}return content}function getViewportCollisions(coords,elementWidth,elementHeight){var viewportTop=session.scrollTop,viewportLeft=session.scrollLeft,viewportBottom=viewportTop+session.windowHeight,viewportRight=viewportLeft+session.windowWidth,collisions=Collision.none;if(coords.topviewportBottom||Math.abs(coords.bottom-session.windowHeight)>viewportBottom){collisions|=Collision.bottom}if(coords.leftviewportRight){collisions|=Collision.left}if(coords.left+elementWidth>viewportRight||coords.right1)){a.preventDefault();var c=a.originalEvent.changedTouches[0],d=document.createEvent("MouseEvents");d.initMouseEvent(b,!0,!0,window,1,c.screenX,c.screenY,c.clientX,c.clientY,!1,!1,!1,!1,0,null),a.target.dispatchEvent(d)}}if(a.support.touch="ontouchend"in document,a.support.touch){var e,b=a.ui.mouse.prototype,c=b._mouseInit,d=b._mouseDestroy;b._touchStart=function(a){var b=this;!e&&b._mouseCapture(a.originalEvent.changedTouches[0])&&(e=!0,b._touchMoved=!1,f(a,"mouseover"),f(a,"mousemove"),f(a,"mousedown"))},b._touchMove=function(a){e&&(this._touchMoved=!0,f(a,"mousemove"))},b._touchEnd=function(a){e&&(f(a,"mouseup"),f(a,"mouseout"),this._touchMoved||f(a,"click"),e=!1)},b._mouseInit=function(){var b=this;b.element.bind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),c.call(b)},b._mouseDestroy=function(){var b=this;b.element.unbind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),d.call(b)}}}(jQuery);/*! SmartMenus jQuery Plugin - v1.1.0 - September 17, 2017 + * http://www.smartmenus.org/ + * Copyright Vasil Dinkov, Vadikom Web Ltd. http://vadikom.com; Licensed MIT */(function(t){"function"==typeof define&&define.amd?define(["jquery"],t):"object"==typeof module&&"object"==typeof module.exports?module.exports=t(require("jquery")):t(jQuery)})(function($){function initMouseDetection(t){var e=".smartmenus_mouse";if(mouseDetectionEnabled||t)mouseDetectionEnabled&&t&&($(document).off(e),mouseDetectionEnabled=!1);else{var i=!0,s=null,o={mousemove:function(t){var e={x:t.pageX,y:t.pageY,timeStamp:(new Date).getTime()};if(s){var o=Math.abs(s.x-e.x),a=Math.abs(s.y-e.y);if((o>0||a>0)&&2>=o&&2>=a&&300>=e.timeStamp-s.timeStamp&&(mouse=!0,i)){var n=$(t.target).closest("a");n.is("a")&&$.each(menuTrees,function(){return $.contains(this.$root[0],n[0])?(this.itemEnter({currentTarget:n[0]}),!1):void 0}),i=!1}}s=e}};o[touchEvents?"touchstart":"pointerover pointermove pointerout MSPointerOver MSPointerMove MSPointerOut"]=function(t){isTouchEvent(t.originalEvent)&&(mouse=!1)},$(document).on(getEventsNS(o,e)),mouseDetectionEnabled=!0}}function isTouchEvent(t){return!/^(4|mouse)$/.test(t.pointerType)}function getEventsNS(t,e){e||(e="");var i={};for(var s in t)i[s.split(" ").join(e+" ")+e]=t[s];return i}var menuTrees=[],mouse=!1,touchEvents="ontouchstart"in window,mouseDetectionEnabled=!1,requestAnimationFrame=window.requestAnimationFrame||function(t){return setTimeout(t,1e3/60)},cancelAnimationFrame=window.cancelAnimationFrame||function(t){clearTimeout(t)},canAnimate=!!$.fn.animate;return $.SmartMenus=function(t,e){this.$root=$(t),this.opts=e,this.rootId="",this.accessIdPrefix="",this.$subArrow=null,this.activatedItems=[],this.visibleSubMenus=[],this.showTimeout=0,this.hideTimeout=0,this.scrollTimeout=0,this.clickActivated=!1,this.focusActivated=!1,this.zIndexInc=0,this.idInc=0,this.$firstLink=null,this.$firstSub=null,this.disabled=!1,this.$disableOverlay=null,this.$touchScrollingSub=null,this.cssTransforms3d="perspective"in t.style||"webkitPerspective"in t.style,this.wasCollapsible=!1,this.init()},$.extend($.SmartMenus,{hideAll:function(){$.each(menuTrees,function(){this.menuHideAll()})},destroy:function(){for(;menuTrees.length;)menuTrees[0].destroy();initMouseDetection(!0)},prototype:{init:function(t){var e=this;if(!t){menuTrees.push(this),this.rootId=((new Date).getTime()+Math.random()+"").replace(/\D/g,""),this.accessIdPrefix="sm-"+this.rootId+"-",this.$root.hasClass("sm-rtl")&&(this.opts.rightToLeftSubMenus=!0);var i=".smartmenus";this.$root.data("smartmenus",this).attr("data-smartmenus-id",this.rootId).dataSM("level",1).on(getEventsNS({"mouseover focusin":$.proxy(this.rootOver,this),"mouseout focusout":$.proxy(this.rootOut,this),keydown:$.proxy(this.rootKeyDown,this)},i)).on(getEventsNS({mouseenter:$.proxy(this.itemEnter,this),mouseleave:$.proxy(this.itemLeave,this),mousedown:$.proxy(this.itemDown,this),focus:$.proxy(this.itemFocus,this),blur:$.proxy(this.itemBlur,this),click:$.proxy(this.itemClick,this)},i),"a"),i+=this.rootId,this.opts.hideOnClick&&$(document).on(getEventsNS({touchstart:$.proxy(this.docTouchStart,this),touchmove:$.proxy(this.docTouchMove,this),touchend:$.proxy(this.docTouchEnd,this),click:$.proxy(this.docClick,this)},i)),$(window).on(getEventsNS({"resize orientationchange":$.proxy(this.winResize,this)},i)),this.opts.subIndicators&&(this.$subArrow=$("").addClass("sub-arrow"),this.opts.subIndicatorsText&&this.$subArrow.html(this.opts.subIndicatorsText)),initMouseDetection()}if(this.$firstSub=this.$root.find("ul").each(function(){e.menuInit($(this))}).eq(0),this.$firstLink=this.$root.find("a").eq(0),this.opts.markCurrentItem){var s=/(index|default)\.[^#\?\/]*/i,o=/#.*/,a=window.location.href.replace(s,""),n=a.replace(o,"");this.$root.find("a").each(function(){var t=this.href.replace(s,""),i=$(this);(t==a||t==n)&&(i.addClass("current"),e.opts.markCurrentTree&&i.parentsUntil("[data-smartmenus-id]","ul").each(function(){$(this).dataSM("parent-a").addClass("current")}))})}this.wasCollapsible=this.isCollapsible()},destroy:function(t){if(!t){var e=".smartmenus";this.$root.removeData("smartmenus").removeAttr("data-smartmenus-id").removeDataSM("level").off(e),e+=this.rootId,$(document).off(e),$(window).off(e),this.opts.subIndicators&&(this.$subArrow=null)}this.menuHideAll();var i=this;this.$root.find("ul").each(function(){var t=$(this);t.dataSM("scroll-arrows")&&t.dataSM("scroll-arrows").remove(),t.dataSM("shown-before")&&((i.opts.subMenusMinWidth||i.opts.subMenusMaxWidth)&&t.css({width:"",minWidth:"",maxWidth:""}).removeClass("sm-nowrap"),t.dataSM("scroll-arrows")&&t.dataSM("scroll-arrows").remove(),t.css({zIndex:"",top:"",left:"",marginLeft:"",marginTop:"",display:""})),0==(t.attr("id")||"").indexOf(i.accessIdPrefix)&&t.removeAttr("id")}).removeDataSM("in-mega").removeDataSM("shown-before").removeDataSM("scroll-arrows").removeDataSM("parent-a").removeDataSM("level").removeDataSM("beforefirstshowfired").removeAttr("role").removeAttr("aria-hidden").removeAttr("aria-labelledby").removeAttr("aria-expanded"),this.$root.find("a.has-submenu").each(function(){var t=$(this);0==t.attr("id").indexOf(i.accessIdPrefix)&&t.removeAttr("id")}).removeClass("has-submenu").removeDataSM("sub").removeAttr("aria-haspopup").removeAttr("aria-controls").removeAttr("aria-expanded").closest("li").removeDataSM("sub"),this.opts.subIndicators&&this.$root.find("span.sub-arrow").remove(),this.opts.markCurrentItem&&this.$root.find("a.current").removeClass("current"),t||(this.$root=null,this.$firstLink=null,this.$firstSub=null,this.$disableOverlay&&(this.$disableOverlay.remove(),this.$disableOverlay=null),menuTrees.splice($.inArray(this,menuTrees),1))},disable:function(t){if(!this.disabled){if(this.menuHideAll(),!t&&!this.opts.isPopup&&this.$root.is(":visible")){var e=this.$root.offset();this.$disableOverlay=$('
').css({position:"absolute",top:e.top,left:e.left,width:this.$root.outerWidth(),height:this.$root.outerHeight(),zIndex:this.getStartZIndex(!0),opacity:0}).appendTo(document.body)}this.disabled=!0}},docClick:function(t){return this.$touchScrollingSub?(this.$touchScrollingSub=null,void 0):((this.visibleSubMenus.length&&!$.contains(this.$root[0],t.target)||$(t.target).closest("a").length)&&this.menuHideAll(),void 0)},docTouchEnd:function(){if(this.lastTouch){if(!(!this.visibleSubMenus.length||void 0!==this.lastTouch.x2&&this.lastTouch.x1!=this.lastTouch.x2||void 0!==this.lastTouch.y2&&this.lastTouch.y1!=this.lastTouch.y2||this.lastTouch.target&&$.contains(this.$root[0],this.lastTouch.target))){this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0);var t=this;this.hideTimeout=setTimeout(function(){t.menuHideAll()},350)}this.lastTouch=null}},docTouchMove:function(t){if(this.lastTouch){var e=t.originalEvent.touches[0];this.lastTouch.x2=e.pageX,this.lastTouch.y2=e.pageY}},docTouchStart:function(t){var e=t.originalEvent.touches[0];this.lastTouch={x1:e.pageX,y1:e.pageY,target:e.target}},enable:function(){this.disabled&&(this.$disableOverlay&&(this.$disableOverlay.remove(),this.$disableOverlay=null),this.disabled=!1)},getClosestMenu:function(t){for(var e=$(t).closest("ul");e.dataSM("in-mega");)e=e.parent().closest("ul");return e[0]||null},getHeight:function(t){return this.getOffset(t,!0)},getOffset:function(t,e){var i;"none"==t.css("display")&&(i={position:t[0].style.position,visibility:t[0].style.visibility},t.css({position:"absolute",visibility:"hidden"}).show());var s=t[0].getBoundingClientRect&&t[0].getBoundingClientRect(),o=s&&(e?s.height||s.bottom-s.top:s.width||s.right-s.left);return o||0===o||(o=e?t[0].offsetHeight:t[0].offsetWidth),i&&t.hide().css(i),o},getStartZIndex:function(t){var e=parseInt(this[t?"$root":"$firstSub"].css("z-index"));return!t&&isNaN(e)&&(e=parseInt(this.$root.css("z-index"))),isNaN(e)?1:e},getTouchPoint:function(t){return t.touches&&t.touches[0]||t.changedTouches&&t.changedTouches[0]||t},getViewport:function(t){var e=t?"Height":"Width",i=document.documentElement["client"+e],s=window["inner"+e];return s&&(i=Math.min(i,s)),i},getViewportHeight:function(){return this.getViewport(!0)},getViewportWidth:function(){return this.getViewport()},getWidth:function(t){return this.getOffset(t)},handleEvents:function(){return!this.disabled&&this.isCSSOn()},handleItemEvents:function(t){return this.handleEvents()&&!this.isLinkInMegaMenu(t)},isCollapsible:function(){return"static"==this.$firstSub.css("position")},isCSSOn:function(){return"inline"!=this.$firstLink.css("display")},isFixed:function(){var t="fixed"==this.$root.css("position");return t||this.$root.parentsUntil("body").each(function(){return"fixed"==$(this).css("position")?(t=!0,!1):void 0}),t},isLinkInMegaMenu:function(t){return $(this.getClosestMenu(t[0])).hasClass("mega-menu")},isTouchMode:function(){return!mouse||this.opts.noMouseOver||this.isCollapsible()},itemActivate:function(t,e){var i=t.closest("ul"),s=i.dataSM("level");if(s>1&&(!this.activatedItems[s-2]||this.activatedItems[s-2][0]!=i.dataSM("parent-a")[0])){var o=this;$(i.parentsUntil("[data-smartmenus-id]","ul").get().reverse()).add(i).each(function(){o.itemActivate($(this).dataSM("parent-a"))})}if((!this.isCollapsible()||e)&&this.menuHideSubMenus(this.activatedItems[s-1]&&this.activatedItems[s-1][0]==t[0]?s:s-1),this.activatedItems[s-1]=t,this.$root.triggerHandler("activate.smapi",t[0])!==!1){var a=t.dataSM("sub");a&&(this.isTouchMode()||!this.opts.showOnClick||this.clickActivated)&&this.menuShow(a)}},itemBlur:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&this.$root.triggerHandler("blur.smapi",e[0])},itemClick:function(t){var e=$(t.currentTarget);if(this.handleItemEvents(e)){if(this.$touchScrollingSub&&this.$touchScrollingSub[0]==e.closest("ul")[0])return this.$touchScrollingSub=null,t.stopPropagation(),!1;if(this.$root.triggerHandler("click.smapi",e[0])===!1)return!1;var i=$(t.target).is(".sub-arrow"),s=e.dataSM("sub"),o=s?2==s.dataSM("level"):!1,a=this.isCollapsible(),n=/toggle$/.test(this.opts.collapsibleBehavior),r=/link$/.test(this.opts.collapsibleBehavior),h=/^accordion/.test(this.opts.collapsibleBehavior);if(s&&!s.is(":visible")){if((!r||!a||i)&&(this.opts.showOnClick&&o&&(this.clickActivated=!0),this.itemActivate(e,h),s.is(":visible")))return this.focusActivated=!0,!1}else if(a&&(n||i))return this.itemActivate(e,h),this.menuHide(s),n&&(this.focusActivated=!1),!1;return this.opts.showOnClick&&o||e.hasClass("disabled")||this.$root.triggerHandler("select.smapi",e[0])===!1?!1:void 0}},itemDown:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&e.dataSM("mousedown",!0)},itemEnter:function(t){var e=$(t.currentTarget);if(this.handleItemEvents(e)){if(!this.isTouchMode()){this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0);var i=this;this.showTimeout=setTimeout(function(){i.itemActivate(e)},this.opts.showOnClick&&1==e.closest("ul").dataSM("level")?1:this.opts.showTimeout)}this.$root.triggerHandler("mouseenter.smapi",e[0])}},itemFocus:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&(!this.focusActivated||this.isTouchMode()&&e.dataSM("mousedown")||this.activatedItems.length&&this.activatedItems[this.activatedItems.length-1][0]==e[0]||this.itemActivate(e,!0),this.$root.triggerHandler("focus.smapi",e[0]))},itemLeave:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&(this.isTouchMode()||(e[0].blur(),this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0)),e.removeDataSM("mousedown"),this.$root.triggerHandler("mouseleave.smapi",e[0]))},menuHide:function(t){if(this.$root.triggerHandler("beforehide.smapi",t[0])!==!1&&(canAnimate&&t.stop(!0,!0),"none"!=t.css("display"))){var e=function(){t.css("z-index","")};this.isCollapsible()?canAnimate&&this.opts.collapsibleHideFunction?this.opts.collapsibleHideFunction.call(this,t,e):t.hide(this.opts.collapsibleHideDuration,e):canAnimate&&this.opts.hideFunction?this.opts.hideFunction.call(this,t,e):t.hide(this.opts.hideDuration,e),t.dataSM("scroll")&&(this.menuScrollStop(t),t.css({"touch-action":"","-ms-touch-action":"","-webkit-transform":"",transform:""}).off(".smartmenus_scroll").removeDataSM("scroll").dataSM("scroll-arrows").hide()),t.dataSM("parent-a").removeClass("highlighted").attr("aria-expanded","false"),t.attr({"aria-expanded":"false","aria-hidden":"true"});var i=t.dataSM("level");this.activatedItems.splice(i-1,1),this.visibleSubMenus.splice($.inArray(t,this.visibleSubMenus),1),this.$root.triggerHandler("hide.smapi",t[0])}},menuHideAll:function(){this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0);for(var t=this.opts.isPopup?1:0,e=this.visibleSubMenus.length-1;e>=t;e--)this.menuHide(this.visibleSubMenus[e]);this.opts.isPopup&&(canAnimate&&this.$root.stop(!0,!0),this.$root.is(":visible")&&(canAnimate&&this.opts.hideFunction?this.opts.hideFunction.call(this,this.$root):this.$root.hide(this.opts.hideDuration))),this.activatedItems=[],this.visibleSubMenus=[],this.clickActivated=!1,this.focusActivated=!1,this.zIndexInc=0,this.$root.triggerHandler("hideAll.smapi")},menuHideSubMenus:function(t){for(var e=this.activatedItems.length-1;e>=t;e--){var i=this.activatedItems[e].dataSM("sub");i&&this.menuHide(i)}},menuInit:function(t){if(!t.dataSM("in-mega")){t.hasClass("mega-menu")&&t.find("ul").dataSM("in-mega",!0);for(var e=2,i=t[0];(i=i.parentNode.parentNode)!=this.$root[0];)e++;var s=t.prevAll("a").eq(-1);s.length||(s=t.prevAll().find("a").eq(-1)),s.addClass("has-submenu").dataSM("sub",t),t.dataSM("parent-a",s).dataSM("level",e).parent().dataSM("sub",t);var o=s.attr("id")||this.accessIdPrefix+ ++this.idInc,a=t.attr("id")||this.accessIdPrefix+ ++this.idInc;s.attr({id:o,"aria-haspopup":"true","aria-controls":a,"aria-expanded":"false"}),t.attr({id:a,role:"group","aria-hidden":"true","aria-labelledby":o,"aria-expanded":"false"}),this.opts.subIndicators&&s[this.opts.subIndicatorsPos](this.$subArrow.clone())}},menuPosition:function(t){var e,i,s=t.dataSM("parent-a"),o=s.closest("li"),a=o.parent(),n=t.dataSM("level"),r=this.getWidth(t),h=this.getHeight(t),u=s.offset(),l=u.left,c=u.top,d=this.getWidth(s),m=this.getHeight(s),p=$(window),f=p.scrollLeft(),v=p.scrollTop(),b=this.getViewportWidth(),S=this.getViewportHeight(),g=a.parent().is("[data-sm-horizontal-sub]")||2==n&&!a.hasClass("sm-vertical"),M=this.opts.rightToLeftSubMenus&&!o.is("[data-sm-reverse]")||!this.opts.rightToLeftSubMenus&&o.is("[data-sm-reverse]"),w=2==n?this.opts.mainMenuSubOffsetX:this.opts.subMenusSubOffsetX,T=2==n?this.opts.mainMenuSubOffsetY:this.opts.subMenusSubOffsetY;if(g?(e=M?d-r-w:w,i=this.opts.bottomToTopSubMenus?-h-T:m+T):(e=M?w-r:d-w,i=this.opts.bottomToTopSubMenus?m-T-h:T),this.opts.keepInViewport){var y=l+e,I=c+i;if(M&&f>y?e=g?f-y+e:d-w:!M&&y+r>f+b&&(e=g?f+b-r-y+e:w-r),g||(S>h&&I+h>v+S?i+=v+S-h-I:(h>=S||v>I)&&(i+=v-I)),g&&(I+h>v+S+.49||v>I)||!g&&h>S+.49){var x=this;t.dataSM("scroll-arrows")||t.dataSM("scroll-arrows",$([$('')[0],$('')[0]]).on({mouseenter:function(){t.dataSM("scroll").up=$(this).hasClass("scroll-up"),x.menuScroll(t)},mouseleave:function(e){x.menuScrollStop(t),x.menuScrollOut(t,e)},"mousewheel DOMMouseScroll":function(t){t.preventDefault()}}).insertAfter(t));var A=".smartmenus_scroll";if(t.dataSM("scroll",{y:this.cssTransforms3d?0:i-m,step:1,itemH:m,subH:h,arrowDownH:this.getHeight(t.dataSM("scroll-arrows").eq(1))}).on(getEventsNS({mouseover:function(e){x.menuScrollOver(t,e)},mouseout:function(e){x.menuScrollOut(t,e)},"mousewheel DOMMouseScroll":function(e){x.menuScrollMousewheel(t,e)}},A)).dataSM("scroll-arrows").css({top:"auto",left:"0",marginLeft:e+(parseInt(t.css("border-left-width"))||0),width:r-(parseInt(t.css("border-left-width"))||0)-(parseInt(t.css("border-right-width"))||0),zIndex:t.css("z-index")}).eq(g&&this.opts.bottomToTopSubMenus?0:1).show(),this.isFixed()){var C={};C[touchEvents?"touchstart touchmove touchend":"pointerdown pointermove pointerup MSPointerDown MSPointerMove MSPointerUp"]=function(e){x.menuScrollTouch(t,e)},t.css({"touch-action":"none","-ms-touch-action":"none"}).on(getEventsNS(C,A))}}}t.css({top:"auto",left:"0",marginLeft:e,marginTop:i-m})},menuScroll:function(t,e,i){var s,o=t.dataSM("scroll"),a=t.dataSM("scroll-arrows"),n=o.up?o.upEnd:o.downEnd;if(!e&&o.momentum){if(o.momentum*=.92,s=o.momentum,.5>s)return this.menuScrollStop(t),void 0}else s=i||(e||!this.opts.scrollAccelerate?this.opts.scrollStep:Math.floor(o.step));var r=t.dataSM("level");if(this.activatedItems[r-1]&&this.activatedItems[r-1].dataSM("sub")&&this.activatedItems[r-1].dataSM("sub").is(":visible")&&this.menuHideSubMenus(r-1),o.y=o.up&&o.y>=n||!o.up&&n>=o.y?o.y:Math.abs(n-o.y)>s?o.y+(o.up?s:-s):n,t.css(this.cssTransforms3d?{"-webkit-transform":"translate3d(0, "+o.y+"px, 0)",transform:"translate3d(0, "+o.y+"px, 0)"}:{marginTop:o.y}),mouse&&(o.up&&o.y>o.downEnd||!o.up&&o.y0;t.dataSM("scroll-arrows").eq(i?0:1).is(":visible")&&(t.dataSM("scroll").up=i,this.menuScroll(t,!0))}e.preventDefault()},menuScrollOut:function(t,e){mouse&&(/^scroll-(up|down)/.test((e.relatedTarget||"").className)||(t[0]==e.relatedTarget||$.contains(t[0],e.relatedTarget))&&this.getClosestMenu(e.relatedTarget)==t[0]||t.dataSM("scroll-arrows").css("visibility","hidden"))},menuScrollOver:function(t,e){if(mouse&&!/^scroll-(up|down)/.test(e.target.className)&&this.getClosestMenu(e.target)==t[0]){this.menuScrollRefreshData(t);var i=t.dataSM("scroll"),s=$(window).scrollTop()-t.dataSM("parent-a").offset().top-i.itemH;t.dataSM("scroll-arrows").eq(0).css("margin-top",s).end().eq(1).css("margin-top",s+this.getViewportHeight()-i.arrowDownH).end().css("visibility","visible")}},menuScrollRefreshData:function(t){var e=t.dataSM("scroll"),i=$(window).scrollTop()-t.dataSM("parent-a").offset().top-e.itemH;this.cssTransforms3d&&(i=-(parseFloat(t.css("margin-top"))-i)),$.extend(e,{upEnd:i,downEnd:i+this.getViewportHeight()-e.subH})},menuScrollStop:function(t){return this.scrollTimeout?(cancelAnimationFrame(this.scrollTimeout),this.scrollTimeout=0,t.dataSM("scroll").step=1,!0):void 0},menuScrollTouch:function(t,e){if(e=e.originalEvent,isTouchEvent(e)){var i=this.getTouchPoint(e);if(this.getClosestMenu(i.target)==t[0]){var s=t.dataSM("scroll");if(/(start|down)$/i.test(e.type))this.menuScrollStop(t)?(e.preventDefault(),this.$touchScrollingSub=t):this.$touchScrollingSub=null,this.menuScrollRefreshData(t),$.extend(s,{touchStartY:i.pageY,touchStartTime:e.timeStamp});else if(/move$/i.test(e.type)){var o=void 0!==s.touchY?s.touchY:s.touchStartY;if(void 0!==o&&o!=i.pageY){this.$touchScrollingSub=t;var a=i.pageY>o;void 0!==s.up&&s.up!=a&&$.extend(s,{touchStartY:i.pageY,touchStartTime:e.timeStamp}),$.extend(s,{up:a,touchY:i.pageY}),this.menuScroll(t,!0,Math.abs(i.pageY-o))}e.preventDefault()}else void 0!==s.touchY&&((s.momentum=15*Math.pow(Math.abs(i.pageY-s.touchStartY)/(e.timeStamp-s.touchStartTime),2))&&(this.menuScrollStop(t),this.menuScroll(t),e.preventDefault()),delete s.touchY)}}},menuShow:function(t){if((t.dataSM("beforefirstshowfired")||(t.dataSM("beforefirstshowfired",!0),this.$root.triggerHandler("beforefirstshow.smapi",t[0])!==!1))&&this.$root.triggerHandler("beforeshow.smapi",t[0])!==!1&&(t.dataSM("shown-before",!0),canAnimate&&t.stop(!0,!0),!t.is(":visible"))){var e=t.dataSM("parent-a"),i=this.isCollapsible();if((this.opts.keepHighlighted||i)&&e.addClass("highlighted"),i)t.removeClass("sm-nowrap").css({zIndex:"",width:"auto",minWidth:"",maxWidth:"",top:"",left:"",marginLeft:"",marginTop:""});else{if(t.css("z-index",this.zIndexInc=(this.zIndexInc||this.getStartZIndex())+1),(this.opts.subMenusMinWidth||this.opts.subMenusMaxWidth)&&(t.css({width:"auto",minWidth:"",maxWidth:""}).addClass("sm-nowrap"),this.opts.subMenusMinWidth&&t.css("min-width",this.opts.subMenusMinWidth),this.opts.subMenusMaxWidth)){var s=this.getWidth(t);t.css("max-width",this.opts.subMenusMaxWidth),s>this.getWidth(t)&&t.removeClass("sm-nowrap").css("width",this.opts.subMenusMaxWidth)}this.menuPosition(t)}var o=function(){t.css("overflow","")};i?canAnimate&&this.opts.collapsibleShowFunction?this.opts.collapsibleShowFunction.call(this,t,o):t.show(this.opts.collapsibleShowDuration,o):canAnimate&&this.opts.showFunction?this.opts.showFunction.call(this,t,o):t.show(this.opts.showDuration,o),e.attr("aria-expanded","true"),t.attr({"aria-expanded":"true","aria-hidden":"false"}),this.visibleSubMenus.push(t),this.$root.triggerHandler("show.smapi",t[0])}},popupHide:function(t){this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0);var e=this;this.hideTimeout=setTimeout(function(){e.menuHideAll()},t?1:this.opts.hideTimeout)},popupShow:function(t,e){if(!this.opts.isPopup)return alert('SmartMenus jQuery Error:\n\nIf you want to show this menu via the "popupShow" method, set the isPopup:true option.'),void 0;if(this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0),this.$root.dataSM("shown-before",!0),canAnimate&&this.$root.stop(!0,!0),!this.$root.is(":visible")){this.$root.css({left:t,top:e});var i=this,s=function(){i.$root.css("overflow","")};canAnimate&&this.opts.showFunction?this.opts.showFunction.call(this,this.$root,s):this.$root.show(this.opts.showDuration,s),this.visibleSubMenus[0]=this.$root}},refresh:function(){this.destroy(!0),this.init(!0)},rootKeyDown:function(t){if(this.handleEvents())switch(t.keyCode){case 27:var e=this.activatedItems[0];if(e){this.menuHideAll(),e[0].focus();var i=e.dataSM("sub");i&&this.menuHide(i)}break;case 32:var s=$(t.target);if(s.is("a")&&this.handleItemEvents(s)){var i=s.dataSM("sub");i&&!i.is(":visible")&&(this.itemClick({currentTarget:t.target}),t.preventDefault())}}},rootOut:function(t){if(this.handleEvents()&&!this.isTouchMode()&&t.target!=this.$root[0]&&(this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0),!this.opts.showOnClick||!this.opts.hideOnClick)){var e=this;this.hideTimeout=setTimeout(function(){e.menuHideAll()},this.opts.hideTimeout)}},rootOver:function(t){this.handleEvents()&&!this.isTouchMode()&&t.target!=this.$root[0]&&this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0)},winResize:function(t){if(this.handleEvents()){if(!("onorientationchange"in window)||"orientationchange"==t.type){var e=this.isCollapsible();this.wasCollapsible&&e||(this.activatedItems.length&&this.activatedItems[this.activatedItems.length-1][0].blur(),this.menuHideAll()),this.wasCollapsible=e}}else if(this.$disableOverlay){var i=this.$root.offset();this.$disableOverlay.css({top:i.top,left:i.left,width:this.$root.outerWidth(),height:this.$root.outerHeight()})}}}}),$.fn.dataSM=function(t,e){return e?this.data(t+"_smartmenus",e):this.data(t+"_smartmenus")},$.fn.removeDataSM=function(t){return this.removeData(t+"_smartmenus")},$.fn.smartmenus=function(options){if("string"==typeof options){var args=arguments,method=options;return Array.prototype.shift.call(args),this.each(function(){var t=$(this).data("smartmenus");t&&t[method]&&t[method].apply(t,args)})}return this.each(function(){var dataOpts=$(this).data("sm-options")||null;if(dataOpts)try{dataOpts=eval("("+dataOpts+")")}catch(e){dataOpts=null,alert('ERROR\n\nSmartMenus jQuery init:\nInvalid "data-sm-options" attribute value syntax.')}new $.SmartMenus(this,$.extend({},$.fn.smartmenus.defaults,options,dataOpts))})},$.fn.smartmenus.defaults={isPopup:!1,mainMenuSubOffsetX:0,mainMenuSubOffsetY:0,subMenusSubOffsetX:0,subMenusSubOffsetY:0,subMenusMinWidth:"10em",subMenusMaxWidth:"20em",subIndicators:!0,subIndicatorsPos:"append",subIndicatorsText:"",scrollStep:30,scrollAccelerate:!0,showTimeout:250,hideTimeout:500,showDuration:0,showFunction:null,hideDuration:0,hideFunction:function(t,e){t.fadeOut(200,e)},collapsibleShowDuration:0,collapsibleShowFunction:function(t,e){t.slideDown(200,e)},collapsibleHideDuration:0,collapsibleHideFunction:function(t,e){t.slideUp(200,e)},showOnClick:!1,hideOnClick:!0,noMouseOver:!1,keepInViewport:!0,keepHighlighted:!0,markCurrentItem:!1,markCurrentTree:!0,rightToLeftSubMenus:!1,bottomToTopSubMenus:!1,collapsibleBehavior:"default"},$}); \ No newline at end of file diff --git a/Space-Invaders/sfml/doc/html/mainpage_8hpp_source.html b/Space-Invaders/sfml/doc/html/mainpage_8hpp_source.html new file mode 100644 index 000000000..8aefb64c1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/mainpage_8hpp_source.html @@ -0,0 +1,104 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
mainpage.hpp
+
+
+
1
+
+
+ + + diff --git a/Space-Invaders/sfml/doc/html/menudata.js b/Space-Invaders/sfml/doc/html/menudata.js new file mode 100644 index 000000000..9a55d96a8 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/menudata.js @@ -0,0 +1,150 @@ +/* + @licstart The following is the entire license notice for the JavaScript code in this file. + + The MIT License (MIT) + + Copyright (C) 1997-2020 by Dimitri van Heesch + + Permission is hereby granted, free of charge, to any person obtaining a copy of this software + and associated documentation files (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, publish, distribute, + sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all copies or + substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + @licend The above is the entire license notice for the JavaScript code in this file +*/ +var menudata={children:[ +{text:"Main Page",url:"index.html"}, +{text:"Related Pages",url:"pages.html"}, +{text:"Modules",url:"modules.html"}, +{text:"Namespaces",url:"namespaces.html",children:[ +{text:"Namespace List",url:"namespaces.html"}, +{text:"Namespace Members",url:"namespacemembers.html",children:[ +{text:"All",url:"namespacemembers.html"}, +{text:"Typedefs",url:"namespacemembers_type.html"}]}]}, +{text:"Classes",url:"annotated.html",children:[ +{text:"Class List",url:"annotated.html"}, +{text:"Class Index",url:"classes.html"}, +{text:"Class Hierarchy",url:"hierarchy.html"}, +{text:"Class Members",url:"functions.html",children:[ +{text:"All",url:"functions.html",children:[ +{text:"a",url:"functions.html#index_a"}, +{text:"b",url:"functions_b.html#index_b"}, +{text:"c",url:"functions_c.html#index_c"}, +{text:"d",url:"functions_d.html#index_d"}, +{text:"e",url:"functions_e.html#index_e"}, +{text:"f",url:"functions_f.html#index_f"}, +{text:"g",url:"functions_g.html#index_g"}, +{text:"h",url:"functions_h.html#index_h"}, +{text:"i",url:"functions_i.html#index_i"}, +{text:"j",url:"functions_j.html#index_j"}, +{text:"k",url:"functions_k.html#index_k"}, +{text:"l",url:"functions_l.html#index_l"}, +{text:"m",url:"functions_m.html#index_m"}, +{text:"n",url:"functions_n.html#index_n"}, +{text:"o",url:"functions_o.html#index_o"}, +{text:"p",url:"functions_p.html#index_p"}, +{text:"q",url:"functions_q.html#index_q"}, +{text:"r",url:"functions_r.html#index_r"}, +{text:"s",url:"functions_s.html#index_s"}, +{text:"t",url:"functions_t.html#index_t"}, +{text:"u",url:"functions_u.html#index_u"}, +{text:"v",url:"functions_v.html#index_v"}, +{text:"w",url:"functions_w.html#index_w"}, +{text:"x",url:"functions_x.html#index_x"}, +{text:"y",url:"functions_y.html#index_y"}, +{text:"z",url:"functions_z.html#index_z"}, +{text:"~",url:"functions_~.html#index__7E"}]}, +{text:"Functions",url:"functions_func.html",children:[ +{text:"a",url:"functions_func.html#index_a"}, +{text:"b",url:"functions_func_b.html#index_b"}, +{text:"c",url:"functions_func_c.html#index_c"}, +{text:"d",url:"functions_func_d.html#index_d"}, +{text:"e",url:"functions_func_e.html#index_e"}, +{text:"f",url:"functions_func_f.html#index_f"}, +{text:"g",url:"functions_func_g.html#index_g"}, +{text:"h",url:"functions_func_h.html#index_h"}, +{text:"i",url:"functions_func_i.html#index_i"}, +{text:"k",url:"functions_func_k.html#index_k"}, +{text:"l",url:"functions_func_l.html#index_l"}, +{text:"m",url:"functions_func_m.html#index_m"}, +{text:"n",url:"functions_func_n.html#index_n"}, +{text:"o",url:"functions_func_o.html#index_o"}, +{text:"p",url:"functions_func_p.html#index_p"}, +{text:"r",url:"functions_func_r.html#index_r"}, +{text:"s",url:"functions_func_s.html#index_s"}, +{text:"t",url:"functions_func_t.html#index_t"}, +{text:"u",url:"functions_func_u.html#index_u"}, +{text:"v",url:"functions_func_v.html#index_v"}, +{text:"w",url:"functions_func_w.html#index_w"}, +{text:"z",url:"functions_func_z.html#index_z"}, +{text:"~",url:"functions_func_~.html#index__7E"}]}, +{text:"Variables",url:"functions_vars.html",children:[ +{text:"a",url:"functions_vars.html#index_a"}, +{text:"b",url:"functions_vars.html#index_b"}, +{text:"c",url:"functions_vars.html#index_c"}, +{text:"d",url:"functions_vars.html#index_d"}, +{text:"f",url:"functions_vars.html#index_f"}, +{text:"g",url:"functions_vars.html#index_g"}, +{text:"h",url:"functions_vars.html#index_h"}, +{text:"i",url:"functions_vars.html#index_i"}, +{text:"j",url:"functions_vars.html#index_j"}, +{text:"k",url:"functions_vars.html#index_k"}, +{text:"l",url:"functions_vars.html#index_l"}, +{text:"m",url:"functions_vars.html#index_m"}, +{text:"n",url:"functions_vars.html#index_n"}, +{text:"o",url:"functions_vars.html#index_o"}, +{text:"p",url:"functions_vars.html#index_p"}, +{text:"r",url:"functions_vars.html#index_r"}, +{text:"s",url:"functions_vars.html#index_s"}, +{text:"t",url:"functions_vars.html#index_t"}, +{text:"u",url:"functions_vars.html#index_u"}, +{text:"v",url:"functions_vars.html#index_v"}, +{text:"w",url:"functions_vars.html#index_w"}, +{text:"x",url:"functions_vars.html#index_x"}, +{text:"y",url:"functions_vars.html#index_y"}, +{text:"z",url:"functions_vars.html#index_z"}]}, +{text:"Typedefs",url:"functions_type.html"}, +{text:"Enumerations",url:"functions_enum.html"}, +{text:"Enumerator",url:"functions_eval.html",children:[ +{text:"a",url:"functions_eval.html#index_a"}, +{text:"b",url:"functions_eval_b.html#index_b"}, +{text:"c",url:"functions_eval_c.html#index_c"}, +{text:"d",url:"functions_eval_d.html#index_d"}, +{text:"e",url:"functions_eval_e.html#index_e"}, +{text:"f",url:"functions_eval_f.html#index_f"}, +{text:"g",url:"functions_eval_g.html#index_g"}, +{text:"h",url:"functions_eval_h.html#index_h"}, +{text:"i",url:"functions_eval_i.html#index_i"}, +{text:"j",url:"functions_eval_j.html#index_j"}, +{text:"k",url:"functions_eval_k.html#index_k"}, +{text:"l",url:"functions_eval_l.html#index_l"}, +{text:"m",url:"functions_eval_m.html#index_m"}, +{text:"n",url:"functions_eval_n.html#index_n"}, +{text:"o",url:"functions_eval_o.html#index_o"}, +{text:"p",url:"functions_eval_p.html#index_p"}, +{text:"q",url:"functions_eval_q.html#index_q"}, +{text:"r",url:"functions_eval_r.html#index_r"}, +{text:"s",url:"functions_eval_s.html#index_s"}, +{text:"t",url:"functions_eval_t.html#index_t"}, +{text:"u",url:"functions_eval_u.html#index_u"}, +{text:"v",url:"functions_eval_v.html#index_v"}, +{text:"w",url:"functions_eval_w.html#index_w"}, +{text:"x",url:"functions_eval_x.html#index_x"}, +{text:"y",url:"functions_eval_y.html#index_y"}, +{text:"z",url:"functions_eval_z.html#index_z"}]}, +{text:"Related Functions",url:"functions_rela.html"}]}]}, +{text:"Files",url:"files.html",children:[ +{text:"File List",url:"files.html"}, +{text:"File Members",url:"globals.html",children:[ +{text:"All",url:"globals.html"}, +{text:"Macros",url:"globals_defs.html"}]}]}]} diff --git a/Space-Invaders/sfml/doc/html/modules.html b/Space-Invaders/sfml/doc/html/modules.html new file mode 100644 index 000000000..6594e6273 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/modules.html @@ -0,0 +1,102 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Modules
+
+
+
Here is a list of all modules:
+ + + + + + +
 Audio moduleSounds, streaming (musics or custom sources), recording, spatialization
 Graphics module2D graphics module: sprites, text, shapes, ..
 Network moduleSocket-based communication, utilities and higher-level network protocols (HTTP, FTP)
 System moduleBase module of SFML, defining various utilities
 Window moduleProvides OpenGL-based windows, and abstractions for events and input handling
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/namespacemembers.html b/Space-Invaders/sfml/doc/html/namespacemembers.html new file mode 100644 index 000000000..a0131a0b4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/namespacemembers.html @@ -0,0 +1,115 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Here is a list of all documented namespace members with links to the namespaces they belong to:
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/namespacemembers_type.html b/Space-Invaders/sfml/doc/html/namespacemembers_type.html new file mode 100644 index 000000000..acfa0b7e7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/namespacemembers_type.html @@ -0,0 +1,115 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+  +
+ + + + diff --git a/Space-Invaders/sfml/doc/html/namespaces.html b/Space-Invaders/sfml/doc/html/namespaces.html new file mode 100644 index 000000000..952d254d7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/namespaces.html @@ -0,0 +1,101 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Namespace List
+
+
+
Here is a list of all documented namespaces with brief descriptions:
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/namespacesf_1_1Glsl.html b/Space-Invaders/sfml/doc/html/namespacesf_1_1Glsl.html new file mode 100644 index 000000000..67c268025 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/namespacesf_1_1Glsl.html @@ -0,0 +1,384 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + + + +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ + +
+
+
+Typedefs
+
sf::Glsl Namespace Reference
Graphics module
+
+
+ +

Namespace with GLSL types. +More...

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Typedefs

typedef Vector2< float > Vec2
 2D float vector (vec2 in GLSL)
 
typedef Vector2< int > Ivec2
 2D int vector (ivec2 in GLSL)
 
typedef Vector2< bool > Bvec2
 2D bool vector (bvec2 in GLSL)
 
typedef Vector3< float > Vec3
 3D float vector (vec3 in GLSL)
 
typedef Vector3< int > Ivec3
 3D int vector (ivec3 in GLSL)
 
typedef Vector3< bool > Bvec3
 3D bool vector (bvec3 in GLSL)
 
typedef implementation defined Vec4
 4D float vector (vec4 in GLSL)
 
typedef implementation defined Ivec4
 4D int vector (ivec4 in GLSL)
 
typedef implementation defined Bvec4
 4D bool vector (bvec4 in GLSL)
 
typedef implementation defined Mat3
 3x3 float matrix (mat3 in GLSL)
 
typedef implementation defined Mat4
 4x4 float matrix (mat4 in GLSL)
 
+

Detailed Description

+

Namespace with GLSL types.

+

The sf::Glsl namespace contains types that match their equivalents in GLSL, the OpenGL shading language. These types are exclusively used by the sf::Shader class.

+

Types that already exist in SFML, such as sf::Vector2<T> and sf::Vector3<T>, are reused as typedefs, so you can use the types in this namespace as well as the original ones. Others are newly defined, such as Glsl::Vec4 or Glsl::Mat3. Their actual type is an implementation detail and should not be used.

+

All vector types support a default constructor that initializes every component to zero, in addition to a constructor with one parameter for each component. The components are stored in member variables called x, y, z, and w.

+

All matrix types support a constructor with a float* parameter that points to a float array of the appropriate size (that is, 9 in a 3x3 matrix, 16 in a 4x4 matrix). Furthermore, they can be converted from sf::Transform objects.

+
See also
sf::Shader
+

Typedef Documentation

+ +

◆ Bvec2

+ +
+
+ + + + +
typedef Vector2<bool> sf::Glsl::Bvec2
+
+ +

2D bool vector (bvec2 in GLSL)

+ +

Definition at line 76 of file Glsl.hpp.

+ +
+
+ +

◆ Bvec3

+ +
+
+ + + + +
typedef Vector3<bool> sf::Glsl::Bvec3
+
+ +

3D bool vector (bvec3 in GLSL)

+ +

Definition at line 94 of file Glsl.hpp.

+ +
+
+ +

◆ Bvec4

+ +
+
+ + + + +
typedef implementation defined sf::Glsl::Bvec4
+
+ +

4D bool vector (bvec4 in GLSL)

+ +

Definition at line 130 of file Glsl.hpp.

+ +
+
+ +

◆ Ivec2

+ +
+
+ + + + +
typedef Vector2<int> sf::Glsl::Ivec2
+
+ +

2D int vector (ivec2 in GLSL)

+ +

Definition at line 70 of file Glsl.hpp.

+ +
+
+ +

◆ Ivec3

+ +
+
+ + + + +
typedef Vector3<int> sf::Glsl::Ivec3
+
+ +

3D int vector (ivec3 in GLSL)

+ +

Definition at line 88 of file Glsl.hpp.

+ +
+
+ +

◆ Ivec4

+ +
+
+ + + + +
typedef implementation defined sf::Glsl::Ivec4
+
+ +

4D int vector (ivec4 in GLSL)

+

4D int vectors can be implicitly converted from sf::Color instances. Each color channel remains unchanged inside the integer interval [0, 255].

sf::Glsl::Ivec4 zeroVector;
+
sf::Glsl::Ivec4 vector(1, 2, 3, 4);
+
sf::Glsl::Ivec4 color = sf::Color::Cyan;
+
sf::Color::Cyan
static const Color Cyan
Cyan predefined color.
Definition: Color.hpp:90
+
sf::Glsl::Ivec4
implementation defined Ivec4
4D int vector (ivec4 in GLSL)
Definition: Glsl.hpp:124
+
+

Definition at line 124 of file Glsl.hpp.

+ +
+
+ +

◆ Mat3

+ +
+
+ + + + +
typedef implementation defined sf::Glsl::Mat3
+
+ +

3x3 float matrix (mat3 in GLSL)

+

The matrix can be constructed from an array with 3x3 elements, aligned in column-major order. For example, a translation by (x, y) looks as follows:

float array[9] =
+
{
+
1, 0, 0,
+
0, 1, 0,
+
x, y, 1
+
};
+
+
sf::Glsl::Mat3 matrix(array);
+
sf::Glsl::Mat3
implementation defined Mat3
3x3 float matrix (mat3 in GLSL)
Definition: Glsl.hpp:155
+

Mat3 can also be implicitly converted from sf::Transform:

sf::Transform transform;
+
sf::Glsl::Mat3 matrix = transform;
+
sf::Transform
Define a 3x3 transform matrix.
Definition: Transform.hpp:43
+
+

Definition at line 155 of file Glsl.hpp.

+ +
+
+ +

◆ Mat4

+ +
+
+ + + + +
typedef implementation defined sf::Glsl::Mat4
+
+ +

4x4 float matrix (mat4 in GLSL)

+

The matrix can be constructed from an array with 4x4 elements, aligned in column-major order. For example, a translation by (x, y, z) looks as follows:

float array[16] =
+
{
+
1, 0, 0, 0,
+
0, 1, 0, 0,
+
0, 0, 1, 0,
+
x, y, z, 1
+
};
+
+
sf::Glsl::Mat4 matrix(array);
+
sf::Glsl::Mat4
implementation defined Mat4
4x4 float matrix (mat4 in GLSL)
Definition: Glsl.hpp:181
+

Mat4 can also be implicitly converted from sf::Transform:

sf::Transform transform;
+
sf::Glsl::Mat4 matrix = transform;
+
+

Definition at line 181 of file Glsl.hpp.

+ +
+
+ +

◆ Vec2

+ +
+
+ + + + +
typedef Vector2<float> sf::Glsl::Vec2
+
+ +

2D float vector (vec2 in GLSL)

+ +

Definition at line 64 of file Glsl.hpp.

+ +
+
+ +

◆ Vec3

+ +
+
+ + + + +
typedef Vector3<float> sf::Glsl::Vec3
+
+ +

3D float vector (vec3 in GLSL)

+ +

Definition at line 82 of file Glsl.hpp.

+ +
+
+ +

◆ Vec4

+ +
+
+ + + + +
typedef implementation defined sf::Glsl::Vec4
+
+ +

4D float vector (vec4 in GLSL)

+

4D float vectors can be implicitly converted from sf::Color instances. Each color channel is normalized from integers in [0, 255] to floating point values in [0, 1].

sf::Glsl::Vec4 zeroVector;
+
sf::Glsl::Vec4 vector(1.f, 2.f, 3.f, 4.f);
+
sf::Glsl::Vec4 color = sf::Color::Cyan;
+
sf::Glsl::Vec4
implementation defined Vec4
4D float vector (vec4 in GLSL)
Definition: Glsl.hpp:110
+
+

Definition at line 110 of file Glsl.hpp.

+ +
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/nav_f.png b/Space-Invaders/sfml/doc/html/nav_f.png new file mode 100644 index 000000000..72a58a529 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/nav_f.png differ diff --git a/Space-Invaders/sfml/doc/html/nav_fd.png b/Space-Invaders/sfml/doc/html/nav_fd.png new file mode 100644 index 000000000..032fbdd4c Binary files /dev/null and b/Space-Invaders/sfml/doc/html/nav_fd.png differ diff --git a/Space-Invaders/sfml/doc/html/nav_g.png b/Space-Invaders/sfml/doc/html/nav_g.png new file mode 100644 index 000000000..2093a237a Binary files /dev/null and b/Space-Invaders/sfml/doc/html/nav_g.png differ diff --git a/Space-Invaders/sfml/doc/html/nav_h.png b/Space-Invaders/sfml/doc/html/nav_h.png new file mode 100644 index 000000000..33389b101 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/nav_h.png differ diff --git a/Space-Invaders/sfml/doc/html/nav_hd.png b/Space-Invaders/sfml/doc/html/nav_hd.png new file mode 100644 index 000000000..de80f18ad Binary files /dev/null and b/Space-Invaders/sfml/doc/html/nav_hd.png differ diff --git a/Space-Invaders/sfml/doc/html/open.png b/Space-Invaders/sfml/doc/html/open.png new file mode 100644 index 000000000..30f75c7ef Binary files /dev/null and b/Space-Invaders/sfml/doc/html/open.png differ diff --git a/Space-Invaders/sfml/doc/html/pages.html b/Space-Invaders/sfml/doc/html/pages.html new file mode 100644 index 000000000..b3cf00a7c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/pages.html @@ -0,0 +1,98 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
+ + + +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Related Pages
+
+
+
Here is a list of all related documentation pages:
+ + +
 Deprecated List
+
+
+ + + + diff --git a/Space-Invaders/sfml/doc/html/search/all_0.js b/Space-Invaders/sfml/doc/html/search/all_0.js new file mode 100644 index 000000000..a428f2844 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_0.js @@ -0,0 +1,34 @@ +var searchData= +[ + ['a_0',['A',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af835596d7ce007d5c34c356dee6740c6',1,'sf::Keyboard::Scan::A()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a9d06fa7ac9af597034ea724fb08b991e',1,'sf::Keyboard::A()']]], + ['a_1',['a',['../classsf_1_1Color.html#a56dbdb47d5f040d9b78ac6a0b8b3a831',1,'sf::Color']]], + ['accelerometer_2',['Accelerometer',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84a11bc58199593e217de23641755ecc867',1,'sf::Sensor']]], + ['accept_3',['accept',['../classsf_1_1TcpListener.html#ae2c83ce5a64d50b68180c46bef0a7346',1,'sf::TcpListener']]], + ['accepted_4',['Accepted',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8ad328945457bd2f0d65107ba6b5ccd443',1,'sf::Http::Response']]], + ['add_5',['add',['../classsf_1_1SocketSelector.html#ade952013232802ff7b9b33668f8d2096',1,'sf::SocketSelector']]], + ['add_6',['Add',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32a50c081d8f36cf7b77632966e15d38966',1,'sf::BlendMode::Add()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a158c586cbe8609031d1a7932e1a8dba2',1,'sf::Keyboard::Add()']]], + ['advance_7',['advance',['../classsf_1_1Glyph.html#aeac19b97ec11409147191606b784deda',1,'sf::Glyph']]], + ['alphadstfactor_8',['alphaDstFactor',['../structsf_1_1BlendMode.html#aaf85b6b7943181cc81745569c4851e4e',1,'sf::BlendMode']]], + ['alphaequation_9',['alphaEquation',['../structsf_1_1BlendMode.html#a68f5a305e0912946f39ba6c9265710c4',1,'sf::BlendMode']]], + ['alphasrcfactor_10',['alphaSrcFactor',['../structsf_1_1BlendMode.html#aa94e44f8e1042a7357e8eff78c61a1be',1,'sf::BlendMode']]], + ['alresource_11',['AlResource',['../classsf_1_1AlResource.html#a51b4f3a825c5d68386f8683e3e1053d7',1,'sf::AlResource::AlResource()'],['../classsf_1_1AlResource.html',1,'sf::AlResource']]], + ['alt_12',['alt',['../structsf_1_1Event_1_1KeyEvent.html#a915a483317de67d995188a855701fbd7',1,'sf::Event::KeyEvent']]], + ['antialiasinglevel_13',['antialiasingLevel',['../structsf_1_1ContextSettings.html#ac4a097be18994dba38d73f36b0418bdc',1,'sf::ContextSettings']]], + ['any_14',['Any',['../classsf_1_1IpAddress.html#a3dbc10b0dc6804cc69e29342f7406907',1,'sf::IpAddress']]], + ['anyport_15',['AnyPort',['../classsf_1_1Socket.html#aa3e6c984bcb81a35234dcc9cc8369d75a5a3c30fd128895403afc11076f461b19',1,'sf::Socket']]], + ['apostrophe_16',['Apostrophe',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac391cefe75135833aea37c75293db820',1,'sf::Keyboard::Scan::Apostrophe()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a77b44e1f040360d71126fa1c4ad12bec',1,'sf::Keyboard::Apostrophe()']]], + ['append_17',['append',['../classsf_1_1VertexArray.html#a80c8f6865e53bd21fc6cb10fffa10035',1,'sf::VertexArray::append()'],['../classsf_1_1Packet.html#a7dd6e429b87520008326c4d71f1cf011',1,'sf::Packet::append()']]], + ['application_18',['Application',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5a7f9d3ad8d2528dc7648b682b069211',1,'sf::Keyboard::Scan']]], + ['arrow_19',['Arrow',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa8d9a9cd284dabb4246ab4f147ba779a3',1,'sf::Cursor']]], + ['arrowwait_20',['ArrowWait',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa16c3acb967f2175434d6bbad7f1300bf',1,'sf::Cursor']]], + ['ascii_21',['Ascii',['../classsf_1_1Ftp.html#a1cd6b89ad23253f6d97e6d4ca4d558cbac9e544a22dce8ef3177449cb235d15c2',1,'sf::Ftp']]], + ['asmicroseconds_22',['asMicroseconds',['../classsf_1_1Time.html#a000c2c64b74658ebd228b9294a464275',1,'sf::Time']]], + ['asmilliseconds_23',['asMilliseconds',['../classsf_1_1Time.html#aa16858ca030a07eb18958c321f256e5a',1,'sf::Time']]], + ['asseconds_24',['asSeconds',['../classsf_1_1Time.html#aa3df2f992d0b0041b4eb02258d43f0e3',1,'sf::Time']]], + ['attribute_25',['Attribute',['../structsf_1_1ContextSettings.html#af2e91e57e8d26c40afe2ec8efaa32a2c',1,'sf::ContextSettings']]], + ['attributeflags_26',['attributeFlags',['../structsf_1_1ContextSettings.html#a0ef3fc53802bc0197d2739466915ada5',1,'sf::ContextSettings']]], + ['audio_20module_27',['Audio module',['../group__audio.html',1,'']]], + ['axis_28',['Axis',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7',1,'sf::Joystick']]], + ['axis_29',['axis',['../structsf_1_1Event_1_1JoystickMoveEvent.html#add22e8126b7974271991dc6380cbdee3',1,'sf::Event::JoystickMoveEvent']]], + ['axiscount_30',['AxisCount',['../classsf_1_1Joystick.html#aee00dd432eacd8369d279b47c3ab4cc5accf3e487c9f6ee2f384351323626a42c',1,'sf::Joystick']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_1.js b/Space-Invaders/sfml/doc/html/search/all_1.js new file mode 100644 index 000000000..08cee7047 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_1.js @@ -0,0 +1,31 @@ +var searchData= +[ + ['b_0',['b',['../classsf_1_1Color.html#a6707aedd0609c8920e12df5d7abc53cb',1,'sf::Color']]], + ['b_1',['B',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5a277726531303b8ba5212999e9664cb',1,'sf::Keyboard::Scan::B()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aca3142235e5c4199f0b8b45d8368ef94',1,'sf::Keyboard::B()']]], + ['back_2',['Back',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae5c30910d66a7706ec731fff17e552d2',1,'sf::Keyboard::Scan']]], + ['backslash_3',['Backslash',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a01ce415ff140d34d25a7bdbbbb785287',1,'sf::Keyboard::Scan::Backslash()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142adbd7d6f90a1009e91acf7bb1dc068512',1,'sf::Keyboard::Backslash()']]], + ['backslash_4',['BackSlash',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a536df84e73859aa44e11e192459470b6',1,'sf::Keyboard']]], + ['backspace_5',['BackSpace',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a33aeaab900abcd01eebf2fcc4f6d97e2',1,'sf::Keyboard']]], + ['backspace_6',['Backspace',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6621384ae8e5b8f0faf0b879c7813817',1,'sf::Keyboard::Scan::Backspace()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aa7c1581bac0f20164512572e6c60e98e',1,'sf::Keyboard::Backspace()']]], + ['badcommandsequence_7',['BadCommandSequence',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bad0c7ab07f01c1f7af16a1852650d7c47',1,'sf::Ftp::Response']]], + ['badgateway_8',['BadGateway',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8aad0cbad4cdaf448beb763e86bc1f747c',1,'sf::Http::Response']]], + ['badrequest_9',['BadRequest',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a3f88a714cf5483ee22f9051e5a3c080a',1,'sf::Http::Response']]], + ['begin_10',['begin',['../classsf_1_1String.html#a8ec30ddc08e3a6bd11c99aed782f6dfe',1,'sf::String::begin()'],['../classsf_1_1String.html#a0e4755d6b4d51de7c3dc2e984b79f95d',1,'sf::String::begin() const']]], + ['binary_11',['Binary',['../classsf_1_1Ftp.html#a1cd6b89ad23253f6d97e6d4ca4d558cba6f253b362639fb5e059dc292762a21ee',1,'sf::Ftp']]], + ['bind_12',['bind',['../classsf_1_1VertexBuffer.html#a1c623e9701b43125e4b3661bc0d0b65b',1,'sf::VertexBuffer::bind()'],['../classsf_1_1Shader.html#a09778f78afcbeb854d608c8dacd8ea30',1,'sf::Shader::bind()'],['../classsf_1_1Texture.html#ae9a4274e7b95ebf7244d09c7445833b0',1,'sf::Texture::bind()'],['../classsf_1_1UdpSocket.html#ad764c3d06d90b4714dcc97a0d1647bcc',1,'sf::UdpSocket::bind()']]], + ['bitsperpixel_13',['bitsPerPixel',['../classsf_1_1VideoMode.html#aa080f1ef96a1008d58b1920eceb189df',1,'sf::VideoMode']]], + ['black_14',['Black',['../classsf_1_1Color.html#a77c688197b981338f0b19dc58bd2facd',1,'sf::Color']]], + ['blendmode_15',['BlendMode',['../structsf_1_1BlendMode.html#a7faef75eae1fb47bbe93f45f38e3d345',1,'sf::BlendMode::BlendMode()'],['../structsf_1_1BlendMode.html#a23c7452cc8e9eb943c3aea6234ce4297',1,'sf::BlendMode::BlendMode(Factor sourceFactor, Factor destinationFactor, Equation blendEquation=Add)'],['../structsf_1_1BlendMode.html#a69a12c596114e77126616e7e0f7d798b',1,'sf::BlendMode::BlendMode(Factor colorSourceFactor, Factor colorDestinationFactor, Equation colorBlendEquation, Factor alphaSourceFactor, Factor alphaDestinationFactor, Equation alphaBlendEquation)']]], + ['blendmode_16',['blendMode',['../classsf_1_1RenderStates.html#ad6ac87f1b5006dae7ebfee4b5d40f5a8',1,'sf::RenderStates']]], + ['blendmode_17',['BlendMode',['../structsf_1_1BlendMode.html',1,'sf']]], + ['blue_18',['Blue',['../classsf_1_1Color.html#ab03770d4817426b2614cfc33cf0e245c',1,'sf::Color']]], + ['bold_19',['Bold',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82af1b47f98fb1e10509ba930a596987171',1,'sf::Text']]], + ['bounds_20',['bounds',['../classsf_1_1Glyph.html#a6f3c892093167914adc31e52e5923f4b',1,'sf::Glyph']]], + ['broadcast_21',['Broadcast',['../classsf_1_1IpAddress.html#aa93d1d57b65d243f2baf804b6035465c',1,'sf::IpAddress']]], + ['button_22',['Button',['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90',1,'sf::Mouse']]], + ['button_23',['button',['../structsf_1_1Event_1_1MouseButtonEvent.html#a5f53725aa7b647705486eeb95f723024',1,'sf::Event::MouseButtonEvent::button()'],['../structsf_1_1Event_1_1JoystickButtonEvent.html#a6412e698a2f7904c5aa875a0d1b34da4',1,'sf::Event::JoystickButtonEvent::button()']]], + ['buttoncount_24',['ButtonCount',['../classsf_1_1Joystick.html#aee00dd432eacd8369d279b47c3ab4cc5a2f1b8a0a59f2c12a4775c0e1e69e1816',1,'sf::Joystick::ButtonCount()'],['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90a52a1d434289774240ddaa22496762402',1,'sf::Mouse::ButtonCount()']]], + ['bvec2_25',['Bvec2',['../namespacesf_1_1Glsl.html#a59d8cf909c3d71ebf3db057480b464da',1,'sf::Glsl']]], + ['bvec3_26',['Bvec3',['../namespacesf_1_1Glsl.html#a4166ffc506619b4912d576e6eba2c957',1,'sf::Glsl']]], + ['bvec4_27',['Bvec4',['../namespacesf_1_1Glsl.html#a8b1f0ac369666c48a9eafc9d3f5618e6',1,'sf::Glsl']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_10.js b/Space-Invaders/sfml/doc/html/search/all_10.js new file mode 100644 index 000000000..f6152e237 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_10.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['q_0',['Q',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af9b34314661202a2f73c2d71d95fcfeb',1,'sf::Keyboard::Scan::Q()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a27e3d50587c9789d2592d275d22fbada',1,'sf::Keyboard::Q()']]], + ['quads_1',['Quads',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba5041359b76b4bd3d3e6ef738826b8743',1,'sf']]], + ['quote_2',['Quote',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af031edb6bcf319734a6664388958c475',1,'sf::Keyboard']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_11.js b/Space-Invaders/sfml/doc/html/search/all_11.js new file mode 100644 index 000000000..025bdd147 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_11.js @@ -0,0 +1,48 @@ +var searchData= +[ + ['r_0',['R',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7aeebbcdb0828850f4d69e6a084801fab8',1,'sf::Joystick::R()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af04c2611e3ee0855a044927d5bd0e194',1,'sf::Keyboard::Scan::R()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142add852cadaa6fff2d982bbab3551c31d0',1,'sf::Keyboard::R()']]], + ['r_1',['r',['../classsf_1_1Color.html#a6a5256ca24a4f9f0e0808f6fc23e01e1',1,'sf::Color']]], + ['ralt_2',['RAlt',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a2d6f466aef0f34d0d794d79362002ae3',1,'sf::Keyboard::Scan::RAlt()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a21dcf098233296462bc7c632b93369cc',1,'sf::Keyboard::RAlt()']]], + ['rangenotsatisfiable_3',['RangeNotSatisfiable',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a12533d00093b190e6d4c0076577e2239',1,'sf::Http::Response']]], + ['rbracket_4',['RBracket',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5b278a8f7b97c3972ec572412d855660',1,'sf::Keyboard::Scan::RBracket()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a578253a70b48e61830aa08292d44680f',1,'sf::Keyboard::RBracket()']]], + ['rcontrol_5',['RControl',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a275d3fd207a9c0b22ce404012c71dc17',1,'sf::Keyboard::RControl()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ab80b18e7c688d4cd1bbb52b40b9699fe',1,'sf::Keyboard::Scan::RControl()']]], + ['read_6',['read',['../classsf_1_1InputSoundFile.html#a83d6f64617456601edeb0daf9d14a17f',1,'sf::InputSoundFile::read()'],['../classsf_1_1SoundFileReader.html#a3b7d86769ea07e24e7b0f0486bed7591',1,'sf::SoundFileReader::read()'],['../classsf_1_1FileInputStream.html#ad1e94c4152429f485db224c44ee1eb50',1,'sf::FileInputStream::read()'],['../classsf_1_1InputStream.html#a8dd89c74c1acb693203f50e750c6ae53',1,'sf::InputStream::read()'],['../classsf_1_1MemoryInputStream.html#adff5270c521819639154d42d76fd4c34',1,'sf::MemoryInputStream::read()']]], + ['receive_7',['receive',['../classsf_1_1TcpSocket.html#a90ce50811ea61d4f00efc62bb99ae1af',1,'sf::TcpSocket::receive(void *data, std::size_t size, std::size_t &received)'],['../classsf_1_1TcpSocket.html#aa655352609bc9804f2baa020df3e7331',1,'sf::TcpSocket::receive(Packet &packet)'],['../classsf_1_1UdpSocket.html#ade9ca0f7ed7919136917b0b997a9833a',1,'sf::UdpSocket::receive(void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort)'],['../classsf_1_1UdpSocket.html#afdd5c655d00c96222d5b477fc057a22b',1,'sf::UdpSocket::receive(Packet &packet, IpAddress &remoteAddress, unsigned short &remotePort)']]], + ['rect_8',['Rect',['../classsf_1_1Rect.html#a0f87ebaef9722a6222fd2e04ce8efb37',1,'sf::Rect::Rect()'],['../classsf_1_1Rect.html#a15cdbc5a1aed3a8fc7be1bd5004f19f9',1,'sf::Rect::Rect(T rectLeft, T rectTop, T rectWidth, T rectHeight)'],['../classsf_1_1Rect.html#a27fdf85caa6d12caeeff78913cc59936',1,'sf::Rect::Rect(const Vector2< T > &position, const Vector2< T > &size)'],['../classsf_1_1Rect.html#a6fff2bb7e93677839461a66bc2957de0',1,'sf::Rect::Rect(const Rect< U > &rectangle)'],['../classsf_1_1Rect.html',1,'sf::Rect< T >']]], + ['rect_3c_20float_20_3e_9',['Rect< float >',['../classsf_1_1Rect.html',1,'sf']]], + ['rect_3c_20int_20_3e_10',['Rect< int >',['../classsf_1_1Rect.html',1,'sf']]], + ['rectangleshape_11',['RectangleShape',['../classsf_1_1RectangleShape.html#a83a2be157ebee85c95ed491c3e78dd7c',1,'sf::RectangleShape::RectangleShape()'],['../classsf_1_1RectangleShape.html',1,'sf::RectangleShape']]], + ['red_12',['Red',['../classsf_1_1Color.html#a127dbf55db9c07d0fa8f4bfcbb97594a',1,'sf::Color']]], + ['redo_13',['Redo',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad7b33839e3d1dc8048ed4e32297113ad',1,'sf::Keyboard::Scan']]], + ['refresh_14',['Refresh',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a21a543fae6b497b61df6e58d315f9e12',1,'sf::Keyboard::Scan']]], + ['registercontextdestroycallback_15',['registerContextDestroyCallback',['../classsf_1_1GlResource.html#ab171bdaf5eb36789da14b30a846db471',1,'sf::GlResource']]], + ['registerreader_16',['registerReader',['../classsf_1_1SoundFileFactory.html#aeee396bfdbb6ac24c57e5c73c30ec105',1,'sf::SoundFileFactory']]], + ['registerwriter_17',['registerWriter',['../classsf_1_1SoundFileFactory.html#abb6e082ea3fedf22c8648113d1be5755',1,'sf::SoundFileFactory']]], + ['regular_18',['Regular',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82a2af9ae5e1cda126570f744448e0caa32',1,'sf::Text']]], + ['remove_19',['remove',['../classsf_1_1SocketSelector.html#a98b6ab693a65b82caa375639232357c1',1,'sf::SocketSelector']]], + ['renamefile_20',['renameFile',['../classsf_1_1Ftp.html#a8f99251d7153e1dc26723e4006deb764',1,'sf::Ftp']]], + ['renderstates_21',['RenderStates',['../classsf_1_1RenderStates.html#a39f94233f464739d8d8522f3aefe97d0',1,'sf::RenderStates::RenderStates(const Shader *theShader)'],['../classsf_1_1RenderStates.html#a885bf14070d0d5391f062f62b270b7d0',1,'sf::RenderStates::RenderStates()'],['../classsf_1_1RenderStates.html#acac8830a593c8a4523ac2fdf3cac8a01',1,'sf::RenderStates::RenderStates(const BlendMode &theBlendMode)'],['../classsf_1_1RenderStates.html#a3e99cad6ab05971d40357949930ed890',1,'sf::RenderStates::RenderStates(const Transform &theTransform)'],['../classsf_1_1RenderStates.html#a8f4ca3be0e27dafea0c4ab8547439bb1',1,'sf::RenderStates::RenderStates(const Texture *theTexture)'],['../classsf_1_1RenderStates.html#ab5eda13cd8c79c74eba3b1b0df817d67',1,'sf::RenderStates::RenderStates(const BlendMode &theBlendMode, const Transform &theTransform, const Texture *theTexture, const Shader *theShader)'],['../classsf_1_1RenderStates.html',1,'sf::RenderStates']]], + ['rendertarget_22',['RenderTarget',['../classsf_1_1RenderTarget.html#a2997c96cbd93cb8ce0aba2ddae35b86f',1,'sf::RenderTarget::RenderTarget()'],['../classsf_1_1RenderTarget.html',1,'sf::RenderTarget']]], + ['rendertexture_23',['RenderTexture',['../classsf_1_1RenderTexture.html#a19ee6e5b4c40ad251803389b3953a9c6',1,'sf::RenderTexture::RenderTexture()'],['../classsf_1_1RenderTexture.html',1,'sf::RenderTexture']]], + ['renderwindow_24',['RenderWindow',['../classsf_1_1RenderWindow.html#a839bbf336bdcafb084dafc3076fc9021',1,'sf::RenderWindow::RenderWindow()'],['../classsf_1_1RenderWindow.html#aebef983e01f677bf5a66cefc4d547647',1,'sf::RenderWindow::RenderWindow(VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())'],['../classsf_1_1RenderWindow.html#a25c0af7d515e710b6eebc9c6be952aa5',1,'sf::RenderWindow::RenderWindow(WindowHandle handle, const ContextSettings &settings=ContextSettings())'],['../classsf_1_1RenderWindow.html',1,'sf::RenderWindow']]], + ['replace_25',['replace',['../classsf_1_1String.html#ad460e628c287b0fa88deba2eb0b6744b',1,'sf::String::replace(std::size_t position, std::size_t length, const String &replaceWith)'],['../classsf_1_1String.html#a82bbfee2bf23c641e5361ad505c07921',1,'sf::String::replace(const String &searchFor, const String &replaceWith)']]], + ['request_26',['Request',['../classsf_1_1Http_1_1Request.html#a8e89d9e8ffcc1163259b35d79809a61c',1,'sf::Http::Request::Request()'],['../classsf_1_1Http_1_1Request.html',1,'sf::Http::Request']]], + ['requestfocus_27',['requestFocus',['../classsf_1_1WindowBase.html#a448770d2372d8df0a1ad6b1c7cce3c89',1,'sf::WindowBase']]], + ['reset_28',['reset',['../classsf_1_1View.html#ac95b636eafab3922b7e8304fb6c00d7d',1,'sf::View']]], + ['resetbuffer_29',['resetBuffer',['../classsf_1_1Sound.html#acb7289d45e06fb76b8292ac84beb82a7',1,'sf::Sound']]], + ['resetcontent_30',['ResetContent',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a77327cc2a5e34cc64030b322e61d12a8',1,'sf::Http::Response']]], + ['resetglstates_31',['resetGLStates',['../classsf_1_1RenderTarget.html#aac7504990d27dada4bfe3c7866920765',1,'sf::RenderTarget']]], + ['resize_32',['resize',['../classsf_1_1VertexArray.html#a0c0fe239e8f9a54e64d3bbc96bf548c0',1,'sf::VertexArray']]], + ['resize_33',['Resize',['../group__window.html#gga97d7ee508bea4507ab40271518c732ffaccff967648ebcd5db2007eff7352b50f',1,'sf::Style']]], + ['resized_34',['Resized',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa67fd26d7e520bc6722db3ff47ef24941',1,'sf::Event']]], + ['response_35',['Response',['../classsf_1_1Ftp_1_1Response.html#af300fffd4862774102f978eb22f85d9b',1,'sf::Ftp::Response::Response()'],['../classsf_1_1Http_1_1Response.html#a2e51c89356fe6a007c448a841a9ec08c',1,'sf::Http::Response::Response()'],['../classsf_1_1Ftp_1_1Response.html',1,'sf::Ftp::Response'],['../classsf_1_1Http_1_1Response.html',1,'sf::Http::Response']]], + ['restart_36',['restart',['../classsf_1_1Clock.html#a123e2627f2943e5ecaa1db0c7df3231b',1,'sf::Clock']]], + ['restartmarkerreply_37',['RestartMarkerReply',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba07e06d3326ba2d078583bef93930d909',1,'sf::Ftp::Response']]], + ['return_38',['Return',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac291de81bdee518d636bc359f2ca77de',1,'sf::Keyboard']]], + ['reversesubtract_39',['ReverseSubtract',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32a2d04acf59e91811128e7d0ef076f65f0',1,'sf::BlendMode']]], + ['right_40',['Right',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a03d293668313031e7ff7eb9b7894e5c7',1,'sf::Keyboard::Scan::Right()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a2aeb083dea103a8e36b6850b51ef3632',1,'sf::Keyboard::Right()'],['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90af2cff24ab6c26daf079b11189f982fc4',1,'sf::Mouse::Right()']]], + ['rotate_41',['rotate',['../classsf_1_1Transform.html#ad78237e81d1de866d1b3c040ad003971',1,'sf::Transform::rotate(float angle, float centerX, float centerY)'],['../classsf_1_1Transform.html#a11aa9a4fbd9254e7d22b96f92f018d09',1,'sf::Transform::rotate(float angle, const Vector2f &center)'],['../classsf_1_1Transformable.html#af8a5ffddc0d93f238fee3bf8efe1ebda',1,'sf::Transformable::rotate()'],['../classsf_1_1View.html#a5fd3901aae1845586ca40add94faa378',1,'sf::View::rotate()'],['../classsf_1_1Transform.html#ad09ce22a1fb08709f66f30befc7b2e7b',1,'sf::Transform::rotate()']]], + ['rsbdelta_42',['rsbDelta',['../classsf_1_1Glyph.html#affcf288079ac470f2d88765bbfef93fa',1,'sf::Glyph']]], + ['rshift_43',['RShift',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a81b7e74173912d98493b62b13a7ed648',1,'sf::Keyboard::Scan::RShift()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a5be69e3b2f25bd5f4eed75d063f42b90',1,'sf::Keyboard::RShift()']]], + ['rsystem_44',['RSystem',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a62f3504c695ca7968e710cfdc1d8c61b',1,'sf::Keyboard::Scan::RSystem()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac1b3fd7424feeda242cedbb64f3f5a7f',1,'sf::Keyboard::RSystem()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_12.js b/Space-Invaders/sfml/doc/html/search/all_12.js new file mode 100644 index 000000000..8dbc14474 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_12.js @@ -0,0 +1,160 @@ +var searchData= +[ + ['glsl_0',['Glsl',['../namespacesf_1_1Glsl.html',1,'sf']]], + ['s_1',['S',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aca13014bf9ed5887d347060a0334ea5a',1,'sf::Keyboard::S()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3c650be640718237a3241e8da1602dae',1,'sf::Keyboard::Scan::S()']]], + ['samplecount_2',['sampleCount',['../structsf_1_1SoundFileReader_1_1Info.html#a74b40b4693d7000571484736d1367167',1,'sf::SoundFileReader::Info::sampleCount()'],['../structsf_1_1SoundStream_1_1Chunk.html#af47f5d94012acf8b11f056ba77aff97a',1,'sf::SoundStream::Chunk::sampleCount()']]], + ['samplerate_3',['sampleRate',['../structsf_1_1SoundFileReader_1_1Info.html#a06ef71c19e7de190b294ae02c361f752',1,'sf::SoundFileReader::Info']]], + ['samples_4',['samples',['../structsf_1_1SoundStream_1_1Chunk.html#aa3b84d69adbe663a17a7671626076df4',1,'sf::SoundStream::Chunk']]], + ['savetofile_5',['saveToFile',['../classsf_1_1Image.html#a51537fb667f47cbe80395cfd7f9e72a4',1,'sf::Image::saveToFile()'],['../classsf_1_1SoundBuffer.html#aade64260c6375580a085314a30be007e',1,'sf::SoundBuffer::saveToFile()']]], + ['savetomemory_6',['saveToMemory',['../classsf_1_1Image.html#ae33432a31031ee501674efa9b6dc3f40',1,'sf::Image']]], + ['scale_7',['scale',['../classsf_1_1Transform.html#a846e9ff8567f50adea9b3ce4c70c1554',1,'sf::Transform::scale(float scaleX, float scaleY)'],['../classsf_1_1Transform.html#af1ad4ae13dacaf812b6411142243042b',1,'sf::Transform::scale(float scaleX, float scaleY, float centerX, float centerY)'],['../classsf_1_1Transform.html#a23fe4e63821354600b7592be90f2d65e',1,'sf::Transform::scale(const Vector2f &factors)'],['../classsf_1_1Transform.html#a486a4a1946208a883c7f8ec1e9cf2e35',1,'sf::Transform::scale(const Vector2f &factors, const Vector2f &center)'],['../classsf_1_1Transformable.html#a3de0c6d8957f3cf318092f3f60656391',1,'sf::Transformable::scale(float factorX, float factorY)'],['../classsf_1_1Transformable.html#adecaa6c69b1f27dd5194b067d96bb694',1,'sf::Transformable::scale(const Vector2f &factor)']]], + ['scan_8',['Scan',['../structsf_1_1Keyboard_1_1Scan.html',1,'sf::Keyboard']]], + ['scancode_9',['scancode',['../structsf_1_1Event_1_1KeyEvent.html#a182706c1c75e73c8fb85b796d1095ae1',1,'sf::Event::KeyEvent']]], + ['scancode_10',['Scancode',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875',1,'sf::Keyboard::Scan']]], + ['scancodecount_11',['ScancodeCount',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a28c5ad8524e1e653b43440e660d441d0',1,'sf::Keyboard::Scan']]], + ['scrolllock_12',['ScrollLock',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875abbf3aeeb831834f97684647c1495d333',1,'sf::Keyboard::Scan']]], + ['search_13',['Search',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a1b0d59ec95a4d6b585cdc7f0756ff6f0',1,'sf::Keyboard::Scan']]], + ['seconds_14',['seconds',['../classsf_1_1Time.html#af9fc40a6c0e687e3430da1cf296385b1',1,'sf::Time']]], + ['seek_15',['seek',['../classsf_1_1InputSoundFile.html#aaf97be15020a42e159ff88f76f22af20',1,'sf::InputSoundFile::seek(Uint64 sampleOffset)'],['../classsf_1_1InputSoundFile.html#a8eee7af58ad75ddc61f93ad72e2d66c1',1,'sf::InputSoundFile::seek(Time timeOffset)'],['../classsf_1_1FileInputStream.html#abdaf5700d4e1de07568e7829106b4eb9',1,'sf::FileInputStream::seek()'],['../classsf_1_1InputStream.html#a76aba8e5d5cf9b1c5902d5e04f7864fc',1,'sf::InputStream::seek()'],['../classsf_1_1MemoryInputStream.html#aa2ac8fda2bdb4c95248ae90c71633034',1,'sf::MemoryInputStream::seek()'],['../classsf_1_1SoundFileReader.html#a1e18ade5ffe882bdfa20a2ebe7e2b015',1,'sf::SoundFileReader::seek()']]], + ['select_16',['Select',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a30a8160d16b2ee9cc2d56a1a3394efa1',1,'sf::Keyboard::Scan']]], + ['semicolon_17',['SemiColon',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a460ab09a36f9ed230504b89b9815de88',1,'sf::Keyboard']]], + ['semicolon_18',['Semicolon',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a60e05ed7eb42bf7d283d7ea4aafeef90',1,'sf::Keyboard::Scan::Semicolon()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab50635b9c913837d1bd4453eec7cb506',1,'sf::Keyboard::Semicolon()']]], + ['send_19',['send',['../classsf_1_1TcpSocket.html#a0f8276e2b1c75aac4a7b0a707b250f44',1,'sf::TcpSocket::send(Packet &packet)'],['../classsf_1_1TcpSocket.html#a31f5b280126a96c6f3ad430f4cbcb54d',1,'sf::TcpSocket::send(const void *data, std::size_t size, std::size_t &sent)'],['../classsf_1_1TcpSocket.html#affce26ab3bcc4f5b9269dad79db544c0',1,'sf::TcpSocket::send(const void *data, std::size_t size)'],['../classsf_1_1UdpSocket.html#a48969a62c80d40fd74293a740798e435',1,'sf::UdpSocket::send(Packet &packet, const IpAddress &remoteAddress, unsigned short remotePort)'],['../classsf_1_1UdpSocket.html#a664ab8f26f37c21cc4de1b847c2efcca',1,'sf::UdpSocket::send(const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort)']]], + ['sendcommand_20',['sendCommand',['../classsf_1_1Ftp.html#a44e095103ecbce175a33eaf0820440ff',1,'sf::Ftp']]], + ['sendrequest_21',['sendRequest',['../classsf_1_1Http.html#aaf09ebfb5e00dcc82e0d494d5c6a9e2a',1,'sf::Http']]], + ['sensor_22',['sensor',['../classsf_1_1Event.html#acdeacbb321655b962e27d08eeec5a190',1,'sf::Event']]], + ['sensor_23',['Sensor',['../classsf_1_1Sensor.html',1,'sf']]], + ['sensorchanged_24',['SensorChanged',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aaadf9a44c788eb9467a83c074fbf12613',1,'sf::Event']]], + ['sensorevent_25',['SensorEvent',['../structsf_1_1Event_1_1SensorEvent.html',1,'sf::Event']]], + ['servicenotavailable_26',['ServiceNotAvailable',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8ac4fffba9d5ad4c14171a1bbe4f6adf87',1,'sf::Http::Response']]], + ['serviceready_27',['ServiceReady',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baea2ee2007d7843c21108bb686ef03757',1,'sf::Ftp::Response']]], + ['servicereadysoon_28',['ServiceReadySoon',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba22413357ade6b586f6ceb0d704f35075',1,'sf::Ftp::Response']]], + ['serviceunavailable_29',['ServiceUnavailable',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba43022ddf49b68a4f5aff0bea7e09e89f',1,'sf::Ftp::Response']]], + ['setactive_30',['setActive',['../classsf_1_1RenderWindow.html#aee6c53eced675e885931eb3e91f11155',1,'sf::RenderWindow::setActive()'],['../classsf_1_1Window.html#aaab549da64cedf74fa6f1ae7a3cc79e0',1,'sf::Window::setActive()'],['../classsf_1_1Context.html#a0806f915ea81ae1f4e8135a7a3696562',1,'sf::Context::setActive()'],['../classsf_1_1RenderTarget.html#adc225ead22a70843ffa9b7eebefa0ce1',1,'sf::RenderTarget::setActive()'],['../classsf_1_1RenderTexture.html#a5da95ecdbce615a80bb78399012508cf',1,'sf::RenderTexture::setActive()']]], + ['setattenuation_31',['setAttenuation',['../classsf_1_1SoundSource.html#aa2adff44cd2f8b4e3c7315d7c2a45626',1,'sf::SoundSource']]], + ['setblocking_32',['setBlocking',['../classsf_1_1Socket.html#a165fc1423e281ea2714c70303d3a9782',1,'sf::Socket']]], + ['setbody_33',['setBody',['../classsf_1_1Http_1_1Request.html#ae9f61ec3fa1639c70e9b5780cb35578e',1,'sf::Http::Request']]], + ['setbuffer_34',['setBuffer',['../classsf_1_1Sound.html#a8b395e9713d0efa48a18628c8ec1972e',1,'sf::Sound']]], + ['setcenter_35',['setCenter',['../classsf_1_1View.html#ab0296b03793e0873e6ae9e15311f3e78',1,'sf::View::setCenter(const Vector2f &center)'],['../classsf_1_1View.html#aa8e3fedb008306ff9811163545fb75f2',1,'sf::View::setCenter(float x, float y)']]], + ['setchannelcount_36',['setChannelCount',['../classsf_1_1SoundRecorder.html#ae4e22ba67d12a74966eb05fad55a317c',1,'sf::SoundRecorder']]], + ['setcharactersize_37',['setCharacterSize',['../classsf_1_1Text.html#ae96f835fc1bff858f8a23c5b01eaaf7e',1,'sf::Text']]], + ['setcolor_38',['setColor',['../classsf_1_1Sprite.html#a14def44da6437bfea20c4df5e71aba4c',1,'sf::Sprite::setColor()'],['../classsf_1_1Text.html#afd1742fca1adb6b0ea98357250ffb634',1,'sf::Text::setColor()']]], + ['setdevice_39',['setDevice',['../classsf_1_1SoundRecorder.html#a8eb3e473292c16e874322815836d3cd3',1,'sf::SoundRecorder']]], + ['setdirection_40',['setDirection',['../classsf_1_1Listener.html#ae479dc15513c6557984d26e32d06d06e',1,'sf::Listener::setDirection(float x, float y, float z)'],['../classsf_1_1Listener.html#a1d99d9457c6ddad93449ecb4f504c2bf',1,'sf::Listener::setDirection(const Vector3f &direction)']]], + ['setenabled_41',['setEnabled',['../classsf_1_1Sensor.html#afb31c5697d2e0a5fec70d702ec1d6cd9',1,'sf::Sensor']]], + ['setfield_42',['setField',['../classsf_1_1Http_1_1Request.html#aea672fae5dd089f4b6b3745ed46210d2',1,'sf::Http::Request']]], + ['setfillcolor_43',['setFillColor',['../classsf_1_1Text.html#ab7bb3babac5a6da1802b2c3e1a3e6dcc',1,'sf::Text::setFillColor()'],['../classsf_1_1Shape.html#a3506f9b5d916fec14d583d16f23c2485',1,'sf::Shape::setFillColor()']]], + ['setfont_44',['setFont',['../classsf_1_1Text.html#a2927805d1ae92d57f15034ea34756b81',1,'sf::Text']]], + ['setframeratelimit_45',['setFramerateLimit',['../classsf_1_1Window.html#af4322d315baf93405bf0d5087ad5e784',1,'sf::Window']]], + ['setglobalvolume_46',['setGlobalVolume',['../classsf_1_1Listener.html#a803a24a1fc04620cacc9f88c6fbc0e3a',1,'sf::Listener']]], + ['sethost_47',['setHost',['../classsf_1_1Http.html#a55121d543b61c41cf20b885a97b04e65',1,'sf::Http']]], + ['sethttpversion_48',['setHttpVersion',['../classsf_1_1Http_1_1Request.html#aa683b607b737a6224a91387b4108d3c7',1,'sf::Http::Request']]], + ['seticon_49',['setIcon',['../classsf_1_1WindowBase.html#add42ae12c13012e6aab74d9e34591719',1,'sf::WindowBase']]], + ['setjoystickthreshold_50',['setJoystickThreshold',['../classsf_1_1WindowBase.html#ad37f939b492c7ea046d4f7b45ac46df1',1,'sf::WindowBase']]], + ['setkeyrepeatenabled_51',['setKeyRepeatEnabled',['../classsf_1_1WindowBase.html#afd1199a64d459ba531deb65f093050a6',1,'sf::WindowBase']]], + ['setletterspacing_52',['setLetterSpacing',['../classsf_1_1Text.html#ab516110605edb0191a7873138ac42af2',1,'sf::Text']]], + ['setlinespacing_53',['setLineSpacing',['../classsf_1_1Text.html#af6505688f79e2e2d90bd68f4d767e965',1,'sf::Text']]], + ['setloop_54',['setLoop',['../classsf_1_1Sound.html#af23ab4f78f975bbabac031102321612b',1,'sf::Sound::setLoop()'],['../classsf_1_1SoundStream.html#a43fade018ffba7e4f847a9f00b353f3d',1,'sf::SoundStream::setLoop()']]], + ['setlooppoints_55',['setLoopPoints',['../classsf_1_1Music.html#ae7b339f0a957dfad045f3f28083a015e',1,'sf::Music']]], + ['setmethod_56',['setMethod',['../classsf_1_1Http_1_1Request.html#abab148554e873e80d2e41376fde1cb62',1,'sf::Http::Request']]], + ['setmindistance_57',['setMinDistance',['../classsf_1_1SoundSource.html#a75bbc2c34addc8b25a14edb908508afe',1,'sf::SoundSource']]], + ['setmousecursor_58',['setMouseCursor',['../classsf_1_1WindowBase.html#a07487a3c7e04472b19e96d3a602213ec',1,'sf::WindowBase']]], + ['setmousecursorgrabbed_59',['setMouseCursorGrabbed',['../classsf_1_1WindowBase.html#a0023344922a1e854175c8ca22b072020',1,'sf::WindowBase']]], + ['setmousecursorvisible_60',['setMouseCursorVisible',['../classsf_1_1WindowBase.html#afa4a3372b2870294d1579d8621fe3c1a',1,'sf::WindowBase']]], + ['setorigin_61',['setOrigin',['../classsf_1_1Transformable.html#a56c67bd80aae8418d13fb96c034d25ec',1,'sf::Transformable::setOrigin(float x, float y)'],['../classsf_1_1Transformable.html#aa93a835ffbf3bee2098dfbbc695a7f05',1,'sf::Transformable::setOrigin(const Vector2f &origin)']]], + ['setoutlinecolor_62',['setOutlineColor',['../classsf_1_1Shape.html#a5978f41ee349ac3c52942996dcb184f7',1,'sf::Shape::setOutlineColor()'],['../classsf_1_1Text.html#aa19ec69c3b894e963602a6804ca68fe4',1,'sf::Text::setOutlineColor()']]], + ['setoutlinethickness_63',['setOutlineThickness',['../classsf_1_1Shape.html#a5ad336ad74fc1f567fce3b7e44cf87dc',1,'sf::Shape::setOutlineThickness()'],['../classsf_1_1Text.html#ab0e6be3b40124557bf53737fe6a6ce77',1,'sf::Text::setOutlineThickness()']]], + ['setparameter_64',['setParameter',['../classsf_1_1Shader.html#a47e4dd78f0752ae08664b4ee616db1cf',1,'sf::Shader::setParameter(const std::string &name, float x)'],['../classsf_1_1Shader.html#ab8d379f40810b8e3eadebee81aedd231',1,'sf::Shader::setParameter(const std::string &name, float x, float y)'],['../classsf_1_1Shader.html#a7e36e044d6b8adca8339f40c5a4b1801',1,'sf::Shader::setParameter(const std::string &name, float x, float y, float z)'],['../classsf_1_1Shader.html#aeb468f1bc2d26750b96b74f1e19027fb',1,'sf::Shader::setParameter(const std::string &name, float x, float y, float z, float w)'],['../classsf_1_1Shader.html#a3ac473ece2c6fa26dc5032c07fd7288e',1,'sf::Shader::setParameter(const std::string &name, const Vector2f &vector)'],['../classsf_1_1Shader.html#a87d4a0c6dc70ae68aecc0dda3f343c07',1,'sf::Shader::setParameter(const std::string &name, const Vector3f &vector)'],['../classsf_1_1Shader.html#aa8618119ed4399df3fd33e78ee96b4fc',1,'sf::Shader::setParameter(const std::string &name, const Color &color)'],['../classsf_1_1Shader.html#a8599ee1348407025039b89ddf3f7cb62',1,'sf::Shader::setParameter(const std::string &name, const Transform &transform)'],['../classsf_1_1Shader.html#a7f58ab5c0a1084f238dfcec86602daa1',1,'sf::Shader::setParameter(const std::string &name, const Texture &texture)'],['../classsf_1_1Shader.html#af06b4cba0bab915fa01032b063909044',1,'sf::Shader::setParameter(const std::string &name, CurrentTextureType)']]], + ['setpitch_65',['setPitch',['../classsf_1_1SoundSource.html#a72a13695ed48b7f7b55e7cd4431f4bb6',1,'sf::SoundSource']]], + ['setpixel_66',['setPixel',['../classsf_1_1Image.html#a9fd329b8cd7d4439e07fb5d3bb2d9744',1,'sf::Image']]], + ['setplayingoffset_67',['setPlayingOffset',['../classsf_1_1SoundStream.html#af416a5f84c8750d2acb9821d78bc8646',1,'sf::SoundStream::setPlayingOffset()'],['../classsf_1_1Sound.html#ab905677846558042022dd6ab15cddff0',1,'sf::Sound::setPlayingOffset()']]], + ['setpoint_68',['setPoint',['../classsf_1_1ConvexShape.html#a5929e0ab0ba5ca1f102b40c234a8e92d',1,'sf::ConvexShape']]], + ['setpointcount_69',['setPointCount',['../classsf_1_1ConvexShape.html#a56e6e79ade6dd651cc1a0e39cb68deae',1,'sf::ConvexShape::setPointCount()'],['../classsf_1_1CircleShape.html#a16590ee7bdf5c9f752275468a4997bed',1,'sf::CircleShape::setPointCount()']]], + ['setposition_70',['setPosition',['../classsf_1_1Mouse.html#a698c41e9bce6f30ceb4063c21f869fc5',1,'sf::Mouse::setPosition(const Vector2i &position, const WindowBase &relativeTo)'],['../classsf_1_1Mouse.html#a1222e16c583be9e3d176d86e0b7817d7',1,'sf::Mouse::setPosition(const Vector2i &position)'],['../classsf_1_1Transformable.html#a4dbfb1a7c80688b0b4c477d706550208',1,'sf::Transformable::setPosition()'],['../classsf_1_1SoundSource.html#a17ba9ed01925395652181a7b2a7d3aef',1,'sf::SoundSource::setPosition(const Vector3f &position)'],['../classsf_1_1SoundSource.html#a0480257ea25d986eba6cc3c1a6f8d7c2',1,'sf::SoundSource::setPosition(float x, float y, float z)'],['../classsf_1_1Listener.html#a5bc2d8d18ea2d8f339d23cbf17678564',1,'sf::Listener::setPosition(float x, float y, float z)'],['../classsf_1_1Listener.html#a28a27d85cfbf8065c535c39176898fcb',1,'sf::Listener::setPosition(const Vector3f &position)'],['../classsf_1_1Transformable.html#af1a42209ce2b5d3f07b00f917bcd8015',1,'sf::Transformable::setPosition()'],['../classsf_1_1WindowBase.html#ab5b8d500fa5acd3ac2908c9221fe2019',1,'sf::WindowBase::setPosition()']]], + ['setprimitivetype_71',['setPrimitiveType',['../classsf_1_1VertexBuffer.html#a7c429dbef94224a86d605cf4c68aa02d',1,'sf::VertexBuffer::setPrimitiveType()'],['../classsf_1_1VertexArray.html#aa38c10707c28a97f4627ae8b2f3ad969',1,'sf::VertexArray::setPrimitiveType()']]], + ['setprocessinginterval_72',['setProcessingInterval',['../classsf_1_1SoundRecorder.html#a85b7fb8a86c08b5084f8f142767bccf6',1,'sf::SoundRecorder::setProcessingInterval()'],['../classsf_1_1SoundStream.html#a3a38d317279163f3766da2e538fbde93',1,'sf::SoundStream::setProcessingInterval()']]], + ['setradius_73',['setRadius',['../classsf_1_1CircleShape.html#a21cdf85fc2f201e10222a241af864be0',1,'sf::CircleShape']]], + ['setrelativetolistener_74',['setRelativeToListener',['../classsf_1_1SoundSource.html#ac478a8b813faf7dd575635b102081d0d',1,'sf::SoundSource']]], + ['setrepeated_75',['setRepeated',['../classsf_1_1RenderTexture.html#af8f97b33512bf7d5b6be3da6f65f7365',1,'sf::RenderTexture::setRepeated()'],['../classsf_1_1Texture.html#aaa87d1eff053b9d4d34a24c784a28658',1,'sf::Texture::setRepeated()']]], + ['setrotation_76',['setRotation',['../classsf_1_1Transformable.html#a32baf2bf1a74699b03bf8c95030a38ed',1,'sf::Transformable::setRotation()'],['../classsf_1_1View.html#a24d0503c9c51f5ef5918612786d325c1',1,'sf::View::setRotation()']]], + ['setscale_77',['setScale',['../classsf_1_1Transformable.html#aaec50b46b3f41b054763304d1e727471',1,'sf::Transformable::setScale(float factorX, float factorY)'],['../classsf_1_1Transformable.html#a4c48a87f1626047e448f9c1a68ff167e',1,'sf::Transformable::setScale(const Vector2f &factors)']]], + ['setsize_78',['setSize',['../classsf_1_1RectangleShape.html#a5c65d374d4a259dfdc24efdd24a5dbec',1,'sf::RectangleShape::setSize()'],['../classsf_1_1View.html#a9525b73fe9fbaceb9568faf56b399dab',1,'sf::View::setSize(float width, float height)'],['../classsf_1_1View.html#a9e08d471ce21aa0e69ce55ff9de66d29',1,'sf::View::setSize(const Vector2f &size)'],['../classsf_1_1WindowBase.html#a7edca32bca3000d2e241dba720034bd6',1,'sf::WindowBase::setSize()']]], + ['setsmooth_79',['setSmooth',['../classsf_1_1Font.html#a77b66551a75fbaf2e831571535b774aa',1,'sf::Font::setSmooth()'],['../classsf_1_1Texture.html#a0c3bd6825b9a99714f10d44179d74324',1,'sf::Texture::setSmooth()'],['../classsf_1_1RenderTexture.html#af08991e63c6020865dd07b20e27305b6',1,'sf::RenderTexture::setSmooth()']]], + ['setsrgb_80',['setSrgb',['../classsf_1_1Texture.html#af8a38872c50a33ff074bd0865db19dd4',1,'sf::Texture']]], + ['setstring_81',['setString',['../classsf_1_1Clipboard.html#a29c597c2165d3ca3a89c17f31ff7413d',1,'sf::Clipboard::setString()'],['../classsf_1_1Text.html#a7d3b3359f286fd9503d1ced25b7b6c33',1,'sf::Text::setString(const String &string)']]], + ['setstyle_82',['setStyle',['../classsf_1_1Text.html#ad791702bc2d1b6590a1719aa60635edf',1,'sf::Text']]], + ['settexture_83',['setTexture',['../classsf_1_1Shape.html#af8fb22bab1956325be5d62282711e3b6',1,'sf::Shape::setTexture()'],['../classsf_1_1Sprite.html#a3729c88d88ac38c19317c18e87242560',1,'sf::Sprite::setTexture(const Texture &texture, bool resetRect=false)']]], + ['settexturerect_84',['setTextureRect',['../classsf_1_1Sprite.html#a3fefec419a4e6a90c0fd54c793d82ec2',1,'sf::Sprite::setTextureRect()'],['../classsf_1_1Shape.html#a2029cc820d1740d14ac794b82525e157',1,'sf::Shape::setTextureRect()']]], + ['settitle_85',['setTitle',['../classsf_1_1WindowBase.html#accd36ae6244ae1e6d643f6c109e983f8',1,'sf::WindowBase']]], + ['setuniform_86',['setUniform',['../classsf_1_1Shader.html#a380e7a5a2896162c5fd08966c4523790',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Ivec4 &vector)'],['../classsf_1_1Shader.html#af417027ac72c06e6cfbf30975cd678e9',1,'sf::Shader::setUniform(const std::string &name, bool x)'],['../classsf_1_1Shader.html#ab2518b8dd0762e682b452a5d5005f2bf',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Bvec2 &vector)'],['../classsf_1_1Shader.html#ab06830875c82476fbb9c975cdeb78a11',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Bvec3 &vector)'],['../classsf_1_1Shader.html#ac8db3e0adf1129abf24f0a51a7ec36f4',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Bvec4 &vector)'],['../classsf_1_1Shader.html#ac1198ae0152d439bc05781046883e281',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Mat3 &matrix)'],['../classsf_1_1Shader.html#a7806a29ffbd0ee9251256a9e7265d479',1,'sf::Shader::setUniform(const std::string &name, const Texture &texture)'],['../classsf_1_1Shader.html#ab18f531e1f726b88fec1cf5a1e6af26d',1,'sf::Shader::setUniform(const std::string &name, CurrentTextureType)'],['../classsf_1_1Shader.html#aca5c55c4a3b23d21e33dbdaab7990755',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Mat4 &matrix)'],['../classsf_1_1Shader.html#abf78e3bea1e9b0bab850b6b0a0de29c7',1,'sf::Shader::setUniform(const std::string &name, float x)'],['../classsf_1_1Shader.html#a4a2c673c41e37b17d67e4af1298b679f',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Vec2 &vector)'],['../classsf_1_1Shader.html#aad654ad8de6f0c56191fa7b8cea21db2',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Vec3 &vector)'],['../classsf_1_1Shader.html#abc1aee8343800680fd62e1f3d43c24bf',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Vec4 &vector)'],['../classsf_1_1Shader.html#ae4fc8b4c18e6b653952bce5c8c81e4a0',1,'sf::Shader::setUniform(const std::string &name, int x)'],['../classsf_1_1Shader.html#a2ccb5bae59cedc7d6a9b533c97f7d1ed',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Ivec2 &vector)'],['../classsf_1_1Shader.html#a9e328e3e97cd753fdc7b842f4b0f202e',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Ivec3 &vector)']]], + ['setuniformarray_87',['setUniformArray',['../classsf_1_1Shader.html#a731d3b9953c50fe7d3fb03340b97deff',1,'sf::Shader::setUniformArray(const std::string &name, const float *scalarArray, std::size_t length)'],['../classsf_1_1Shader.html#ab2e2eab45d9a091f3720c0879a5bb026',1,'sf::Shader::setUniformArray(const std::string &name, const Glsl::Vec2 *vectorArray, std::size_t length)'],['../classsf_1_1Shader.html#aeae884292fed977bbea5039818f208e7',1,'sf::Shader::setUniformArray(const std::string &name, const Glsl::Vec3 *vectorArray, std::size_t length)'],['../classsf_1_1Shader.html#aa89ac1ea7918c9b1c2232df59affb7fa',1,'sf::Shader::setUniformArray(const std::string &name, const Glsl::Vec4 *vectorArray, std::size_t length)'],['../classsf_1_1Shader.html#a69587701d347ba21d506197d0fb9f842',1,'sf::Shader::setUniformArray(const std::string &name, const Glsl::Mat3 *matrixArray, std::size_t length)'],['../classsf_1_1Shader.html#a066b0ba02e1c1bddc9e2571eca1156ab',1,'sf::Shader::setUniformArray(const std::string &name, const Glsl::Mat4 *matrixArray, std::size_t length)']]], + ['setupvector_88',['setUpVector',['../classsf_1_1Listener.html#a0ea9b3083a994b2b90253543bc4e3ad6',1,'sf::Listener::setUpVector(float x, float y, float z)'],['../classsf_1_1Listener.html#a281e8cd44d3411d891b5e83b0cb6b9d4',1,'sf::Listener::setUpVector(const Vector3f &upVector)']]], + ['seturi_89',['setUri',['../classsf_1_1Http_1_1Request.html#a3723de4b4f1a14b744477841c4ac22e6',1,'sf::Http::Request']]], + ['setusage_90',['setUsage',['../classsf_1_1VertexBuffer.html#ace40070db1fccf12a025383b23e81cad',1,'sf::VertexBuffer']]], + ['setvalue_91',['setValue',['../classsf_1_1ThreadLocal.html#ab7e334c83d77644a8e67ee31c3230007',1,'sf::ThreadLocal']]], + ['setverticalsyncenabled_92',['setVerticalSyncEnabled',['../classsf_1_1Window.html#a59041c4556e0351048f8aff366034f61',1,'sf::Window']]], + ['setview_93',['setView',['../classsf_1_1RenderTarget.html#a063db6dd0a14913504af30e50cb6d946',1,'sf::RenderTarget']]], + ['setviewport_94',['setViewport',['../classsf_1_1View.html#a8eaec46b7d332fe834f016d0187d4b4a',1,'sf::View']]], + ['setvirtualkeyboardvisible_95',['setVirtualKeyboardVisible',['../classsf_1_1Keyboard.html#ad61fee7e793242d444a8c5acd662fe5b',1,'sf::Keyboard']]], + ['setvisible_96',['setVisible',['../classsf_1_1WindowBase.html#a576488ad202cb2cd4359af94eaba4dd8',1,'sf::WindowBase']]], + ['setvolume_97',['setVolume',['../classsf_1_1SoundSource.html#a2f192f2b49fb8e2b82f3498d3663fcc2',1,'sf::SoundSource']]], + ['sfml_20documentation_98',['SFML Documentation',['../index.html',1,'']]], + ['sfml_5fdefine_5fdiscrete_5fgpu_5fpreference_99',['SFML_DEFINE_DISCRETE_GPU_PREFERENCE',['../GpuPreference_8hpp.html#ab0233c2d867cbd561036ed2440a4fec0',1,'GpuPreference.hpp']]], + ['shader_100',['Shader',['../classsf_1_1Shader.html',1,'sf::Shader'],['../classsf_1_1Shader.html#a1d7f28f26b4122959fcafec871c2c3c5',1,'sf::Shader::Shader()']]], + ['shader_101',['shader',['../classsf_1_1RenderStates.html#ad4f79ecdd0c60ed0d24fbe555b221bd8',1,'sf::RenderStates']]], + ['shape_102',['Shape',['../classsf_1_1Shape.html',1,'sf::Shape'],['../classsf_1_1Shape.html#a413a457f720835b9f5d8e97ca8b80960',1,'sf::Shape::Shape()']]], + ['shift_103',['shift',['../structsf_1_1Event_1_1KeyEvent.html#a776af1a3ca79abeeec18ebf1c0065aa9',1,'sf::Event::KeyEvent']]], + ['size_104',['size',['../classsf_1_1Event.html#a85dae56a377eeffd39183c3f6fc96cb9',1,'sf::Event']]], + ['sizeall_105',['SizeAll',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa256a64be04f0347e6a44cbf84e5410bd',1,'sf::Cursor']]], + ['sizebottom_106',['SizeBottom',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aaafd57cfee8747f202db04a549057e185',1,'sf::Cursor']]], + ['sizebottomleft_107',['SizeBottomLeft',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa62fb130f4aa6ecf39c8366e0de549cc2',1,'sf::Cursor']]], + ['sizebottomlefttopright_108',['SizeBottomLeftTopRight',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aac047cea5795b6074fbb4d6479452e8ef',1,'sf::Cursor']]], + ['sizebottomright_109',['SizeBottomRight',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa581edf98abd0b4905329b516a45eeef8',1,'sf::Cursor']]], + ['sizeevent_110',['SizeEvent',['../structsf_1_1Event_1_1SizeEvent.html',1,'sf::Event']]], + ['sizehorizontal_111',['SizeHorizontal',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa0131508eaa8802dba34b8c9b41aec6e9',1,'sf::Cursor']]], + ['sizeleft_112',['SizeLeft',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa4725e9d5f8117997732f8dcccce45be4',1,'sf::Cursor']]], + ['sizeright_113',['SizeRight',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aaebc3670bd27360a7de429daa07921a4d',1,'sf::Cursor']]], + ['sizetop_114',['SizeTop',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa605e36bf335a0d801b4e7d67995a9e85',1,'sf::Cursor']]], + ['sizetopleft_115',['SizeTopLeft',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa2cc42c06dd701af7211f351333b629ca',1,'sf::Cursor']]], + ['sizetopleftbottomright_116',['SizeTopLeftBottomRight',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa934ddc380262a94358ccb5a4ab7bbe1c',1,'sf::Cursor']]], + ['sizetopright_117',['SizeTopRight',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa84d9478fdeef2f727f06f3fe5bdb1be6',1,'sf::Cursor']]], + ['sizevertical_118',['SizeVertical',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aab3cefa56d3a0fe9fe64680c7ec11eab5',1,'sf::Cursor']]], + ['slash_119',['Slash',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a7424bf901434a587a6c202c423e6786c',1,'sf::Keyboard::Slash()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5c37f9adf66e083d85950db1597c45f5',1,'sf::Keyboard::Scan::Slash()']]], + ['sleep_120',['sleep',['../group__system.html#gab8c0d1f966b4e5110fd370b662d8c11b',1,'sf']]], + ['socket_121',['Socket',['../classsf_1_1Socket.html',1,'sf::Socket'],['../classsf_1_1Socket.html#a80ffb47ec0bafc83af019055d3e6a303',1,'sf::Socket::Socket()']]], + ['socketselector_122',['SocketSelector',['../classsf_1_1SocketSelector.html',1,'sf::SocketSelector'],['../classsf_1_1SocketSelector.html#a741959c5158aeb1e4457cad47d90f76b',1,'sf::SocketSelector::SocketSelector()'],['../classsf_1_1SocketSelector.html#a50b1b955eb7ecb2e7c2764f3f4722fbf',1,'sf::SocketSelector::SocketSelector(const SocketSelector &copy)']]], + ['sound_123',['Sound',['../classsf_1_1Sound.html',1,'sf::Sound'],['../classsf_1_1Sound.html#a36ab74beaaa953d9879c933ddd246282',1,'sf::Sound::Sound()'],['../classsf_1_1Sound.html#a3b1cfc19a856d4ff8c079ee41bb78e69',1,'sf::Sound::Sound(const SoundBuffer &buffer)'],['../classsf_1_1Sound.html#ae05eeed6377932694d86b3011be366c0',1,'sf::Sound::Sound(const Sound &copy)']]], + ['soundbuffer_124',['SoundBuffer',['../classsf_1_1SoundBuffer.html',1,'sf::SoundBuffer'],['../classsf_1_1SoundBuffer.html#a0cabfbfe19b831bf7d5c9592d92ef233',1,'sf::SoundBuffer::SoundBuffer()'],['../classsf_1_1SoundBuffer.html#aaf000fc741ff27015907e8588263f4a6',1,'sf::SoundBuffer::SoundBuffer(const SoundBuffer &copy)']]], + ['soundbufferrecorder_125',['SoundBufferRecorder',['../classsf_1_1SoundBufferRecorder.html',1,'sf']]], + ['soundfilefactory_126',['SoundFileFactory',['../classsf_1_1SoundFileFactory.html',1,'sf']]], + ['soundfilereader_127',['SoundFileReader',['../classsf_1_1SoundFileReader.html',1,'sf']]], + ['soundfilewriter_128',['SoundFileWriter',['../classsf_1_1SoundFileWriter.html',1,'sf']]], + ['soundrecorder_129',['SoundRecorder',['../classsf_1_1SoundRecorder.html',1,'sf::SoundRecorder'],['../classsf_1_1SoundRecorder.html#a50ebad413c4f157408a0fa49f23212a9',1,'sf::SoundRecorder::SoundRecorder()']]], + ['soundsource_130',['SoundSource',['../classsf_1_1SoundSource.html',1,'sf::SoundSource'],['../classsf_1_1SoundSource.html#ae0c7728c1449fdebe65749ab6fcb3170',1,'sf::SoundSource::SoundSource(const SoundSource &copy)'],['../classsf_1_1SoundSource.html#aefa4bd4460f387d81a0637d293979436',1,'sf::SoundSource::SoundSource()']]], + ['soundstream_131',['SoundStream',['../classsf_1_1SoundStream.html',1,'sf::SoundStream'],['../classsf_1_1SoundStream.html#a769d08f4c3c6b4340ef3a838329d2e5c',1,'sf::SoundStream::SoundStream()']]], + ['space_132',['Space',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a37fceb15fd79c29859aeb30e4b34237d',1,'sf::Keyboard::Scan::Space()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a6fdaa93b6b8d1a2b73bc239e9ada94ef',1,'sf::Keyboard::Space()']]], + ['span_133',['Span',['../structsf_1_1Music_1_1Span.html',1,'sf::Music::Span< T >'],['../structsf_1_1Music_1_1Span.html#a71e6200a586f650ce002e7e99929ae85',1,'sf::Music::Span::Span()'],['../structsf_1_1Music_1_1Span.html#a935db12207fa3da4c2461cd5e1f9fa0d',1,'sf::Music::Span::Span(T off, T len)']]], + ['span_3c_20uint64_20_3e_134',['Span< Uint64 >',['../structsf_1_1Music_1_1Span.html',1,'sf::Music']]], + ['sprite_135',['Sprite',['../classsf_1_1Sprite.html',1,'sf::Sprite'],['../classsf_1_1Sprite.html#a92559fbca895a96758abf5eabab96984',1,'sf::Sprite::Sprite()'],['../classsf_1_1Sprite.html#a2a9fca374d7abf084bb1c143a879ff4a',1,'sf::Sprite::Sprite(const Texture &texture)'],['../classsf_1_1Sprite.html#a01cfe1402372d243dbaa2ffa96020206',1,'sf::Sprite::Sprite(const Texture &texture, const IntRect &rectangle)']]], + ['srcalpha_136',['SrcAlpha',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbaac0ae68df2930b4d616c3e7abeec7d41',1,'sf::BlendMode']]], + ['srccolor_137',['SrcColor',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbad679bb0ecaf15c188d7f2e1fab572188',1,'sf::BlendMode']]], + ['srgbcapable_138',['sRgbCapable',['../structsf_1_1ContextSettings.html#ac93b041bfb6cbd36034997797708a0a3',1,'sf::ContextSettings']]], + ['start_139',['start',['../classsf_1_1SoundRecorder.html#a715f0fd2f228c83d79aaedca562ae51f',1,'sf::SoundRecorder']]], + ['static_140',['Static',['../classsf_1_1VertexBuffer.html#a3a531528684e63ecb45edd51282f5cb7a041ab564f6cd1b6775bd0ebff06b6d7e',1,'sf::VertexBuffer']]], + ['status_141',['Status',['../classsf_1_1SoundSource.html#ac43af72c98c077500b239bc75b812f03',1,'sf::SoundSource::Status()'],['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8',1,'sf::Http::Response::Status()'],['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dc',1,'sf::Socket::Status()'],['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3b',1,'sf::Ftp::Response::Status()']]], + ['stencilbits_142',['stencilBits',['../structsf_1_1ContextSettings.html#ac2e788c201ca20e84fd38a28071abd29',1,'sf::ContextSettings']]], + ['stop_143',['stop',['../classsf_1_1Sound.html#aa9c91c34f7c6d344d5ee9b997511f754',1,'sf::Sound::stop()'],['../classsf_1_1SoundRecorder.html#a8d9c8346aa9aa409cfed4a1101159c4c',1,'sf::SoundRecorder::stop()'],['../classsf_1_1SoundSource.html#a06501a25b12376befcc7ee1ed4865fda',1,'sf::SoundSource::stop()'],['../classsf_1_1SoundStream.html#a16cc6a0404b32e42c4dce184bb94d0f4',1,'sf::SoundStream::stop()']]], + ['stop_144',['Stop',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a03a70c06d505acb1473f68a63c712faa',1,'sf::Keyboard::Scan']]], + ['stopped_145',['Stopped',['../classsf_1_1SoundSource.html#ac43af72c98c077500b239bc75b812f03adabb01e8aa85b2f54b344890addf764a',1,'sf::SoundSource']]], + ['stream_146',['Stream',['../classsf_1_1VertexBuffer.html#a3a531528684e63ecb45edd51282f5cb7aeed06a391698772af58a9cfdff77deaf',1,'sf::VertexBuffer']]], + ['strikethrough_147',['StrikeThrough',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82a9ed1f5bb154c21269e1190c5aa97d479',1,'sf::Text']]], + ['string_148',['String',['../classsf_1_1String.html',1,'sf::String'],['../classsf_1_1String.html#a8e1a5027416d121187908e2ed77079ff',1,'sf::String::String(Uint32 utf32Char)'],['../classsf_1_1String.html#a9563a4e93f692e0c8e8702b374ef8692',1,'sf::String::String()'],['../classsf_1_1String.html#a0aa41dcbd17b0c36c74d03d3b0147f1e',1,'sf::String::String(const std::string &ansiString, const std::locale &locale=std::locale())'],['../classsf_1_1String.html#a5742d0a9b0c754f711820c2b5c40fa55',1,'sf::String::String(const wchar_t *wideString)'],['../classsf_1_1String.html#a5e38151340af4f9a5f74ad24c0664074',1,'sf::String::String(const std::wstring &wideString)'],['../classsf_1_1String.html#aea3629adf19f9fe713d4946f6c75b214',1,'sf::String::String(const Uint32 *utf32String)'],['../classsf_1_1String.html#a6eee86dbe75d16bbcc26e97416c2e1ca',1,'sf::String::String(const std::basic_string< Uint32 > &utf32String)'],['../classsf_1_1String.html#af862594d3c4070d8ddbf08cf8dce4f59',1,'sf::String::String(const String &copy)'],['../classsf_1_1String.html#a57d2b8c289f9894f859564cad034bfc7',1,'sf::String::String(const char *ansiString, const std::locale &locale=std::locale())'],['../classsf_1_1String.html#ac9df7f7696cff164794e338f3c89ccc5',1,'sf::String::String(char ansiChar, const std::locale &locale=std::locale())'],['../classsf_1_1String.html#aefaa202d2aa5ff85b4f75a5983367e86',1,'sf::String::String(wchar_t wideChar)']]], + ['style_149',['Style',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82',1,'sf::Text']]], + ['substring_150',['substring',['../classsf_1_1String.html#a492645e00032455e6d92ff0e992654ce',1,'sf::String']]], + ['subtract_151',['Subtract',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a68983f67bd30d27b27c90d6794c78aa2',1,'sf::Keyboard::Subtract()'],['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32a14c825be24f8412fc5ed5b49f19bc0d0',1,'sf::BlendMode::Subtract()']]], + ['swap_152',['swap',['../classsf_1_1Texture.html#a9243470c64b7ff0d231e00663e495798',1,'sf::Texture::swap()'],['../classsf_1_1VertexBuffer.html#a3954d696848dc4c921c15a6b4459c8e6',1,'sf::VertexBuffer::swap()']]], + ['system_153',['system',['../structsf_1_1Event_1_1KeyEvent.html#ac0557f7edc2a608ec65175fdd843afc5',1,'sf::Event::KeyEvent']]], + ['system_20module_154',['System module',['../group__system.html',1,'']]], + ['systemstatus_155',['SystemStatus',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba9bdd02ae119b8be639e778859ee74060',1,'sf::Ftp::Response']]], + ['systemtype_156',['SystemType',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba78391f73aa11f07f1514c7d070b93c08',1,'sf::Ftp::Response']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_13.js b/Space-Invaders/sfml/doc/html/search/all_13.js new file mode 100644 index 000000000..e40bff796 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_13.js @@ -0,0 +1,60 @@ +var searchData= +[ + ['t_0',['T',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a55bee4759c12cb033659e8d8de796ae9',1,'sf::Keyboard::Scan::T()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a19f59109111fc5271d3581bcd0c43187',1,'sf::Keyboard::T()']]], + ['tab_1',['Tab',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa724a5e6b812f12b06957717fd78d4a3',1,'sf::Keyboard::Scan::Tab()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a20c552c39c8356b1078f1cfff7936b4a',1,'sf::Keyboard::Tab()']]], + ['tcp_2',['Tcp',['../classsf_1_1Socket.html#a5d3ff44e56e68f02816bb0fabc34adf8acc02e97e90234b957eaad4dff7f22214',1,'sf::Socket']]], + ['tcplistener_3',['TcpListener',['../classsf_1_1TcpListener.html',1,'sf::TcpListener'],['../classsf_1_1TcpListener.html#a59a1db5b6f4711a3e57390da2f8d9630',1,'sf::TcpListener::TcpListener()']]], + ['tcpsocket_4',['TcpSocket',['../classsf_1_1TcpSocket.html',1,'sf::TcpSocket'],['../classsf_1_1TcpSocket.html#a62a9bf81fd7f15fedb29fd1348483236',1,'sf::TcpSocket::TcpSocket()']]], + ['tell_5',['tell',['../classsf_1_1InputStream.html#a599515b9ccdbddb6fef5a98424fd559c',1,'sf::InputStream::tell()'],['../classsf_1_1MemoryInputStream.html#a7ad4bdf721f29de8f66421ff29e23ee4',1,'sf::MemoryInputStream::tell()'],['../classsf_1_1FileInputStream.html#a768c5fdb3be79e2d71d1bce911f8741c',1,'sf::FileInputStream::tell()']]], + ['terminate_6',['terminate',['../classsf_1_1Thread.html#ad6b205d4f1ce38b8d44bba0f5501477c',1,'sf::Thread']]], + ['texcoords_7',['texCoords',['../classsf_1_1Vertex.html#a9e79bd05818d36c4789751908037097c',1,'sf::Vertex']]], + ['text_8',['Text',['../classsf_1_1Text.html',1,'sf']]], + ['text_9',['text',['../classsf_1_1Event.html#a00c7bba6bee892791847ec22440e0a83',1,'sf::Event']]], + ['text_10',['Text',['../classsf_1_1Text.html#a614019e0b5c0ed39a99d32483a51f2c5',1,'sf::Text::Text(const String &string, const Font &font, unsigned int characterSize=30)'],['../classsf_1_1Text.html#aff7cab6a92e5948c9d1481cb2d87eb84',1,'sf::Text::Text()'],['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa1a9979392de58ff11d5b4ab330e6393d',1,'sf::Cursor::Text()']]], + ['textentered_11',['TextEntered',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa7e09871dc984080ff528e4f7e073e874',1,'sf::Event']]], + ['textevent_12',['TextEvent',['../structsf_1_1Event_1_1TextEvent.html',1,'sf::Event']]], + ['texture_13',['Texture',['../classsf_1_1Texture.html',1,'sf']]], + ['texture_14',['texture',['../classsf_1_1RenderStates.html#a457fc5a41731889de9cf39cf9b3436c3',1,'sf::RenderStates']]], + ['texture_15',['Texture',['../classsf_1_1Texture.html#a3e04674853b8533bf981db3173e3a4a7',1,'sf::Texture::Texture()'],['../classsf_1_1Texture.html#a524855cbf89de3b74be84d385fd229de',1,'sf::Texture::Texture(const Texture &copy)']]], + ['texturerect_16',['textureRect',['../classsf_1_1Glyph.html#a0d502d326449f8c49011ed91d2805f5b',1,'sf::Glyph']]], + ['thread_17',['Thread',['../classsf_1_1Thread.html',1,'sf::Thread'],['../classsf_1_1Thread.html#a4cc65399bbb111cf8132537783b8e96c',1,'sf::Thread::Thread(F function)'],['../classsf_1_1Thread.html#a719b2cc067d92d52c35064a49d850a53',1,'sf::Thread::Thread(F function, A argument)'],['../classsf_1_1Thread.html#aa9f473c8cbb078900c62b1fd14a83a34',1,'sf::Thread::Thread(void(C::*function)(), C *object)']]], + ['threadlocal_18',['ThreadLocal',['../classsf_1_1ThreadLocal.html',1,'sf::ThreadLocal'],['../classsf_1_1ThreadLocal.html#a44ea3c4be4eef118080275cbf4cf04cd',1,'sf::ThreadLocal::ThreadLocal()']]], + ['threadlocalptr_19',['ThreadLocalPtr',['../classsf_1_1ThreadLocalPtr.html',1,'sf::ThreadLocalPtr< T >'],['../classsf_1_1ThreadLocalPtr.html#a8c678211d7828d2a8c41cb534422d649',1,'sf::ThreadLocalPtr::ThreadLocalPtr()']]], + ['tilde_20',['Tilde',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a90be0882086bccb516e3afc5c7fb82eb',1,'sf::Keyboard']]], + ['time_21',['Time',['../classsf_1_1Time.html',1,'sf::Time'],['../classsf_1_1Time.html#acba0cfbc49e3a09a22a8e079eb67a05c',1,'sf::Time::Time()']]], + ['titlebar_22',['Titlebar',['../group__window.html#gga97d7ee508bea4507ab40271518c732ffab4c8b32b05ed715928513787cb1e85b6',1,'sf::Style']]], + ['toansi_23',['toAnsi',['../classsf_1_1Utf_3_0132_01_4.html#a768cb205f7f1d20cd900e34fb48f9316',1,'sf::Utf< 32 >::toAnsi()'],['../classsf_1_1Utf_3_018_01_4.html#a3d8b02f29021bd48831e7706d826f0c5',1,'sf::Utf< 8 >::toAnsi()'],['../classsf_1_1Utf_3_0116_01_4.html#a6d2bfbdfe46364bd49bca28a410b18f7',1,'sf::Utf< 16 >::toAnsi()']]], + ['toansistring_24',['toAnsiString',['../classsf_1_1String.html#ada5d5bba4528aceb0a1e298553e6c30a',1,'sf::String']]], + ['tointeger_25',['toInteger',['../classsf_1_1IpAddress.html#ae7911c5ea9562f9602c3e29cd54b15e9',1,'sf::IpAddress::toInteger()'],['../classsf_1_1Color.html#abb46e6942c4fe0d221574a46e642caa9',1,'sf::Color::toInteger()']]], + ['tolatin1_26',['toLatin1',['../classsf_1_1Utf_3_0132_01_4.html#a064ce0ad81768d0d99b6b3e2e980e3ce',1,'sf::Utf< 32 >::toLatin1()'],['../classsf_1_1Utf_3_018_01_4.html#adf6f6e0a8ee0527c8ab390ce5c0b6b13',1,'sf::Utf< 8 >::toLatin1()'],['../classsf_1_1Utf_3_0116_01_4.html#ad0cc57ebf48fac584f4d5f3d30a20010',1,'sf::Utf< 16 >::toLatin1()']]], + ['top_27',['top',['../classsf_1_1Rect.html#abd3d3a2d0ad211ef0082bd0aa1a5c0e3',1,'sf::Rect']]], + ['tostring_28',['toString',['../classsf_1_1IpAddress.html#a88507954142d7fc2176cce7f36422340',1,'sf::IpAddress']]], + ['touch_29',['Touch',['../classsf_1_1Touch.html',1,'sf']]], + ['touch_30',['touch',['../classsf_1_1Event.html#a5f6ed8e499a4c3d171ff1baab469b2ee',1,'sf::Event']]], + ['touchbegan_31',['TouchBegan',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aae6f8231ad6013d063929a09b6c28f515',1,'sf::Event']]], + ['touchended_32',['TouchEnded',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aabc7123492dbca320da5c03fea1a141e5',1,'sf::Event']]], + ['touchevent_33',['TouchEvent',['../structsf_1_1Event_1_1TouchEvent.html',1,'sf::Event']]], + ['touchmoved_34',['TouchMoved',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa9524b7d7665212c6d56f623b5b8311a9',1,'sf::Event']]], + ['toutf16_35',['toUtf16',['../classsf_1_1String.html#ab805f230a0b2e972f9f32ac4cf11d912',1,'sf::String::toUtf16()'],['../classsf_1_1Utf_3_018_01_4.html#a925ac9e141dcb6f9b07c7b95f7cfbda2',1,'sf::Utf< 8 >::toUtf16()'],['../classsf_1_1Utf_3_0116_01_4.html#a0c9744c8f142360a8afebb24da134b34',1,'sf::Utf< 16 >::toUtf16()'],['../classsf_1_1Utf_3_0132_01_4.html#a3f97efb599ad237af06f076f3fcfa354',1,'sf::Utf< 32 >::toUtf16()']]], + ['toutf32_36',['toUtf32',['../classsf_1_1String.html#aef4f51ebe43465c665c78692d0262e43',1,'sf::String::toUtf32()'],['../classsf_1_1Utf_3_018_01_4.html#a79395429baba13dd04a8c1fba745ce65',1,'sf::Utf< 8 >::toUtf32()'],['../classsf_1_1Utf_3_0116_01_4.html#a781174f776a3effb96c1ccd9a4513ab1',1,'sf::Utf< 16 >::toUtf32()'],['../classsf_1_1Utf_3_0132_01_4.html#abd7c1e80791c80c4d78257440de96140',1,'sf::Utf< 32 >::toUtf32()']]], + ['toutf8_37',['toUtf8',['../classsf_1_1String.html#a2a4f366d5db833ae818881507b46e13a',1,'sf::String::toUtf8()'],['../classsf_1_1Utf_3_018_01_4.html#aef68054cab6a592c0b04de94e93bb520',1,'sf::Utf< 8 >::toUtf8()'],['../classsf_1_1Utf_3_0116_01_4.html#afdd2f31536ce3fba4dfb632dfdd6e4b7',1,'sf::Utf< 16 >::toUtf8()'],['../classsf_1_1Utf_3_0132_01_4.html#a193e155964b073c8ba838434f41d5e97',1,'sf::Utf< 32 >::toUtf8()']]], + ['towide_38',['toWide',['../classsf_1_1Utf_3_0116_01_4.html#a42bace5988f7f20497cfdd6025c2d7f2',1,'sf::Utf< 16 >::toWide()'],['../classsf_1_1Utf_3_0132_01_4.html#a0d5bf45a9732beb935592da6bed1242c',1,'sf::Utf< 32 >::toWide()'],['../classsf_1_1Utf_3_018_01_4.html#ac6633c64ff1fad6bd1bfe72c37b3a468',1,'sf::Utf< 8 >::toWide()']]], + ['towidestring_39',['toWideString',['../classsf_1_1String.html#a9d81aa3103e7e2062bd85d912a5aecf1',1,'sf::String']]], + ['transferaborted_40',['TransferAborted',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba7cfefcc586c12ba70f752353fde7126e',1,'sf::Ftp::Response']]], + ['transfermode_41',['TransferMode',['../classsf_1_1Ftp.html#a1cd6b89ad23253f6d97e6d4ca4d558cb',1,'sf::Ftp']]], + ['transform_42',['Transform',['../classsf_1_1Transform.html',1,'sf::Transform'],['../classsf_1_1Transform.html#ac32de51bd0b9f3d52fbe0838225ee83b',1,'sf::Transform::Transform()'],['../classsf_1_1Transform.html#a78c48677712fcf41122d02f1301d71a3',1,'sf::Transform::Transform(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22)']]], + ['transform_43',['transform',['../classsf_1_1RenderStates.html#a1f737981a0f2f0d4bb8dac866a8d1149',1,'sf::RenderStates']]], + ['transformable_44',['Transformable',['../classsf_1_1Transformable.html',1,'sf::Transformable'],['../classsf_1_1Transformable.html#ae71710de0fef423121bab1c684954a2e',1,'sf::Transformable::Transformable()']]], + ['transformpoint_45',['transformPoint',['../classsf_1_1Transform.html#af2e38c3c077d28898686662558b41135',1,'sf::Transform::transformPoint(float x, float y) const'],['../classsf_1_1Transform.html#ab42a0bb7a252c6d221004f6372ce5fdc',1,'sf::Transform::transformPoint(const Vector2f &point) const']]], + ['transformrect_46',['transformRect',['../classsf_1_1Transform.html#a3824a20505d81a94bc22be1ffee57d3d',1,'sf::Transform']]], + ['transientcontextlock_47',['TransientContextLock',['../classsf_1_1GlResource_1_1TransientContextLock.html',1,'sf::GlResource::TransientContextLock'],['../classsf_1_1GlResource_1_1TransientContextLock.html#a6434ee8f0380c300b361be038f37123a',1,'sf::GlResource::TransientContextLock::TransientContextLock()']]], + ['translate_48',['translate',['../classsf_1_1Transform.html#a053cd024e320ae719837386d126d0f51',1,'sf::Transform::translate(float x, float y)'],['../classsf_1_1Transform.html#a2426209f1fd3cc02129dec373a3c6f69',1,'sf::Transform::translate(const Vector2f &offset)']]], + ['transparent_49',['Transparent',['../classsf_1_1Color.html#a569b45471737f770656f50ae7bbac292',1,'sf::Color']]], + ['trianglefan_50',['TriangleFan',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba363f7762b33706c805c6a451ad554f5e',1,'sf']]], + ['triangles_51',['Triangles',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba880a7aa72c20b9f9beb7eb64d2434670',1,'sf']]], + ['trianglesfan_52',['TrianglesFan',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba5338a2c6d922151fe50f235036af8a20',1,'sf']]], + ['trianglesstrip_53',['TrianglesStrip',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba66643dbbb24bbacb405973ed80eebae0',1,'sf']]], + ['trianglestrip_54',['TriangleStrip',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba05e55fec6d32c2fc8328f94d07f91184',1,'sf']]], + ['type_55',['Type',['../classsf_1_1Shader.html#afaa1aa65e5de37b74d047da9def9f9b3',1,'sf::Shader::Type()'],['../classsf_1_1Socket.html#a5d3ff44e56e68f02816bb0fabc34adf8',1,'sf::Socket::Type()'],['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930a',1,'sf::Cursor::Type()'],['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84',1,'sf::Sensor::Type()']]], + ['type_56',['type',['../structsf_1_1Event_1_1SensorEvent.html#abee7d67bf0947fd1138e4466011e2436',1,'sf::Event::SensorEvent::type()'],['../classsf_1_1Event.html#adf2f8044f713fd9d6019077b0d1ffe0a',1,'sf::Event::type()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_14.js b/Space-Invaders/sfml/doc/html/search/all_14.js new file mode 100644 index 000000000..1e80d2253 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_14.js @@ -0,0 +1,24 @@ +var searchData= +[ + ['u_0',['U',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a0a901f61e75292dd2f642b6e4f33a214',1,'sf::Joystick::U()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aeaecd56929398797033710d1cb274003',1,'sf::Keyboard::Scan::U()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab4f30ae34848ee934dd4f5496a8fb4a1',1,'sf::Keyboard::U()']]], + ['udp_1',['Udp',['../classsf_1_1Socket.html#a5d3ff44e56e68f02816bb0fabc34adf8a6ebf3094830db4820191a327f3cc6ce2',1,'sf::Socket']]], + ['udpsocket_2',['UdpSocket',['../classsf_1_1UdpSocket.html',1,'sf::UdpSocket'],['../classsf_1_1UdpSocket.html#abb10725e26dee9d3a8165fe87ffb71bb',1,'sf::UdpSocket::UdpSocket()']]], + ['unauthorized_3',['Unauthorized',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8ab7a79b7bff50fb1902c19eecbb4e2a2d',1,'sf::Http::Response']]], + ['unbind_4',['unbind',['../classsf_1_1UdpSocket.html#a2c4abb8102a1bd31f51fcfe7f15427a3',1,'sf::UdpSocket']]], + ['underlined_5',['Underlined',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82a664bd143f92b6e8c709d7f788e8b20df',1,'sf::Text']]], + ['undo_6',['Undo',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac7476165cf08ca489e6949441d4e0715',1,'sf::Keyboard::Scan']]], + ['unicode_7',['unicode',['../structsf_1_1Event_1_1TextEvent.html#a00d96b1a5328a1d7cbc276e161befcb0',1,'sf::Event::TextEvent']]], + ['unknown_8',['Unknown',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af29c5f0133653ccd3cbc947b51e97895',1,'sf::Keyboard::Scan::Unknown()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a840c43fa8e05ff854f6fe9a86c7c939e',1,'sf::Keyboard::Unknown()']]], + ['unlock_9',['unlock',['../classsf_1_1Mutex.html#ade71268ffc5e80756652058b01c23c33',1,'sf::Mutex']]], + ['unregisterreader_10',['unregisterReader',['../classsf_1_1SoundFileFactory.html#ac42f01faf678d1f410e1ce8a18e4cebb',1,'sf::SoundFileFactory']]], + ['unregisterwriter_11',['unregisterWriter',['../classsf_1_1SoundFileFactory.html#a1bd8ebd264a5ec33962a9f7a8ca21a60',1,'sf::SoundFileFactory']]], + ['up_12',['Up',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6b3aa7f474aba344035fb34c037cdc05',1,'sf::Keyboard::Scan::Up()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac4cf6ef2d2632445e9e26c8f2b70e82d',1,'sf::Keyboard::Up()']]], + ['update_13',['update',['../classsf_1_1Shape.html#adfb2bd966c8edbc5d6c92ebc375e4ac1',1,'sf::Shape::update()'],['../classsf_1_1Texture.html#ae4eab5c6781316840b0c50ad08370963',1,'sf::Texture::update(const Uint8 *pixels)'],['../classsf_1_1Texture.html#a1352d8e16c2aeb4df586ed65dd2c36b9',1,'sf::Texture::update(const Uint8 *pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y)'],['../classsf_1_1Texture.html#af9885ca00b74950d60feea28132d9691',1,'sf::Texture::update(const Texture &texture)'],['../classsf_1_1Texture.html#a89beb474da1da84b5e38c9fc0b441fe4',1,'sf::Texture::update(const Texture &texture, unsigned int x, unsigned int y)'],['../classsf_1_1Texture.html#a037cdf171af0fb392d07626a44a4ea17',1,'sf::Texture::update(const Image &image)'],['../classsf_1_1Texture.html#a87f916490b757fe900798eedf3abf3ba',1,'sf::Texture::update(const Image &image, unsigned int x, unsigned int y)'],['../classsf_1_1Texture.html#ad3cceef238f7d5d2108a98dd38c17fc5',1,'sf::Texture::update(const Window &window)'],['../classsf_1_1Texture.html#a154f246eb8059b602076009ab1cfd175',1,'sf::Texture::update(const Window &window, unsigned int x, unsigned int y)'],['../classsf_1_1VertexBuffer.html#ad100a5f578a91c49a9009e3c6956c82d',1,'sf::VertexBuffer::update(const Vertex *vertices)'],['../classsf_1_1VertexBuffer.html#ae6c8649a64861507010d21e77fbd53fa',1,'sf::VertexBuffer::update(const Vertex *vertices, std::size_t vertexCount, unsigned int offset)'],['../classsf_1_1VertexBuffer.html#a41f8bbcf07f403e7fe29b1b905dc7544',1,'sf::VertexBuffer::update(const VertexBuffer &vertexBuffer)'],['../classsf_1_1Joystick.html#ab85fa9175b4edd3e5a07ee3cde0b0f48',1,'sf::Joystick::update()']]], + ['upload_14',['upload',['../classsf_1_1Ftp.html#a0402d2cec27a197ffba34c88ffaddeac',1,'sf::Ftp']]], + ['usage_15',['Usage',['../classsf_1_1VertexBuffer.html#a3a531528684e63ecb45edd51282f5cb7',1,'sf::VertexBuffer']]], + ['useracceleration_16',['UserAcceleration',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84ad3a399e0025892b7c53e8767cebb9215',1,'sf::Sensor']]], + ['utf_17',['Utf',['../classsf_1_1Utf.html',1,'sf']]], + ['utf_3c_2016_20_3e_18',['Utf< 16 >',['../classsf_1_1Utf_3_0116_01_4.html',1,'sf']]], + ['utf_3c_2032_20_3e_19',['Utf< 32 >',['../classsf_1_1Utf_3_0132_01_4.html',1,'sf']]], + ['utf_3c_208_20_3e_20',['Utf< 8 >',['../classsf_1_1Utf_3_018_01_4.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_15.js b/Space-Invaders/sfml/doc/html/search/all_15.js new file mode 100644 index 000000000..db310fee4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_15.js @@ -0,0 +1,23 @@ +var searchData= +[ + ['v_0',['V',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7aa2e2c8ffa1837e7911ee0c7d045bf8f4',1,'sf::Joystick::V()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875acf235c9f74c25df943ead5f38a01945a',1,'sf::Keyboard::Scan::V()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aec9074abd2d41628d1ecdc14e1b2cd96',1,'sf::Keyboard::V()']]], + ['vec2_1',['Vec2',['../namespacesf_1_1Glsl.html#adeed356d346d87634b4c197a530e4edf',1,'sf::Glsl']]], + ['vec3_2',['Vec3',['../namespacesf_1_1Glsl.html#a9bdd0463b7cb5316244a082007bd50f0',1,'sf::Glsl']]], + ['vec4_3',['Vec4',['../namespacesf_1_1Glsl.html#a7c67253548c58adb77cb14f847f18f83',1,'sf::Glsl']]], + ['vector2_4',['Vector2',['../classsf_1_1Vector2.html',1,'sf::Vector2< T >'],['../classsf_1_1Vector2.html#a58c32383b5291380db4b43a289f75988',1,'sf::Vector2::Vector2()'],['../classsf_1_1Vector2.html#aed26a72164e59e8a4a0aeee2049568f1',1,'sf::Vector2::Vector2(T X, T Y)'],['../classsf_1_1Vector2.html#a3da455e0ae3f8ff6d2fe36d10b332d10',1,'sf::Vector2::Vector2(const Vector2< U > &vector)']]], + ['vector2_3c_20float_20_3e_5',['Vector2< float >',['../classsf_1_1Vector2.html',1,'sf']]], + ['vector2_3c_20unsigned_20int_20_3e_6',['Vector2< unsigned int >',['../classsf_1_1Vector2.html',1,'sf']]], + ['vector3_7',['Vector3',['../classsf_1_1Vector3.html',1,'sf::Vector3< T >'],['../classsf_1_1Vector3.html#aee8be1985c6e45e381ad4071265636f9',1,'sf::Vector3::Vector3()'],['../classsf_1_1Vector3.html#a99ed75b68f58adfa3e9fa0561b424bf6',1,'sf::Vector3::Vector3(T X, T Y, T Z)'],['../classsf_1_1Vector3.html#adb2b2e150025e97ccfa96219bbed59d1',1,'sf::Vector3::Vector3(const Vector3< U > &vector)']]], + ['vendorid_8',['vendorId',['../structsf_1_1Joystick_1_1Identification.html#a827caf37a56492e3430e5ca6b15b5e9f',1,'sf::Joystick::Identification']]], + ['versionnotsupported_9',['VersionNotSupported',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8aeb32a1a087d5fcf1a42663eb40c3c305',1,'sf::Http::Response']]], + ['vertex_10',['Vertex',['../classsf_1_1Vertex.html',1,'sf::Vertex'],['../classsf_1_1Vertex.html#ab9bf849c4c0d82d09bf5bece23d2456a',1,'sf::Vertex::Vertex(const Vector2f &thePosition, const Vector2f &theTexCoords)'],['../classsf_1_1Vertex.html#ad5943f2b3cbc64b6e714bb37ccaf4960',1,'sf::Vertex::Vertex(const Vector2f &thePosition, const Color &theColor, const Vector2f &theTexCoords)'],['../classsf_1_1Shader.html#afaa1aa65e5de37b74d047da9def9f9b3a8718008f827eb32e29bbdd1791c62dce',1,'sf::Shader::Vertex()'],['../classsf_1_1Vertex.html#a6b4c79cd69f7ec1296fede536f39e9c8',1,'sf::Vertex::Vertex()'],['../classsf_1_1Vertex.html#a4dccc5c351b73b6fac169fe442535b40',1,'sf::Vertex::Vertex(const Vector2f &thePosition)'],['../classsf_1_1Vertex.html#a70b0679b4ec531d5bd1a7d0225c7321a',1,'sf::Vertex::Vertex(const Vector2f &thePosition, const Color &theColor)']]], + ['vertexarray_11',['VertexArray',['../classsf_1_1VertexArray.html',1,'sf::VertexArray'],['../classsf_1_1VertexArray.html#a15729e01df8fc0021f9774dfb56295c1',1,'sf::VertexArray::VertexArray()'],['../classsf_1_1VertexArray.html#a4bb1c29a0e3354a035075899d84f02f9',1,'sf::VertexArray::VertexArray(PrimitiveType type, std::size_t vertexCount=0)']]], + ['vertexbuffer_12',['VertexBuffer',['../classsf_1_1VertexBuffer.html',1,'sf::VertexBuffer'],['../classsf_1_1VertexBuffer.html#aba8836c571cef25a0f80e478add1560a',1,'sf::VertexBuffer::VertexBuffer()'],['../classsf_1_1VertexBuffer.html#a3f51dcd61dac52be54ba7b22ebdea7c8',1,'sf::VertexBuffer::VertexBuffer(PrimitiveType type)'],['../classsf_1_1VertexBuffer.html#af2dce0a43e061e5f91b97cf7267427e3',1,'sf::VertexBuffer::VertexBuffer(Usage usage)'],['../classsf_1_1VertexBuffer.html#a326a5c89f1ba01b51b323535494434e8',1,'sf::VertexBuffer::VertexBuffer(PrimitiveType type, Usage usage)'],['../classsf_1_1VertexBuffer.html#a2f2ff1e218cfc749b87f8873e23c016b',1,'sf::VertexBuffer::VertexBuffer(const VertexBuffer &copy)']]], + ['verticalwheel_13',['VerticalWheel',['../classsf_1_1Mouse.html#a60dd479a43f26f200e7957aa11803ff4abd571de908d2b2c4b9f165f29c678496',1,'sf::Mouse']]], + ['videomode_14',['VideoMode',['../classsf_1_1VideoMode.html',1,'sf::VideoMode'],['../classsf_1_1VideoMode.html#a46c35ed41de9e115661dcd529d64e9d3',1,'sf::VideoMode::VideoMode(unsigned int modeWidth, unsigned int modeHeight, unsigned int modeBitsPerPixel=32)'],['../classsf_1_1VideoMode.html#a04c9417e5c304510bef5f6aeb03f6ce1',1,'sf::VideoMode::VideoMode()']]], + ['view_15',['View',['../classsf_1_1View.html',1,'sf::View'],['../classsf_1_1View.html#a28c38308ff089ae5bdacd001d12286d3',1,'sf::View::View()'],['../classsf_1_1View.html#a1d63bc49e041b3b1ff992bb6430e1326',1,'sf::View::View(const FloatRect &rectangle)'],['../classsf_1_1View.html#afdaf84cfc910ef160450d63603457ea4',1,'sf::View::View(const Vector2f &center, const Vector2f &size)']]], + ['volumedown_16',['VolumeDown',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa32039062878ff1d9ed8fb062949f976',1,'sf::Keyboard::Scan']]], + ['volumemute_17',['VolumeMute',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3af7a1640f764386171d4cba53e6d5e2',1,'sf::Keyboard::Scan']]], + ['volumeup_18',['VolumeUp',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa76641e5826ca3a7fb09cefa4d922270',1,'sf::Keyboard::Scan']]], + ['vulkan_19',['Vulkan',['../classsf_1_1Vulkan.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_16.js b/Space-Invaders/sfml/doc/html/search/all_16.js new file mode 100644 index 000000000..36d6eb251 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_16.js @@ -0,0 +1,16 @@ +var searchData= +[ + ['w_0',['W',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a287b960abc4c422a8f4c1bbfc0dfd2a9',1,'sf::Keyboard::Scan::W()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a258aa89e9c6c9aad1ccbaeb41839c5e0',1,'sf::Keyboard::W()']]], + ['wait_1',['wait',['../classsf_1_1SocketSelector.html#a9cfda5475f17925e65889394d70af702',1,'sf::SocketSelector::wait()'],['../classsf_1_1Thread.html#a724b1f94c2d54f84280f2f78bde95fa0',1,'sf::Thread::wait()']]], + ['wait_2',['Wait',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aabeb51ea58e48e4477ab802d46ad2cbdd',1,'sf::Cursor']]], + ['waitevent_3',['waitEvent',['../classsf_1_1WindowBase.html#aa1c100a69b5bc0c84e23a4652d51ac41',1,'sf::WindowBase']]], + ['wheel_4',['Wheel',['../classsf_1_1Mouse.html#a60dd479a43f26f200e7957aa11803ff4',1,'sf::Mouse']]], + ['wheel_5',['wheel',['../structsf_1_1Event_1_1MouseWheelScrollEvent.html#a1d82dccecc46968d517b2fc66639dd74',1,'sf::Event::MouseWheelScrollEvent']]], + ['white_6',['White',['../classsf_1_1Color.html#a4fd874712178d9e206f53226002aa4ca',1,'sf::Color']]], + ['width_7',['width',['../classsf_1_1Rect.html#a4dd5b9d4333bebbc51bd309298fd500f',1,'sf::Rect::width()'],['../structsf_1_1Event_1_1SizeEvent.html#a20ea1b78c9bb1604432f8f0067bbfd94',1,'sf::Event::SizeEvent::width()'],['../classsf_1_1VideoMode.html#a9b3b2ad2cac6b9c266823fb5ed506d90',1,'sf::VideoMode::width()']]], + ['window_8',['Window',['../classsf_1_1Window.html',1,'sf::Window'],['../classsf_1_1Window.html#a5359122166b4dc492c3d25caf08ccfc4',1,'sf::Window::Window()'],['../classsf_1_1Window.html#a1bee771baecbae6d357871929dc042a2',1,'sf::Window::Window(VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())'],['../classsf_1_1Window.html#a6d60912633bff9d33cf3ade4e0201de4',1,'sf::Window::Window(WindowHandle handle, const ContextSettings &settings=ContextSettings())']]], + ['window_20module_9',['Window module',['../group__window.html',1,'']]], + ['windowbase_10',['WindowBase',['../classsf_1_1WindowBase.html',1,'sf::WindowBase'],['../classsf_1_1WindowBase.html#a0cfe9d015cc95b89ef862c8d8050a964',1,'sf::WindowBase::WindowBase()'],['../classsf_1_1WindowBase.html#ab150dbdb19eead86bcecb42cf3609e63',1,'sf::WindowBase::WindowBase(VideoMode mode, const String &title, Uint32 style=Style::Default)'],['../classsf_1_1WindowBase.html#ab4e3667dddddfeda57d124de24f93ac1',1,'sf::WindowBase::WindowBase(WindowHandle handle)']]], + ['windowhandle_11',['WindowHandle',['../group__window.html#gaed947028b0698a812cad2f97bfe9caa3',1,'sf']]], + ['write_12',['write',['../classsf_1_1OutputSoundFile.html#adfcf525fced71121f336fa89faac3d67',1,'sf::OutputSoundFile::write()'],['../classsf_1_1SoundFileWriter.html#a4ce597e7682d22c5b2c98d77e931a1da',1,'sf::SoundFileWriter::write()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_17.js b/Space-Invaders/sfml/doc/html/search/all_17.js new file mode 100644 index 000000000..80ed1e1ec --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_17.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['x_0',['x',['../classsf_1_1Vector2.html#a1e6ad77fa155f3753bfb92699bd28141',1,'sf::Vector2::x()'],['../classsf_1_1Vector3.html#a3cb0c769390bc37c346bb1a69e510d16',1,'sf::Vector3::x()'],['../structsf_1_1Event_1_1MouseMoveEvent.html#aa3a23809afb905cbb52c66d8512e21fd',1,'sf::Event::MouseMoveEvent::x()'],['../structsf_1_1Event_1_1MouseButtonEvent.html#a49b937b311729174950787781aafcdc7',1,'sf::Event::MouseButtonEvent::x()'],['../structsf_1_1Event_1_1MouseWheelEvent.html#a3079803f836ed7208f43b60332ab053e',1,'sf::Event::MouseWheelEvent::x()'],['../structsf_1_1Event_1_1MouseWheelScrollEvent.html#a3d17cae0568d18083f879655abdc8ae4',1,'sf::Event::MouseWheelScrollEvent::x()'],['../structsf_1_1Event_1_1TouchEvent.html#a8993963790b850caa68b98d3cad2be45',1,'sf::Event::TouchEvent::x()'],['../structsf_1_1Event_1_1SensorEvent.html#aa6ccbd13c181b866a6467462158d93d9',1,'sf::Event::SensorEvent::x()']]], + ['x_1',['X',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a95dc8b9bf7b0a2157fc67891c54c401e',1,'sf::Joystick::X()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af4f6ad0b93dd6bc360badd5abe812a67',1,'sf::Keyboard::Scan::X()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a012f5ee9d518e9e24caa087fbddc0594',1,'sf::Keyboard::X()']]], + ['xbutton1_2',['XButton1',['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90aecc7f3ce9ad6a60b9b0027876446b8d7',1,'sf::Mouse']]], + ['xbutton2_3',['XButton2',['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90a03fa056fd0dd9d629c205d91a8ef1b5a',1,'sf::Mouse']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_18.js b/Space-Invaders/sfml/doc/html/search/all_18.js new file mode 100644 index 000000000..98273c120 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_18.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['y_0',['y',['../classsf_1_1Vector2.html#a420f2481b015f4eb929c75f2af564299',1,'sf::Vector2::y()'],['../classsf_1_1Vector3.html#a6590d50ccb862c5efc5512e974e9b794',1,'sf::Vector3::y()'],['../structsf_1_1Event_1_1MouseMoveEvent.html#a86d78a2fba5b3abda16ca059f2392ad4',1,'sf::Event::MouseMoveEvent::y()'],['../structsf_1_1Event_1_1MouseButtonEvent.html#aae4735071868d4411d1782bf67619d64',1,'sf::Event::MouseButtonEvent::y()'],['../structsf_1_1Event_1_1MouseWheelEvent.html#a7ea1b8d8c28e2f530c6e9e6d9a5d32d3',1,'sf::Event::MouseWheelEvent::y()'],['../structsf_1_1Event_1_1MouseWheelScrollEvent.html#aa38bf23704162024eed19917eef3853c',1,'sf::Event::MouseWheelScrollEvent::y()'],['../structsf_1_1Event_1_1TouchEvent.html#add80639dc68bc37e3275744d501cdbe0',1,'sf::Event::TouchEvent::y()'],['../structsf_1_1Event_1_1SensorEvent.html#aecafcd25ecb3ba486e42284e4bb69a57',1,'sf::Event::SensorEvent::y()']]], + ['y_1',['Y',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a51ef1455f7511ad4a78ba241d66593ce',1,'sf::Joystick::Y()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6305407064e0beb4f0499166e087ff22',1,'sf::Keyboard::Scan::Y()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a5d877e63d1353e0fc0a0757a87a7bd0e',1,'sf::Keyboard::Y()']]], + ['yellow_2',['Yellow',['../classsf_1_1Color.html#af8896b5f56650935f5b9d72d528802c7',1,'sf::Color']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_19.js b/Space-Invaders/sfml/doc/html/search/all_19.js new file mode 100644 index 000000000..6e30fc5e7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_19.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['z_0',['Z',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a7c37a1240b2dafbbfc5c1a0e23911315',1,'sf::Joystick::Z()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a2aca2d41fc86e4e31be7220d81ce589a',1,'sf::Keyboard::Scan::Z()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a4e12efd6478a2d174264f29b0b41ab43',1,'sf::Keyboard::Z()']]], + ['z_1',['z',['../classsf_1_1Vector3.html#a2f36ab4b552c028e3a9734c1ad4df7d1',1,'sf::Vector3::z()'],['../structsf_1_1Event_1_1SensorEvent.html#a5704e0d0b82b07f051cc858894f3ea43',1,'sf::Event::SensorEvent::z()']]], + ['zero_2',['Zero',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbafda2d66c3c3da15cd3b42338fbf6d2ba',1,'sf::BlendMode::Zero()'],['../classsf_1_1Time.html#a8db127b632fa8da21550e7282af11fa0',1,'sf::Time::Zero()']]], + ['zoom_3',['zoom',['../classsf_1_1View.html#a4a72a360a5792fbe4e99cd6feaf7726e',1,'sf::View']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_1a.js b/Space-Invaders/sfml/doc/html/search/all_1a.js new file mode 100644 index 000000000..09913740f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_1a.js @@ -0,0 +1,43 @@ +var searchData= +[ + ['_7ealresource_0',['~AlResource',['../classsf_1_1AlResource.html#a74ad78198cddcb6e5d847177364049db',1,'sf::AlResource']]], + ['_7econtext_1',['~Context',['../classsf_1_1Context.html#a805b1bbdb3e52b1fda7c9bf2cd6ca86b',1,'sf::Context']]], + ['_7ecursor_2',['~Cursor',['../classsf_1_1Cursor.html#a777ba6a1d0d68f8eb9dc85976a5b9727',1,'sf::Cursor']]], + ['_7edrawable_3',['~Drawable',['../classsf_1_1Drawable.html#a906002f2df7beb5edbddf5bbef96f120',1,'sf::Drawable']]], + ['_7efileinputstream_4',['~FileInputStream',['../classsf_1_1FileInputStream.html#ad49ae2025ff2183f80067943a7d0276d',1,'sf::FileInputStream']]], + ['_7efont_5',['~Font',['../classsf_1_1Font.html#aa18a3c62e6e01e9a21c531b5cad4b7f2',1,'sf::Font']]], + ['_7eftp_6',['~Ftp',['../classsf_1_1Ftp.html#a2edfa8e9009caf27bce74459ae76dc52',1,'sf::Ftp']]], + ['_7eglresource_7',['~GlResource',['../classsf_1_1GlResource.html#ab99035b67052331d1e8cf67abd93de98',1,'sf::GlResource']]], + ['_7eimage_8',['~Image',['../classsf_1_1Image.html#a0ba22a38e6c96e3b37dd88198046de83',1,'sf::Image']]], + ['_7einputsoundfile_9',['~InputSoundFile',['../classsf_1_1InputSoundFile.html#a326a1a486587038123de0c187bf5c635',1,'sf::InputSoundFile']]], + ['_7einputstream_10',['~InputStream',['../classsf_1_1InputStream.html#a4b2eb0f92323e630bd0542bc6191682e',1,'sf::InputStream']]], + ['_7elock_11',['~Lock',['../classsf_1_1Lock.html#a8168b36323a18ccf5b6bc531d964aec5',1,'sf::Lock']]], + ['_7emusic_12',['~Music',['../classsf_1_1Music.html#a4c65860fed2f01d0eaa6c4199870414b',1,'sf::Music']]], + ['_7emutex_13',['~Mutex',['../classsf_1_1Mutex.html#a9f76a67b7b6d3918131a692179b4e3f2',1,'sf::Mutex']]], + ['_7enoncopyable_14',['~NonCopyable',['../classsf_1_1NonCopyable.html#a8274ffbf46014f5f7f364befb52c7728',1,'sf::NonCopyable']]], + ['_7eoutputsoundfile_15',['~OutputSoundFile',['../classsf_1_1OutputSoundFile.html#a1492adbfef1f391d720afb56f068182e',1,'sf::OutputSoundFile']]], + ['_7epacket_16',['~Packet',['../classsf_1_1Packet.html#adc0490ca3c7c3d1e321bd742e5213913',1,'sf::Packet']]], + ['_7erendertarget_17',['~RenderTarget',['../classsf_1_1RenderTarget.html#a9abd1654a99fba46f6887b9c625b9b06',1,'sf::RenderTarget']]], + ['_7erendertexture_18',['~RenderTexture',['../classsf_1_1RenderTexture.html#a94b84ab9335be84d2a014c964d973304',1,'sf::RenderTexture']]], + ['_7erenderwindow_19',['~RenderWindow',['../classsf_1_1RenderWindow.html#a3407e36bfc1752d723140438a825365c',1,'sf::RenderWindow']]], + ['_7eshader_20',['~Shader',['../classsf_1_1Shader.html#a4bac6cc8b046ecd8fb967c145a2380e6',1,'sf::Shader']]], + ['_7eshape_21',['~Shape',['../classsf_1_1Shape.html#a2262aceb9df52d4275c19633592f19bf',1,'sf::Shape']]], + ['_7esocket_22',['~Socket',['../classsf_1_1Socket.html#a79a4b5918f0b34a2f8db449089694788',1,'sf::Socket']]], + ['_7esocketselector_23',['~SocketSelector',['../classsf_1_1SocketSelector.html#a9069cd61208260b8ed9cf233afa1f73d',1,'sf::SocketSelector']]], + ['_7esound_24',['~Sound',['../classsf_1_1Sound.html#ad0792c35310eba2dffd8489c80fad076',1,'sf::Sound']]], + ['_7esoundbuffer_25',['~SoundBuffer',['../classsf_1_1SoundBuffer.html#aea240161724ffba74a0d6a9e277d3cd5',1,'sf::SoundBuffer']]], + ['_7esoundbufferrecorder_26',['~SoundBufferRecorder',['../classsf_1_1SoundBufferRecorder.html#a350f7f885ccfd12b4c6c120c23695637',1,'sf::SoundBufferRecorder']]], + ['_7esoundfilereader_27',['~SoundFileReader',['../classsf_1_1SoundFileReader.html#a34163297f302d15818c76b54f815acc8',1,'sf::SoundFileReader']]], + ['_7esoundfilewriter_28',['~SoundFileWriter',['../classsf_1_1SoundFileWriter.html#a76944fc158688f35050bd5b592c90270',1,'sf::SoundFileWriter']]], + ['_7esoundrecorder_29',['~SoundRecorder',['../classsf_1_1SoundRecorder.html#acc599e61aaa47edaae88cf43f0a43549',1,'sf::SoundRecorder']]], + ['_7esoundsource_30',['~SoundSource',['../classsf_1_1SoundSource.html#a77c7c1524f8cb81df2de9375b0f87c5c',1,'sf::SoundSource']]], + ['_7esoundstream_31',['~SoundStream',['../classsf_1_1SoundStream.html#a1fafb9f1ca572d23d7d6a17921860d85',1,'sf::SoundStream']]], + ['_7etexture_32',['~Texture',['../classsf_1_1Texture.html#a9c5354ad40eb1c5aeeeb21f57ccd7e6c',1,'sf::Texture']]], + ['_7ethread_33',['~Thread',['../classsf_1_1Thread.html#af77942fc1730af7c31bc4c3a913a9c1d',1,'sf::Thread']]], + ['_7ethreadlocal_34',['~ThreadLocal',['../classsf_1_1ThreadLocal.html#acc612bddfd0f0507b1c5da8b3b8c75c2',1,'sf::ThreadLocal']]], + ['_7etransformable_35',['~Transformable',['../classsf_1_1Transformable.html#a43253abcb863195a673c2a347a7425cc',1,'sf::Transformable']]], + ['_7etransientcontextlock_36',['~TransientContextLock',['../classsf_1_1GlResource_1_1TransientContextLock.html#a169285281b252ac8d54523b0fcc4b814',1,'sf::GlResource::TransientContextLock']]], + ['_7evertexbuffer_37',['~VertexBuffer',['../classsf_1_1VertexBuffer.html#acfbb3b16221bfb9406fcaa18cfcac3e7',1,'sf::VertexBuffer']]], + ['_7ewindow_38',['~Window',['../classsf_1_1Window.html#ac30eb6ea5f5594204944d09d4bd69a97',1,'sf::Window']]], + ['_7ewindowbase_39',['~WindowBase',['../classsf_1_1WindowBase.html#a7aac2a828b6bbd39b7195bb0545a2c47',1,'sf::WindowBase']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_2.js b/Space-Invaders/sfml/doc/html/search/all_2.js new file mode 100644 index 000000000..57c55b92c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_2.js @@ -0,0 +1,61 @@ +var searchData= +[ + ['c_0',['C',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad3acc09d4a2dc958837e48b80af01a4c',1,'sf::Keyboard::Scan::C()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a0d586c4ec0cd6b537cb6f49180fedecc',1,'sf::Keyboard::C()']]], + ['capslock_1',['CapsLock',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6a1c1f6a4dfac0c5170296a88da1dd57',1,'sf::Keyboard::Scan']]], + ['capture_2',['capture',['../classsf_1_1RenderWindow.html#a5a784b8a09bf4a8bc97ef9e0a8957c35',1,'sf::RenderWindow']]], + ['changedirectory_3',['changeDirectory',['../classsf_1_1Ftp.html#a7e93488ea6330dd4dd76e428da9bb6d3',1,'sf::Ftp']]], + ['channelcount_4',['channelCount',['../structsf_1_1SoundFileReader_1_1Info.html#ac748bb30768d1a3caf329e95d31d6d2a',1,'sf::SoundFileReader::Info']]], + ['chunk_5',['Chunk',['../structsf_1_1SoundStream_1_1Chunk.html',1,'sf::SoundStream']]], + ['circleshape_6',['CircleShape',['../classsf_1_1CircleShape.html#aaebe705e7180cd55588eb19488af3af1',1,'sf::CircleShape::CircleShape()'],['../classsf_1_1CircleShape.html',1,'sf::CircleShape']]], + ['clear_7',['clear',['../classsf_1_1RenderTarget.html#a6bb6f0ba348f2b1e2f46114aeaf60f26',1,'sf::RenderTarget::clear()'],['../classsf_1_1VertexArray.html#a3654c424aca1f9e468f369bc777c839c',1,'sf::VertexArray::clear()'],['../classsf_1_1Packet.html#a133ea8b8fe6e93c230f0d79f19a3bf0d',1,'sf::Packet::clear()'],['../classsf_1_1SocketSelector.html#a76e650acb0199d4be91e90a493fbc91a',1,'sf::SocketSelector::clear()'],['../classsf_1_1String.html#a391c1b4950cbf3d3f8040cea73af2969',1,'sf::String::clear()']]], + ['clipboard_8',['Clipboard',['../classsf_1_1Clipboard.html',1,'sf']]], + ['clock_9',['Clock',['../classsf_1_1Clock.html#abbc959c7830ca7c3a4da133cb506d3fd',1,'sf::Clock::Clock()'],['../classsf_1_1Clock.html',1,'sf::Clock']]], + ['close_10',['Close',['../group__window.html#gga97d7ee508bea4507ab40271518c732ffae07a7d411d5acf28f4a9a4b76a3a9493',1,'sf::Style']]], + ['close_11',['close',['../classsf_1_1InputSoundFile.html#ad28182aea9dc9f7d0dfc7f78691825b4',1,'sf::InputSoundFile::close()'],['../classsf_1_1OutputSoundFile.html#ad20c867d7e565d533da029f31ea5a337',1,'sf::OutputSoundFile::close()'],['../classsf_1_1Socket.html#a71f2f5c2aa99e01cafe824fee4c573be',1,'sf::Socket::close()'],['../classsf_1_1TcpListener.html#a3a00a850506bd0f9f48867a0fe59556b',1,'sf::TcpListener::close()'],['../classsf_1_1Window.html#a7355b916852af56cfe3cc00feed9f419',1,'sf::Window::close()'],['../classsf_1_1WindowBase.html#a9a5ea0ba0ab584dbd11bbfea233b457f',1,'sf::WindowBase::close()']]], + ['closed_12',['Closed',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa316e4212e083f1dce79efd8d9e9c0a95',1,'sf::Event']]], + ['closingconnection_13',['ClosingConnection',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bab23931490fc2d1df3081d651fe0f4d6e',1,'sf::Ftp::Response']]], + ['closingdataconnection_14',['ClosingDataConnection',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bac723ebc8a38913bbf0d9504556cbaaa6',1,'sf::Ftp::Response']]], + ['code_15',['code',['../structsf_1_1Event_1_1KeyEvent.html#a2879fdab8a68cb1c6ecc45730a2d0e61',1,'sf::Event::KeyEvent']]], + ['color_16',['Color',['../classsf_1_1Color.html#ac2eb4393fb11ad3fa3ccf34e92fe08e4',1,'sf::Color::Color()'],['../classsf_1_1Color.html#ac791dc61be4c60baac50fe700f1c9850',1,'sf::Color::Color(Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha=255)'],['../classsf_1_1Color.html#a5449f4b2b9a78230d40ce2c223c9ab2e',1,'sf::Color::Color(Uint32 color)']]], + ['color_17',['color',['../classsf_1_1Vertex.html#a799faa0629442e90f07cd2edb568ff80',1,'sf::Vertex']]], + ['color_18',['Color',['../classsf_1_1Color.html',1,'sf']]], + ['colordstfactor_19',['colorDstFactor',['../structsf_1_1BlendMode.html#adee68ee59e7f1bf71d12db03d251104d',1,'sf::BlendMode']]], + ['colorequation_20',['colorEquation',['../structsf_1_1BlendMode.html#aed12f06eb7f50a1b95b892b0964857b1',1,'sf::BlendMode']]], + ['colorsrcfactor_21',['colorSrcFactor',['../structsf_1_1BlendMode.html#a32d1a55dbfada86a06d9b881dc8ccf7b',1,'sf::BlendMode']]], + ['combine_22',['combine',['../classsf_1_1Transform.html#ad8403f888799b5c9f781cb9f3757f2a4',1,'sf::Transform']]], + ['comma_23',['Comma',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a035f3ce4c48fecfd7d2c77987710e5fa',1,'sf::Keyboard::Scan::Comma()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab7374f48cc79e3085739160b8e3ef2f9',1,'sf::Keyboard::Comma()']]], + ['commandnotimplemented_24',['CommandNotImplemented',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba2ca4834c756c81b924ebed696fcba0a8',1,'sf::Ftp::Response']]], + ['commandunknown_25',['CommandUnknown',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba75bdf0b6844fa9c07b3c25647d22c269',1,'sf::Ftp::Response']]], + ['connect_26',['connect',['../classsf_1_1Ftp.html#af02fb3de3f450a50a27981961c69c860',1,'sf::Ftp::connect()'],['../classsf_1_1TcpSocket.html#a68cd42d5ab70ab54b16787f555951c40',1,'sf::TcpSocket::connect()']]], + ['connectionclosed_27',['ConnectionClosed',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bad1e5dcf298ce30c528261435f1a2eb53',1,'sf::Ftp::Response']]], + ['connectionfailed_28',['ConnectionFailed',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba51aa367cc1e85a45ea3c7be48730e990',1,'sf::Ftp::Response::ConnectionFailed()'],['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a7f307376f13bdc06b24fc274ecd2aa60',1,'sf::Http::Response::ConnectionFailed()']]], + ['constiterator_29',['ConstIterator',['../classsf_1_1String.html#a8e18efc2e8464f6eb82818902d527efa',1,'sf::String']]], + ['contains_30',['contains',['../classsf_1_1Rect.html#a45c77c073a7a4d9232218ab2838f41bb',1,'sf::Rect::contains(const Vector2< T > &point) const'],['../classsf_1_1Rect.html#a910b998c92756157e1407e1363f93212',1,'sf::Rect::contains(T x, T y) const']]], + ['context_31',['Context',['../classsf_1_1Context.html#aba22797a790706ca2c5c04ee39f2b555',1,'sf::Context::Context()'],['../classsf_1_1Context.html#a2a9e3529e48919120e6b6fc10bad296c',1,'sf::Context::Context(const ContextSettings &settings, unsigned int width, unsigned int height)'],['../classsf_1_1Context.html',1,'sf::Context']]], + ['contextsettings_32',['ContextSettings',['../structsf_1_1ContextSettings.html#ac56869ccbb6bf0df48b88880754e12b7',1,'sf::ContextSettings::ContextSettings()'],['../structsf_1_1ContextSettings.html',1,'sf::ContextSettings']]], + ['control_33',['control',['../structsf_1_1Event_1_1KeyEvent.html#a9255861c2f88501d80ad6b44a310b62f',1,'sf::Event::KeyEvent']]], + ['convexshape_34',['ConvexShape',['../classsf_1_1ConvexShape.html#af9981b8909569b381b3fccf32fc69856',1,'sf::ConvexShape::ConvexShape()'],['../classsf_1_1ConvexShape.html',1,'sf::ConvexShape']]], + ['coordinatetype_35',['CoordinateType',['../classsf_1_1Texture.html#aa6fd3bbe3c334b3c4428edfb2765a82e',1,'sf::Texture']]], + ['copy_36',['copy',['../classsf_1_1Image.html#ab2fa337c956f85f93377dcb52153a45a',1,'sf::Image']]], + ['copy_37',['Copy',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a7ecdffb69ce6c849414e4a818d3103a7',1,'sf::Keyboard::Scan']]], + ['copytoimage_38',['copyToImage',['../classsf_1_1Texture.html#a77e18a70de2e525ac5e4a7cd95f614b9',1,'sf::Texture']]], + ['core_39',['Core',['../structsf_1_1ContextSettings.html#af2e91e57e8d26c40afe2ec8efaa32a2cacb581130734cbd87cbbc9438429f4a8b',1,'sf::ContextSettings']]], + ['count_40',['Count',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84afcb4a80eb9e3f927c5837207a1b9eb29',1,'sf::Sensor']]], + ['count_41',['count',['../classsf_1_1Utf_3_018_01_4.html#af1f15d9a772ee887be39e97431e15d32',1,'sf::Utf< 8 >::count()'],['../classsf_1_1Utf_3_0116_01_4.html#a6df8d9be8211ffe1095b3b82eac83f6f',1,'sf::Utf< 16 >::count()'],['../classsf_1_1Utf_3_0132_01_4.html#a9b18c32b9e6d4b3126e9b4af45988b55',1,'sf::Utf< 32 >::count()']]], + ['count_42',['Count',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aae51749211243cab2ab270b29cdc32a70',1,'sf::Event::Count()'],['../classsf_1_1Joystick.html#aee00dd432eacd8369d279b47c3ab4cc5a6e0a2a95bc1da277610c04d80f52715e',1,'sf::Joystick::Count()']]], + ['create_43',['create',['../classsf_1_1RenderTexture.html#a49b7b723a80f89bc409a942364351dc3',1,'sf::RenderTexture::create()'],['../classsf_1_1Image.html#a2a67930e2fd9ad97cf004e918cf5832b',1,'sf::Image::create(unsigned int width, unsigned int height, const Color &color=Color(0, 0, 0))'],['../classsf_1_1Image.html#a1c2b960ea12bdbb29e80934ce5268ebf',1,'sf::Image::create(unsigned int width, unsigned int height, const Uint8 *pixels)'],['../classsf_1_1RenderTexture.html#a0e945c4ce7703591c7f240b169744603',1,'sf::RenderTexture::create()'],['../classsf_1_1Texture.html#a89b4c7d204acf1033c3a1b6e0a3ad0a3',1,'sf::Texture::create()'],['../classsf_1_1VertexBuffer.html#aa68e128d59c7f7d5eb0d4d94125439a5',1,'sf::VertexBuffer::create()'],['../classsf_1_1Socket.html#aafbe140f4b1921e0d19e88cf7a61dcbc',1,'sf::Socket::create()'],['../classsf_1_1Socket.html#af1dd898f7aa3ead7ff7b2d1c20e97781',1,'sf::Socket::create(SocketHandle handle)'],['../classsf_1_1Window.html#ac6a58d9c26a18f0e70888d0f53e154c1',1,'sf::Window::create(VideoMode mode, const String &title, Uint32 style=Style::Default)'],['../classsf_1_1Window.html#a6518b989614750e90d9784f4d05ce02c',1,'sf::Window::create(VideoMode mode, const String &title, Uint32 style, const ContextSettings &settings)'],['../classsf_1_1Window.html#a5ee0c5262df6cc4e1a8031ae6848437f',1,'sf::Window::create(WindowHandle handle)'],['../classsf_1_1Window.html#a064dd5dd7bb337fb9f5635f580081a1e',1,'sf::Window::create(WindowHandle handle, const ContextSettings &settings)'],['../classsf_1_1WindowBase.html#a3b888387b7bd4be38d6db1234c8d7ad4',1,'sf::WindowBase::create(VideoMode mode, const String &title, Uint32 style=Style::Default)'],['../classsf_1_1WindowBase.html#a4e4968e15e33fd70629983f635bcc21c',1,'sf::WindowBase::create(WindowHandle handle)']]], + ['created_44',['Created',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a0a6e8bafa9365a0ed10b8a9cbfd0649b',1,'sf::Http::Response']]], + ['createdirectory_45',['createDirectory',['../classsf_1_1Ftp.html#a247b84c4b25da37804218c2b748c4787',1,'sf::Ftp']]], + ['createmaskfromcolor_46',['createMaskFromColor',['../classsf_1_1Image.html#a22f13f8c242a6b38eb73cc176b37ae34',1,'sf::Image']]], + ['createreaderfromfilename_47',['createReaderFromFilename',['../classsf_1_1SoundFileFactory.html#ae68185540db5e2a451d626be45036fe0',1,'sf::SoundFileFactory']]], + ['createreaderfrommemory_48',['createReaderFromMemory',['../classsf_1_1SoundFileFactory.html#a2384ed647b08c5b2bbf43566d5d7b5fd',1,'sf::SoundFileFactory']]], + ['createreaderfromstream_49',['createReaderFromStream',['../classsf_1_1SoundFileFactory.html#af64ce454cde415ebd3ca5442801d87d8',1,'sf::SoundFileFactory']]], + ['createvulkansurface_50',['createVulkanSurface',['../classsf_1_1WindowBase.html#a4bcb435cdb954f991f493976263a2fc1',1,'sf::WindowBase']]], + ['createwriterfromfilename_51',['createWriterFromFilename',['../classsf_1_1SoundFileFactory.html#a2bc9da55d78be2c41a273bbbea4c0978',1,'sf::SoundFileFactory']]], + ['cross_52',['Cross',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aaf3b3213aad68863c7dec96587681fecd',1,'sf::Cursor']]], + ['currenttexture_53',['CurrentTexture',['../classsf_1_1Shader.html#ac84c7953eec2e19358ea6e2cc5385b8d',1,'sf::Shader']]], + ['currenttexturetype_54',['CurrentTextureType',['../structsf_1_1Shader_1_1CurrentTextureType.html',1,'sf::Shader']]], + ['cursor_55',['Cursor',['../classsf_1_1Cursor.html#a6a36a0a5943b22b77b00cac839dd715c',1,'sf::Cursor::Cursor()'],['../classsf_1_1Cursor.html',1,'sf::Cursor']]], + ['cut_56',['Cut',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af5b15a621ad19b8f357821f7adfc6bb1',1,'sf::Keyboard::Scan']]], + ['cyan_57',['Cyan',['../classsf_1_1Color.html#a64ae9beb0b9a5865dd811cda4bb18340',1,'sf::Color']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_3.js b/Space-Invaders/sfml/doc/html/search/all_3.js new file mode 100644 index 000000000..b23f6e106 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_3.js @@ -0,0 +1,35 @@ +var searchData= +[ + ['d_0',['D',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a96ec4a613d00dce6f8d90adc8728864a',1,'sf::Keyboard::Scan::D()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ae778600bd3e878b59df1dbdd5877ba7a',1,'sf::Keyboard::D()']]], + ['dash_1',['Dash',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a401a183dcfde0a06cb60fe6c91fa1e39',1,'sf::Keyboard']]], + ['dataconnectionalreadyopened_2',['DataConnectionAlreadyOpened',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bafa52d19bc813d69055f4cc390d4a76ca',1,'sf::Ftp::Response']]], + ['dataconnectionopened_3',['DataConnectionOpened',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3badc78ed87d5bddb174fa3c16707ac2f2d',1,'sf::Ftp::Response']]], + ['dataconnectionunavailable_4',['DataConnectionUnavailable',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba757b89ff1f236941f7759b0ed0c28b88',1,'sf::Ftp::Response']]], + ['debug_5',['Debug',['../structsf_1_1ContextSettings.html#af2e91e57e8d26c40afe2ec8efaa32a2ca6043f67afb3d48918d5336474eabaafc',1,'sf::ContextSettings']]], + ['decode_6',['decode',['../classsf_1_1Utf_3_018_01_4.html#a59d4e8d5832961e62b263d308b72bf4b',1,'sf::Utf< 8 >::decode()'],['../classsf_1_1Utf_3_0116_01_4.html#a17be6fc08e51182e7ac8bf9269dfae37',1,'sf::Utf< 16 >::decode()'],['../classsf_1_1Utf_3_0132_01_4.html#ad754ce8476f7b80563890dec12cefd46',1,'sf::Utf< 32 >::decode(In begin, In end, Uint32 &output, Uint32 replacement=0)']]], + ['decodeansi_7',['decodeAnsi',['../classsf_1_1Utf_3_0132_01_4.html#a68346ea833f88267a7c739d4d96fb86f',1,'sf::Utf< 32 >']]], + ['decodewide_8',['decodeWide',['../classsf_1_1Utf_3_0132_01_4.html#a043fe25f5f4dbc205e78e6f1d99840dc',1,'sf::Utf< 32 >']]], + ['default_9',['Default',['../group__window.html#gga97d7ee508bea4507ab40271518c732ffa5597cd420fc461807e4a201c92adea37',1,'sf::Style::Default()'],['../classsf_1_1RenderStates.html#ad29672df29f19ce50c3021d95f2bb062',1,'sf::RenderStates::Default()'],['../structsf_1_1ContextSettings.html#af2e91e57e8d26c40afe2ec8efaa32a2cabf868dcb751b909bf031484ed42a93bb',1,'sf::ContextSettings::Default()']]], + ['delete_10',['Delete',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598abc9555b94c1b896185015ec3990999f9',1,'sf::Http::Request::Delete()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a2f071cf261d91b0facc044c2ba11ae94',1,'sf::Keyboard::Scan::Delete()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab66187002fc7f6695ef3d05237b93a38',1,'sf::Keyboard::Delete()']]], + ['deletedirectory_11',['deleteDirectory',['../classsf_1_1Ftp.html#a2a8a7ef9144204b5b319c9a4be8806c2',1,'sf::Ftp']]], + ['deletefile_12',['deleteFile',['../classsf_1_1Ftp.html#a8aa272b0eb7769a850006e70fcad370f',1,'sf::Ftp']]], + ['delocalize_13',['delocalize',['../classsf_1_1Keyboard.html#af9fd530c73b8a2cd6094d373e879eb00',1,'sf::Keyboard']]], + ['delta_14',['delta',['../structsf_1_1Event_1_1MouseWheelEvent.html#a4d02b524b5530c7863e7b0f211fa522c',1,'sf::Event::MouseWheelEvent::delta()'],['../structsf_1_1Event_1_1MouseWheelScrollEvent.html#ac45c164997a594d424071e74b53b5817',1,'sf::Event::MouseWheelScrollEvent::delta()']]], + ['deprecated_20list_15',['Deprecated List',['../deprecated.html',1,'']]], + ['depthbits_16',['depthBits',['../structsf_1_1ContextSettings.html#a4809e22089c2af7276b8809b5aede7bb',1,'sf::ContextSettings']]], + ['directoryok_17',['DirectoryOk',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba06d26e95a170fc422af13def415e0437',1,'sf::Ftp::Response']]], + ['directoryresponse_18',['DirectoryResponse',['../classsf_1_1Ftp_1_1DirectoryResponse.html#a36b6d2728fa53c4ad37b7a6307f4d388',1,'sf::Ftp::DirectoryResponse::DirectoryResponse()'],['../classsf_1_1Ftp_1_1DirectoryResponse.html',1,'sf::Ftp::DirectoryResponse']]], + ['directorystatus_19',['DirectoryStatus',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba8729460a695013cc96330e2fced0ae1f',1,'sf::Ftp::Response']]], + ['disconnect_20',['disconnect',['../classsf_1_1Ftp.html#acf7459926f3391cd06bf84337ed6a0f4',1,'sf::Ftp::disconnect()'],['../classsf_1_1TcpSocket.html#ac18f518a9be3d6be5e74b9404c253c1e',1,'sf::TcpSocket::disconnect()']]], + ['disconnected_21',['Disconnected',['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dcab215141f756acdc23c67fad149710eb1',1,'sf::Socket']]], + ['display_22',['display',['../classsf_1_1RenderTexture.html#af92886d5faef3916caff9fa9ab32c555',1,'sf::RenderTexture::display()'],['../classsf_1_1Window.html#adabf839cb103ac96cfc82f781638772a',1,'sf::Window::display()']]], + ['divide_23',['Divide',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142afae3dc28752954f0bfe298ac52f58cb6',1,'sf::Keyboard']]], + ['done_24',['Done',['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dca1de3a85bc56d3ae85b3d0f3cfd04ae90',1,'sf::Socket']]], + ['down_25',['Down',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a33dd676edbdf0817d7a65b21df3d0dca',1,'sf::Keyboard::Down()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a18774f082756cdee120731cd53689008',1,'sf::Keyboard::Scan::Down()']]], + ['download_26',['download',['../classsf_1_1Ftp.html#a20c1600ec5fd6f5a2ad1429ab8aa5df4',1,'sf::Ftp']]], + ['draw_27',['draw',['../classsf_1_1Drawable.html#a90d2c88bba9b035a0844eccb380ef631',1,'sf::Drawable::draw()'],['../classsf_1_1RenderTarget.html#a12417a3bcc245c41d957b29583556f39',1,'sf::RenderTarget::draw(const Drawable &drawable, const RenderStates &states=RenderStates::Default)'],['../classsf_1_1RenderTarget.html#a976bc94057799eb9f8a18ac5fdfd9b73',1,'sf::RenderTarget::draw(const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default)'],['../classsf_1_1RenderTarget.html#a07cb25d4557a30146b24b25b242310ea',1,'sf::RenderTarget::draw(const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default)'],['../classsf_1_1RenderTarget.html#a3dc4d06f081d36ca1e8f1a1298d49abc',1,'sf::RenderTarget::draw(const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default)']]], + ['drawable_28',['Drawable',['../classsf_1_1Drawable.html',1,'sf']]], + ['dstalpha_29',['DstAlpha',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbba5e3dc9a6f117aaa5f7433e1f4662a5f7',1,'sf::BlendMode']]], + ['dstcolor_30',['DstColor',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbba3d85281c3eab7153f2bd9faae3e7523a',1,'sf::BlendMode']]], + ['dynamic_31',['Dynamic',['../classsf_1_1VertexBuffer.html#a3a531528684e63ecb45edd51282f5cb7a13365282a5933ecd9cc6a3ef39ba58f7',1,'sf::VertexBuffer']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_4.js b/Space-Invaders/sfml/doc/html/search/all_4.js new file mode 100644 index 000000000..d1ac26dbc --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_4.js @@ -0,0 +1,22 @@ +var searchData= +[ + ['e_0',['E',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adc59d37687890a0efbac55992448e41f',1,'sf::Keyboard::Scan::E()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a0e027c08438a8bf77e2e1e5d5d75bd84',1,'sf::Keyboard::E()']]], + ['ebcdic_1',['Ebcdic',['../classsf_1_1Ftp.html#a1cd6b89ad23253f6d97e6d4ca4d558cbabb1e34435231e73c96534c71090be7f4',1,'sf::Ftp']]], + ['encode_2',['encode',['../classsf_1_1Utf_3_018_01_4.html#a5fbc6b5a996f52e9e4a14633d0d71847',1,'sf::Utf< 8 >::encode()'],['../classsf_1_1Utf_3_0116_01_4.html#a516090c84ceec2cfde0a13b6148363bb',1,'sf::Utf< 16 >::encode()'],['../classsf_1_1Utf_3_0132_01_4.html#a27b9d3f3fc49a8c88d91966889fcfca1',1,'sf::Utf< 32 >::encode(Uint32 input, Out output, Uint32 replacement=0)']]], + ['encodeansi_3',['encodeAnsi',['../classsf_1_1Utf_3_0132_01_4.html#af6590226a071076ca22d818573a16ded',1,'sf::Utf< 32 >']]], + ['encodewide_4',['encodeWide',['../classsf_1_1Utf_3_0132_01_4.html#a52e511e74ddc5df1bbf18f910193bc47',1,'sf::Utf< 32 >']]], + ['end_5',['End',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a60da82f685e98127043da8ffd04b7442',1,'sf::Keyboard::Scan::End()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a4478343b2b7efc310f995fd4251a264d',1,'sf::Keyboard::End()']]], + ['end_6',['end',['../classsf_1_1String.html#ac823012f39cb6f61100418876e99d53b',1,'sf::String::end()'],['../classsf_1_1String.html#af1ab4c82ff2bdfb6903b4b1bb78a8e5c',1,'sf::String::end() const']]], + ['endofpacket_7',['endOfPacket',['../classsf_1_1Packet.html#a61e354fa670da053907c14b738839560',1,'sf::Packet']]], + ['enter_8',['Enter',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adb4984ca4b4e90eae95e32bb0de29c8e',1,'sf::Keyboard::Scan::Enter()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a59e26db0965305492875d7da68f6a990',1,'sf::Keyboard::Enter()']]], + ['enteringpassivemode_9',['EnteringPassiveMode',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba48314fc47a72ad0aacdea93b91756f6e',1,'sf::Ftp::Response']]], + ['equal_10',['Equal',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6cd11681bbd83c0565c9c63e4d512a86',1,'sf::Keyboard::Scan::Equal()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ae55c35f6b6417e1dbbfa351c64dfc743',1,'sf::Keyboard::Equal()']]], + ['equation_11',['Equation',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32',1,'sf::BlendMode']]], + ['erase_12',['erase',['../classsf_1_1String.html#aaa78a0a46b3fbe200a4ccdedc326eb93',1,'sf::String']]], + ['err_13',['err',['../group__system.html#ga7fe7f475639e26334606b5142c29551f',1,'sf']]], + ['error_14',['Error',['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dca1dc9854433a28c22e192721179a2df5d',1,'sf::Socket']]], + ['escape_15',['Escape',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac8409d6faf55c88bc01c722c51e99b93',1,'sf::Keyboard::Scan::Escape()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a64b7ecb543c5d03bec8383dde123c95d',1,'sf::Keyboard::Escape()']]], + ['event_16',['Event',['../classsf_1_1Event.html',1,'sf']]], + ['eventtype_17',['EventType',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4a',1,'sf::Event']]], + ['execute_18',['Execute',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a12c94b4dc55153a952283aff554ae3a0',1,'sf::Keyboard::Scan']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_5.js b/Space-Invaders/sfml/doc/html/search/all_5.js new file mode 100644 index 000000000..ef26a520b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_5.js @@ -0,0 +1,54 @@ +var searchData= +[ + ['f_0',['F',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a2d87edd4fa1f6ae355cabcccb5844ea3',1,'sf::Keyboard::Scan::F()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab8021fbbe5483bc98f124df6f7090002',1,'sf::Keyboard::F()']]], + ['f1_1',['F1',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a60bdd99ca0d0ab177a65078a185333a6',1,'sf::Keyboard::Scan::F1()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ae59c7e28858e970c9d4f0e418179b632',1,'sf::Keyboard::F1()']]], + ['f10_2',['F10',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aee4c9257be218585114cf27602892572',1,'sf::Keyboard::Scan::F10()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aec695ecf296e7084a8f7f3ec408e16ac',1,'sf::Keyboard::F10()']]], + ['f11_3',['F11',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5047f3be2633e101840945b58867be6e',1,'sf::Keyboard::Scan::F11()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af9a8de90d90a7a7582269bc5c41f5afd',1,'sf::Keyboard::F11()']]], + ['f12_4',['F12',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa068df80ff6d72b0bdab149e3a3d26af',1,'sf::Keyboard::Scan::F12()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af9d8807117d946de5e403bcbd4d7161d',1,'sf::Keyboard::F12()']]], + ['f13_5',['F13',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a9e28e971941ca2900c1eea17cda50a04',1,'sf::Keyboard::F13()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af3416f863ce92ae05b26aed80e72a52f',1,'sf::Keyboard::Scan::F13()']]], + ['f14_6',['F14',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a8589f17d8b4170b7f51711c1d6611f21',1,'sf::Keyboard::Scan::F14()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a9a0327a4ef876338d5f3c34c514f190c',1,'sf::Keyboard::F14()']]], + ['f15_7',['F15',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a8949ce79077cc8bf64f4fa42bb6a2808',1,'sf::Keyboard::F15()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875acad0fde63b2171cc56d42a1d23d679ba',1,'sf::Keyboard::Scan::F15()']]], + ['f16_8',['F16',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a1c3d4ce6fc1826f1da081b942676cccd',1,'sf::Keyboard::Scan']]], + ['f17_9',['F17',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa416a15ec21b4957d740992f446a5224',1,'sf::Keyboard::Scan']]], + ['f18_10',['F18',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae50807a7d06cc5324eac783bf4d0b96d',1,'sf::Keyboard::Scan']]], + ['f19_11',['F19',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a51ff7425b98bbcd8e777908de15f3d10',1,'sf::Keyboard::Scan']]], + ['f2_12',['F2',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3ea5468548feaccb419a8c4c160c16b0',1,'sf::Keyboard::Scan::F2()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a6a2faa5f876a1e75f24a596b658ff413',1,'sf::Keyboard::F2()']]], + ['f20_13',['F20',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a06d01cd179c76fe33c2f61006176f076',1,'sf::Keyboard::Scan']]], + ['f21_14',['F21',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad86a6e71ba08ffc8167d003b92cadb77',1,'sf::Keyboard::Scan']]], + ['f22_15',['F22',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a538c92aa44eae29b23ef3c096c1b571b',1,'sf::Keyboard::Scan']]], + ['f23_16',['F23',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac66a8fea90d7307b434b4a09b0822202',1,'sf::Keyboard::Scan']]], + ['f24_17',['F24',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a069f7f10bbdb13aeea8cfdebee4752f4',1,'sf::Keyboard::Scan']]], + ['f3_18',['F3',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af2e1be02540c0794302ec9e1d2262ef4',1,'sf::Keyboard::Scan::F3()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a1fb58d66f9c0183db3e70b2b0576074e',1,'sf::Keyboard::F3()']]], + ['f4_19',['F4',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae4a9bcd1df4becc4994c676f44a5a101',1,'sf::Keyboard::Scan::F4()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a71311e21238cf2c0df1bbf096bba68f2',1,'sf::Keyboard::F4()']]], + ['f5_20',['F5',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a01fd2f93eddf2887186ea91180a789a8',1,'sf::Keyboard::F5()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a4fe3daf6c23906249b87f0ffffb458be',1,'sf::Keyboard::Scan::F5()']]], + ['f6_21',['F6',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3c3934e6efc54b366de1e27f5099276e',1,'sf::Keyboard::Scan::F6()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac756a19b31eb28cd2c35c29d8e54ea04',1,'sf::Keyboard::F6()']]], + ['f7_22',['F7',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a060d30d36a3e08208b2bc46d0f549b6c',1,'sf::Keyboard::F7()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5dc33031068713ce55bb332672d9bb9a',1,'sf::Keyboard::Scan::F7()']]], + ['f8_23',['F8',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae1faf360e99035dff729917bee051daa',1,'sf::Keyboard::Scan::F8()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ade468cd27716b9c2a0d0158afa2f8621',1,'sf::Keyboard::F8()']]], + ['f9_24',['F9',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae0cb68ca4ec3844548d4e089ec9ea8c5',1,'sf::Keyboard::Scan::F9()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a3c5c2342003a7191de6636b5ef44e1b9',1,'sf::Keyboard::F9()']]], + ['factor_25',['Factor',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbb',1,'sf::BlendMode']]], + ['family_26',['family',['../structsf_1_1Font_1_1Info.html#a008413b4b6cf621eb92668a11098a519',1,'sf::Font::Info']]], + ['favorites_27',['Favorites',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad54aa9735cb59fe6fbd9a54939dadb53',1,'sf::Keyboard::Scan']]], + ['fileactionaborted_28',['FileActionAborted',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baf822d1b0abf3e9ae7dd44684549d512d',1,'sf::Ftp::Response']]], + ['fileactionok_29',['FileActionOk',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baf988b69b0a5f55f8122da5ba001932e0',1,'sf::Ftp::Response']]], + ['fileinputstream_30',['FileInputStream',['../classsf_1_1FileInputStream.html#a9a321e273f41ff7f187899061fcae9be',1,'sf::FileInputStream::FileInputStream()'],['../classsf_1_1FileInputStream.html',1,'sf::FileInputStream']]], + ['filenamenotallowed_31',['FilenameNotAllowed',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba03254aba823298179a98056e15568c5b',1,'sf::Ftp::Response']]], + ['filestatus_32',['FileStatus',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baebddfc7997dca289c83068dff3f47dce',1,'sf::Ftp::Response']]], + ['fileunavailable_33',['FileUnavailable',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba3f8f931e499936fde6b750d81f5ecfef',1,'sf::Ftp::Response']]], + ['find_34',['find',['../classsf_1_1String.html#aa189ec8656854106ab8d2e935fd9cbcc',1,'sf::String']]], + ['findcharacterpos_35',['findCharacterPos',['../classsf_1_1Text.html#a2e252d8dcae3eb61c6c962c0bc674b12',1,'sf::Text']]], + ['finger_36',['finger',['../structsf_1_1Event_1_1TouchEvent.html#a9a79fe86bf9ac3c16ec7326f96feb61a',1,'sf::Event::TouchEvent']]], + ['fliphorizontally_37',['flipHorizontally',['../classsf_1_1Image.html#a57168e7bc29190e08bbd6c9c19f4bb2c',1,'sf::Image']]], + ['flipvertically_38',['flipVertically',['../classsf_1_1Image.html#a78a702a7e49d1de2dec9894da99d279c',1,'sf::Image']]], + ['font_39',['Font',['../classsf_1_1Font.html#a506404655b8869ed60d1e7709812f583',1,'sf::Font::Font()'],['../classsf_1_1Font.html#a72d7322b355ee2f1be4500f530e98081',1,'sf::Font::Font(const Font &copy)'],['../classsf_1_1Font.html',1,'sf::Font']]], + ['forbidden_40',['Forbidden',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a64492842e823ebe12a85539b6b454986',1,'sf::Http::Response']]], + ['forward_41',['Forward',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adb5993c42ae3794c0e755f8e4b4666ea',1,'sf::Keyboard::Scan']]], + ['fragment_42',['Fragment',['../classsf_1_1Shader.html#afaa1aa65e5de37b74d047da9def9f9b3ace6e88eec3a56b2e55ee3c8e64e9b89a',1,'sf::Shader']]], + ['fromansi_43',['fromAnsi',['../classsf_1_1Utf_3_018_01_4.html#a1b62ba85ad3c8ce68746e16192b3eef0',1,'sf::Utf< 8 >::fromAnsi()'],['../classsf_1_1Utf_3_0116_01_4.html#a8a595dc1ea57ecf7aad944964913f0ff',1,'sf::Utf< 16 >::fromAnsi()'],['../classsf_1_1Utf_3_0132_01_4.html#a384a4169287af15876783ad477cac4e3',1,'sf::Utf< 32 >::fromAnsi()']]], + ['fromlatin1_44',['fromLatin1',['../classsf_1_1Utf_3_018_01_4.html#a85dd3643b7109a1a2f802747e55e28e8',1,'sf::Utf< 8 >::fromLatin1()'],['../classsf_1_1Utf_3_0116_01_4.html#a52293df75893733fe6cf84b8a017cbf7',1,'sf::Utf< 16 >::fromLatin1()'],['../classsf_1_1Utf_3_0132_01_4.html#a05741b76b5a26267a72735e40ca61c55',1,'sf::Utf< 32 >::fromLatin1()']]], + ['fromutf16_45',['fromUtf16',['../classsf_1_1String.html#a81f70eecad0000a4f2e4d66f97b80300',1,'sf::String']]], + ['fromutf32_46',['fromUtf32',['../classsf_1_1String.html#ab023a4900dce37ee71ab9e29b30a23cb',1,'sf::String']]], + ['fromutf8_47',['fromUtf8',['../classsf_1_1String.html#aa7beb7ae5b26e63dcbbfa390e27a9e4b',1,'sf::String']]], + ['fromwide_48',['fromWide',['../classsf_1_1Utf_3_018_01_4.html#aa99e636a7addc157b425dfc11b008f42',1,'sf::Utf< 8 >::fromWide()'],['../classsf_1_1Utf_3_0116_01_4.html#a263423929b6f8e4d3ad09b45ac5cb0a1',1,'sf::Utf< 16 >::fromWide()'],['../classsf_1_1Utf_3_0132_01_4.html#abdf0d41e0c8814a68326688e3b8d187f',1,'sf::Utf< 32 >::fromWide()']]], + ['ftp_49',['Ftp',['../classsf_1_1Ftp.html',1,'sf']]], + ['fullscreen_50',['Fullscreen',['../group__window.html#gga97d7ee508bea4507ab40271518c732ffa6288ec86830245cf957e2d234f79f50d',1,'sf::Style']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_6.js b/Space-Invaders/sfml/doc/html/search/all_6.js new file mode 100644 index 000000000..b83c28227 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_6.js @@ -0,0 +1,117 @@ +var searchData= +[ + ['g_0',['g',['../classsf_1_1Color.html#a591daf9c3c55dea830c76c962d6ba1a5',1,'sf::Color']]], + ['g_1',['G',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a21dc36f8ac9ff44d3c6aca6a66503264',1,'sf::Keyboard::Scan::G()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aafb9e3d7679d88d86afc608d79c251f7',1,'sf::Keyboard::G()']]], + ['gainedfocus_2',['GainedFocus',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa8c5003ced508499933d540df8a6023ec',1,'sf::Event']]], + ['gatewaytimeout_3',['GatewayTimeout',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a215935d823ab44694709a184a71353b0',1,'sf::Http::Response']]], + ['generatemipmap_4',['generateMipmap',['../classsf_1_1RenderTexture.html#a8ca34c8b7e00793c1d3ef4f9a834f8cc',1,'sf::RenderTexture::generateMipmap()'],['../classsf_1_1Texture.html#a7779a75c0324b5faff77602f871710a9',1,'sf::Texture::generateMipmap()']]], + ['geometry_5',['Geometry',['../classsf_1_1Shader.html#afaa1aa65e5de37b74d047da9def9f9b3a812421100fd57456727375938fb62788',1,'sf::Shader']]], + ['get_6',['Get',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598ab822baed393f3d0353621e5378b9fcb4',1,'sf::Http::Request']]], + ['getactivecontext_7',['getActiveContext',['../classsf_1_1Context.html#a31bc6509779067b21d13208ffe85d5ca',1,'sf::Context']]], + ['getactivecontextid_8',['getActiveContextId',['../classsf_1_1Context.html#a61b1cb0a99b8e3ce56579d70aa41fb70',1,'sf::Context']]], + ['getattenuation_9',['getAttenuation',['../classsf_1_1SoundSource.html#a8ad7dafb4f1b4afbc638cebe24f48cc9',1,'sf::SoundSource']]], + ['getavailabledevices_10',['getAvailableDevices',['../classsf_1_1SoundRecorder.html#a2a0a831148dcf3d979de42029ec0c280',1,'sf::SoundRecorder']]], + ['getaxisposition_11',['getAxisPosition',['../classsf_1_1Joystick.html#aea4930193331df1851b709f3060ba58b',1,'sf::Joystick']]], + ['getbody_12',['getBody',['../classsf_1_1Http_1_1Response.html#ac59e2b11cae4b6232c737547a3ca9850',1,'sf::Http::Response']]], + ['getbounds_13',['getBounds',['../classsf_1_1VertexArray.html#abd57744c732abfc7d4c98d8e1d4ccca1',1,'sf::VertexArray']]], + ['getbuffer_14',['getBuffer',['../classsf_1_1Sound.html#a7c0f6033856909eeefa2e6696db96ef2',1,'sf::Sound::getBuffer()'],['../classsf_1_1SoundBufferRecorder.html#a1befea2bfa3959ff6fabbf7e33cbc864',1,'sf::SoundBufferRecorder::getBuffer()']]], + ['getbuttoncount_15',['getButtonCount',['../classsf_1_1Joystick.html#a4de9f445c6582bfe9f0873f695682885',1,'sf::Joystick']]], + ['getcenter_16',['getCenter',['../classsf_1_1View.html#a8bd01cd2bcad03e547232b190c215b09',1,'sf::View']]], + ['getchannelcount_17',['getChannelCount',['../classsf_1_1SoundBuffer.html#a127707b831d875ed790eef1aa2b9fcc3',1,'sf::SoundBuffer::getChannelCount()'],['../classsf_1_1SoundRecorder.html#a610e98e7a73b316ce26b7c55234f86e9',1,'sf::SoundRecorder::getChannelCount()'],['../classsf_1_1InputSoundFile.html#a54307c308ba05dea63aba54a29c804a4',1,'sf::InputSoundFile::getChannelCount()'],['../classsf_1_1SoundStream.html#a1f70933912dd9498f4dc99feefed27f3',1,'sf::SoundStream::getChannelCount()']]], + ['getcharactersize_18',['getCharacterSize',['../classsf_1_1Text.html#a46d1d7f1d513bb8d434e985a93ea5224',1,'sf::Text']]], + ['getcolor_19',['getColor',['../classsf_1_1Sprite.html#af4a3ee8177fdd6e472a360a0a837d7cf',1,'sf::Sprite::getColor()'],['../classsf_1_1Text.html#ab367e86c9e9e6cd3806c362ab8e79101',1,'sf::Text::getColor()']]], + ['getdata_20',['getData',['../classsf_1_1Packet.html#a998b70df024bee4792e2ecdc915ae46e',1,'sf::Packet::getData()'],['../classsf_1_1String.html#a3ed7f3ad41659a2b31a8d8e99a7b8199',1,'sf::String::getData()']]], + ['getdatasize_21',['getDataSize',['../classsf_1_1Packet.html#a0fae6eccf2ca704fc5099cd90a9f56f7',1,'sf::Packet']]], + ['getdefaultdevice_22',['getDefaultDevice',['../classsf_1_1SoundRecorder.html#ad1d450a80642dab4b632999d72a1bf23',1,'sf::SoundRecorder']]], + ['getdefaultview_23',['getDefaultView',['../classsf_1_1RenderTarget.html#a7741129e3ef7ab4f0a40024fca13480c',1,'sf::RenderTarget']]], + ['getdescription_24',['getDescription',['../classsf_1_1Keyboard.html#aab9652b25d81d6526b72bdc876d92d41',1,'sf::Keyboard']]], + ['getdesktopmode_25',['getDesktopMode',['../classsf_1_1VideoMode.html#ac1be160a4342e6eafb2cb0e8c9b18d44',1,'sf::VideoMode']]], + ['getdevice_26',['getDevice',['../classsf_1_1SoundRecorder.html#a13d7d97b3ca67efa18f5ee0aa5884f1f',1,'sf::SoundRecorder']]], + ['getdirection_27',['getDirection',['../classsf_1_1Listener.html#a54e91baba51d4431474f53ff7f9309f9',1,'sf::Listener']]], + ['getdirectory_28',['getDirectory',['../classsf_1_1Ftp_1_1DirectoryResponse.html#a983b0ce3d99c687e0862212040158d67',1,'sf::Ftp::DirectoryResponse']]], + ['getdirectorylisting_29',['getDirectoryListing',['../classsf_1_1Ftp.html#a8f37258e461fcb9e2a0655e9df0be4a0',1,'sf::Ftp']]], + ['getduration_30',['getDuration',['../classsf_1_1InputSoundFile.html#aa081bd4d9732408d10b48227a360778e',1,'sf::InputSoundFile::getDuration()'],['../classsf_1_1Music.html#a288ef6f552a136b0e56952dcada3d672',1,'sf::Music::getDuration()'],['../classsf_1_1SoundBuffer.html#a280a581d9b360fd16121714c51fc8261',1,'sf::SoundBuffer::getDuration()']]], + ['getelapsedtime_31',['getElapsedTime',['../classsf_1_1Clock.html#abe889b42a65bcd8eefc16419645d08a7',1,'sf::Clock']]], + ['getfield_32',['getField',['../classsf_1_1Http_1_1Response.html#ae16458c4e969206381b78587aa47c8dc',1,'sf::Http::Response']]], + ['getfillcolor_33',['getFillColor',['../classsf_1_1Text.html#a10400757492ec7fa97454488314ca39b',1,'sf::Text::getFillColor()'],['../classsf_1_1Shape.html#aa5da23e522d2dd11e3e7661c26164c78',1,'sf::Shape::getFillColor()']]], + ['getfont_34',['getFont',['../classsf_1_1Text.html#ad947a43bddaddf54d008df600699599b',1,'sf::Text']]], + ['getfullscreenmodes_35',['getFullscreenModes',['../classsf_1_1VideoMode.html#a0f99e67ef2b51fbdc335d9991232609e',1,'sf::VideoMode']]], + ['getfunction_36',['getFunction',['../classsf_1_1Context.html#a998980d311effdf6223ce40d934c23c3',1,'sf::Context::getFunction()'],['../classsf_1_1Vulkan.html#af5b575941e5976af33c6447046e7fefe',1,'sf::Vulkan::getFunction()']]], + ['getglobalbounds_37',['getGlobalBounds',['../classsf_1_1Shape.html#ac0e29425d908d5442060cc44790fe4da',1,'sf::Shape::getGlobalBounds()'],['../classsf_1_1Sprite.html#aa795483096b90745b2e799532963e271',1,'sf::Sprite::getGlobalBounds()'],['../classsf_1_1Text.html#ad33ed96ce9fbe99610f7f8b6874a16b4',1,'sf::Text::getGlobalBounds()']]], + ['getglobalvolume_38',['getGlobalVolume',['../classsf_1_1Listener.html#a137ea535799bdf70be6ec969673d4d33',1,'sf::Listener']]], + ['getglyph_39',['getGlyph',['../classsf_1_1Font.html#a4fa68953025b5357b5683297a3104070',1,'sf::Font']]], + ['getgraphicsrequiredinstanceextensions_40',['getGraphicsRequiredInstanceExtensions',['../classsf_1_1Vulkan.html#a295895b452031cf58fadbf3205db6149',1,'sf::Vulkan']]], + ['gethandle_41',['getHandle',['../classsf_1_1Socket.html#a675457784284ae2f5640bbbe16729393',1,'sf::Socket']]], + ['getidentification_42',['getIdentification',['../classsf_1_1Joystick.html#aa917c9435330e6e0368d3893672d1b74',1,'sf::Joystick']]], + ['getinfo_43',['getInfo',['../classsf_1_1Font.html#a86f7a72943c428cac8fa6adaaa69c722',1,'sf::Font']]], + ['getinverse_44',['getInverse',['../classsf_1_1Transform.html#a14f49e81af44aabcff7611f6703a1e4a',1,'sf::Transform']]], + ['getinversetransform_45',['getInverseTransform',['../classsf_1_1Transformable.html#ac5e75d724436069d2268791c6b486916',1,'sf::Transformable::getInverseTransform()'],['../classsf_1_1View.html#aa685c17a56aae7c7df4c90ea6285fd46',1,'sf::View::getInverseTransform()']]], + ['getkerning_46',['getKerning',['../classsf_1_1Font.html#ab357e3e0e158f1dfc454a78e111cb5d6',1,'sf::Font']]], + ['getletterspacing_47',['getLetterSpacing',['../classsf_1_1Text.html#a028fc6e561bd9a0671254419b498b889',1,'sf::Text']]], + ['getlinespacing_48',['getLineSpacing',['../classsf_1_1Font.html#a4538cc8af337393208a87675fe1c3e59',1,'sf::Font::getLineSpacing()'],['../classsf_1_1Text.html#a670622e1c299dfd6518afe289c7cd248',1,'sf::Text::getLineSpacing()']]], + ['getlisting_49',['getListing',['../classsf_1_1Ftp_1_1ListingResponse.html#a0d0579db7e0531761992dbbae1174bf2',1,'sf::Ftp::ListingResponse']]], + ['getlocaladdress_50',['getLocalAddress',['../classsf_1_1IpAddress.html#a4c31622ad87edca48adbb8e8ed00ee4a',1,'sf::IpAddress']]], + ['getlocalbounds_51',['getLocalBounds',['../classsf_1_1Sprite.html#ab2f4c781464da6f8a52b1df6058a48b8',1,'sf::Sprite::getLocalBounds()'],['../classsf_1_1Shape.html#ae3294bcdf8713d33a862242ecf706443',1,'sf::Shape::getLocalBounds()'],['../classsf_1_1Text.html#a3e6b3b298827f853b41165eee2cbbc66',1,'sf::Text::getLocalBounds()']]], + ['getlocalport_52',['getLocalPort',['../classsf_1_1TcpSocket.html#a98e45f0f49af1fd99216b9195e86d86b',1,'sf::TcpSocket::getLocalPort()'],['../classsf_1_1TcpListener.html#a784b9a9c59d4cdbae1795e90b8015780',1,'sf::TcpListener::getLocalPort()'],['../classsf_1_1UdpSocket.html#a5c03644b3da34bb763bce93e758c938e',1,'sf::UdpSocket::getLocalPort()']]], + ['getloop_53',['getLoop',['../classsf_1_1Sound.html#a054da07266ce8f39229495146e3041eb',1,'sf::Sound::getLoop()'],['../classsf_1_1SoundStream.html#a49d263f9bbaefec4b019bd05fda59b25',1,'sf::SoundStream::getLoop()']]], + ['getlooppoints_54',['getLoopPoints',['../classsf_1_1Music.html#aae3451cad5c16ee6a6e124e62ed61361',1,'sf::Music']]], + ['getmajorhttpversion_55',['getMajorHttpVersion',['../classsf_1_1Http_1_1Response.html#ab1c6948f6444fad34d0537e206e398b8',1,'sf::Http::Response']]], + ['getmatrix_56',['getMatrix',['../classsf_1_1Transform.html#ab85cb4194f42a965d337a8f02783c534',1,'sf::Transform']]], + ['getmaximumantialiasinglevel_57',['getMaximumAntialiasingLevel',['../classsf_1_1RenderTexture.html#ab0849fc3e064b744ffae1ab1d85ee12b',1,'sf::RenderTexture']]], + ['getmaximumsize_58',['getMaximumSize',['../classsf_1_1Texture.html#a0bf905d487b104b758549c2e9e20a3fb',1,'sf::Texture']]], + ['getmessage_59',['getMessage',['../classsf_1_1Ftp_1_1Response.html#adc2890c93c9f8ee997b828fcbef82c97',1,'sf::Ftp::Response']]], + ['getmindistance_60',['getMinDistance',['../classsf_1_1SoundSource.html#a605ca7f359ec1c36fcccdcd4696562ac',1,'sf::SoundSource']]], + ['getminorhttpversion_61',['getMinorHttpVersion',['../classsf_1_1Http_1_1Response.html#af3c649568d2e291e71c3a7da546bb392',1,'sf::Http::Response']]], + ['getnativeactivity_62',['getNativeActivity',['../group__system.html#ga666414341ce8396227f5a125ee5b7053',1,'sf']]], + ['getnativehandle_63',['getNativeHandle',['../classsf_1_1Shader.html#ac14d0bf7afe7b6bb415d309f9c707188',1,'sf::Shader::getNativeHandle()'],['../classsf_1_1Texture.html#a674b632608747bfc27b53a4935c835b0',1,'sf::Texture::getNativeHandle()'],['../classsf_1_1VertexBuffer.html#a343fa0a240c91bc4203a6727fcd9b920',1,'sf::VertexBuffer::getNativeHandle()']]], + ['getorigin_64',['getOrigin',['../classsf_1_1Transformable.html#a898b33eb6513161eb5c747a072364f15',1,'sf::Transformable']]], + ['getoutlinecolor_65',['getOutlineColor',['../classsf_1_1Text.html#ade9256ff9d43c9481fcf5f4003fe0141',1,'sf::Text::getOutlineColor()'],['../classsf_1_1Shape.html#a4aa05b59851468e948ac9682b9c71abb',1,'sf::Shape::getOutlineColor() const']]], + ['getoutlinethickness_66',['getOutlineThickness',['../classsf_1_1Shape.html#a1d4d5299c573a905e5833fc4dce783a7',1,'sf::Shape::getOutlineThickness()'],['../classsf_1_1Text.html#af6bf01c23189edf52c8b38708db6f3f6',1,'sf::Text::getOutlineThickness()']]], + ['getpitch_67',['getPitch',['../classsf_1_1SoundSource.html#a4736acc2c802f927544c9ce52a44a9e4',1,'sf::SoundSource']]], + ['getpixel_68',['getPixel',['../classsf_1_1Image.html#acf278760458433b2c3626a6980388a95',1,'sf::Image']]], + ['getpixelsptr_69',['getPixelsPtr',['../classsf_1_1Image.html#a2f49e69b6c6257b19b4d911993075c40',1,'sf::Image']]], + ['getplayingoffset_70',['getPlayingOffset',['../classsf_1_1Sound.html#a559bc3aea581107bcb380fdbe523aa08',1,'sf::Sound::getPlayingOffset()'],['../classsf_1_1SoundStream.html#ae288f3c72edbad9cc7ee938ce5b907c1',1,'sf::SoundStream::getPlayingOffset()']]], + ['getpoint_71',['getPoint',['../classsf_1_1CircleShape.html#a2d7f9715502b960b92387102fddb8736',1,'sf::CircleShape::getPoint()'],['../classsf_1_1ConvexShape.html#a72a97bc426d8daf4d682a20fcb7f3fe7',1,'sf::ConvexShape::getPoint()'],['../classsf_1_1RectangleShape.html#a3909f1a1946930ff5ae17c26206c0f81',1,'sf::RectangleShape::getPoint()'],['../classsf_1_1Shape.html#a40e5d83713eb9f0c999944cf96458085',1,'sf::Shape::getPoint()']]], + ['getpointcount_72',['getPointCount',['../classsf_1_1RectangleShape.html#adfb2f429e5720c9ccdb26d5996c3ae33',1,'sf::RectangleShape::getPointCount()'],['../classsf_1_1Shape.html#af988dd61a29803fc04d02198e44b5643',1,'sf::Shape::getPointCount()'],['../classsf_1_1CircleShape.html#a014d29ec11e8afa4dce50e7047d99601',1,'sf::CircleShape::getPointCount()'],['../classsf_1_1ConvexShape.html#a0c54b8d48fe4e13414f6e667dbfc22a3',1,'sf::ConvexShape::getPointCount()']]], + ['getposition_73',['getPosition',['../classsf_1_1Touch.html#a8a1456574d2825d4249fcf72f11d4398',1,'sf::Touch::getPosition()'],['../classsf_1_1WindowBase.html#a5ddaa5943f547645079f081422e45c81',1,'sf::WindowBase::getPosition()'],['../classsf_1_1Listener.html#acd7ee65bc948ca38e1c669aa12340c54',1,'sf::Listener::getPosition()'],['../classsf_1_1SoundSource.html#a8d199521f55550c7a3b2b0f6950dffa1',1,'sf::SoundSource::getPosition()'],['../classsf_1_1Rect.html#a846489bc985f7d1655150cad65961bbd',1,'sf::Rect::getPosition()'],['../classsf_1_1Transformable.html#aea8b18e91a7bf7be589851bb9dd11241',1,'sf::Transformable::getPosition()'],['../classsf_1_1Mouse.html#ac368680f797b7f6e4f50b5b7928c1387',1,'sf::Mouse::getPosition()'],['../classsf_1_1Mouse.html#ac9934f761e377da97993de5aab75006b',1,'sf::Mouse::getPosition(const WindowBase &relativeTo)'],['../classsf_1_1Touch.html#af1b7035be709091c7475075e43e2bc23',1,'sf::Touch::getPosition()']]], + ['getprimitivetype_74',['getPrimitiveType',['../classsf_1_1VertexBuffer.html#a02061d85472ff69e7ad14dc72f8fcaa4',1,'sf::VertexBuffer::getPrimitiveType()'],['../classsf_1_1VertexArray.html#aa1a60d84543aa6e220683349b645f130',1,'sf::VertexArray::getPrimitiveType()']]], + ['getpublicaddress_75',['getPublicAddress',['../classsf_1_1IpAddress.html#a5c5cbf67e4aacf23c24f2ad991df4c55',1,'sf::IpAddress']]], + ['getradius_76',['getRadius',['../classsf_1_1CircleShape.html#aa3dd5a1b5031486ce5b6f09d43674aa3',1,'sf::CircleShape']]], + ['getreadposition_77',['getReadPosition',['../classsf_1_1Packet.html#a5c2dc9878afaf30e88d922776201f6c3',1,'sf::Packet']]], + ['getremoteaddress_78',['getRemoteAddress',['../classsf_1_1TcpSocket.html#aa8579c203b1fd21beb74d7f76444a94c',1,'sf::TcpSocket']]], + ['getremoteport_79',['getRemotePort',['../classsf_1_1TcpSocket.html#a93bced0afd4b1c60797a85725be04951',1,'sf::TcpSocket']]], + ['getrotation_80',['getRotation',['../classsf_1_1Transformable.html#aa00b5c5d4a06ac24a94dd72c56931d3a',1,'sf::Transformable::getRotation()'],['../classsf_1_1View.html#a324d8885f4ab17f1f7b0313580c9b84e',1,'sf::View::getRotation()']]], + ['getsamplecount_81',['getSampleCount',['../classsf_1_1InputSoundFile.html#a665b7fed6cdca3e0c622909e5a6655e4',1,'sf::InputSoundFile::getSampleCount()'],['../classsf_1_1SoundBuffer.html#aebe2a4bdbfbd9249353748da3f6a4fa1',1,'sf::SoundBuffer::getSampleCount()']]], + ['getsampleoffset_82',['getSampleOffset',['../classsf_1_1InputSoundFile.html#a73a99f159e8aca6e39478f6cf686d7ad',1,'sf::InputSoundFile']]], + ['getsamplerate_83',['getSampleRate',['../classsf_1_1InputSoundFile.html#a6b8177e40dd8020752f6d52f96b774c3',1,'sf::InputSoundFile::getSampleRate()'],['../classsf_1_1SoundBuffer.html#a2c2cf0078ce0549246ecc4a1646212b4',1,'sf::SoundBuffer::getSampleRate()'],['../classsf_1_1SoundRecorder.html#aed292c297a3e0d627db4eb5c18f58c44',1,'sf::SoundRecorder::getSampleRate()'],['../classsf_1_1SoundStream.html#a7da448dc40d81a33b8dc555fbf0d3fbf',1,'sf::SoundStream::getSampleRate()']]], + ['getsamples_84',['getSamples',['../classsf_1_1SoundBuffer.html#a3d5571a5231d3aea0d2cea933c38cc9e',1,'sf::SoundBuffer']]], + ['getscale_85',['getScale',['../classsf_1_1Transformable.html#a7bcae0e924213f2e89edd8926f2453af',1,'sf::Transformable']]], + ['getsettings_86',['getSettings',['../classsf_1_1Context.html#a5aace0ecfcf9552e97eed9ae88d01f71',1,'sf::Context::getSettings()'],['../classsf_1_1Window.html#a0605afbaceb02b098f9d731b7ab4203d',1,'sf::Window::getSettings()']]], + ['getsize_87',['getSize',['../classsf_1_1String.html#ae7aff54e178f5d3e399953adff5cad20',1,'sf::String::getSize()'],['../classsf_1_1WindowBase.html#a188a482d916a972d59d6b0700132e379',1,'sf::WindowBase::getSize()'],['../classsf_1_1Image.html#a85409951b05369813069ed64393391ce',1,'sf::Image::getSize()'],['../classsf_1_1Rect.html#ab1fd0936386404646ebe708652a66d09',1,'sf::Rect::getSize()'],['../classsf_1_1RectangleShape.html#af6819a7b842b83863f21e7a9c63097e7',1,'sf::RectangleShape::getSize()'],['../classsf_1_1RenderTarget.html#a2e5ade2457d9fb4c4907ae5b3d9e94a5',1,'sf::RenderTarget::getSize()'],['../classsf_1_1RenderTexture.html#a6685315b5c4c25a5dcb75b4280b381ba',1,'sf::RenderTexture::getSize()'],['../classsf_1_1RenderWindow.html#ae3eacf93661c8068fca7a78d57dc7e14',1,'sf::RenderWindow::getSize()'],['../classsf_1_1Texture.html#a9f86b8cc670c6399c539d4ce07ae5c8a',1,'sf::Texture::getSize()'],['../classsf_1_1View.html#a57e4a87cf0d724678675d22a0093719a',1,'sf::View::getSize()'],['../classsf_1_1FileInputStream.html#aabdcaa315e088e008eeb9711ecc796e8',1,'sf::FileInputStream::getSize()'],['../classsf_1_1InputStream.html#a311eaaaa65d636728e5153b574b72d5d',1,'sf::InputStream::getSize()'],['../classsf_1_1MemoryInputStream.html#a6ade3ca45de361ffa0a718595f0b6763',1,'sf::MemoryInputStream::getSize()']]], + ['getstatus_88',['getStatus',['../classsf_1_1Ftp_1_1Response.html#a52bbca9fbf5451157bc055e3d8430c25',1,'sf::Ftp::Response::getStatus()'],['../classsf_1_1Sound.html#a406fc363594a7718a53ebef49a870f51',1,'sf::Sound::getStatus()'],['../classsf_1_1SoundSource.html#aa8d313c31b968159582a999aa66e5ed7',1,'sf::SoundSource::getStatus()'],['../classsf_1_1SoundStream.html#a64a8193ed728da37c115c65de015849f',1,'sf::SoundStream::getStatus()'],['../classsf_1_1Http_1_1Response.html#a4271651703764fd9a7d2c0315aff20de',1,'sf::Http::Response::getStatus()']]], + ['getstring_89',['getString',['../classsf_1_1Text.html#ab334881845307db46ccf344191aa819c',1,'sf::Text::getString()'],['../classsf_1_1Clipboard.html#a3c385cc2b6d78a3d0cfa29928a7d6eb8',1,'sf::Clipboard::getString()']]], + ['getstyle_90',['getStyle',['../classsf_1_1Text.html#a0da79b0c057f4bb51592465a205c35d7',1,'sf::Text']]], + ['getsystemhandle_91',['getSystemHandle',['../classsf_1_1WindowBase.html#af9e56181556545bf6e6d7ed969edae21',1,'sf::WindowBase']]], + ['gettexture_92',['getTexture',['../classsf_1_1Font.html#a649982b4d0928d76a6f45b21719a6601',1,'sf::Font::getTexture()'],['../classsf_1_1RenderTexture.html#a61a6eba45d5c9e5c913aebeccb7b7eda',1,'sf::RenderTexture::getTexture()'],['../classsf_1_1Shape.html#af4c345931cd651ffb8f7a177446e28f7',1,'sf::Shape::getTexture()'],['../classsf_1_1Sprite.html#a6d0f107b5dd5976be50bc5b163ba21aa',1,'sf::Sprite::getTexture()']]], + ['gettexturerect_93',['getTextureRect',['../classsf_1_1Shape.html#ad8adbb54823c8eff1830a938e164daa4',1,'sf::Shape::getTextureRect()'],['../classsf_1_1Sprite.html#afb19e5b4f39d17cf4d95752b3a79bcb6',1,'sf::Sprite::getTextureRect()']]], + ['gettimeoffset_94',['getTimeOffset',['../classsf_1_1InputSoundFile.html#ad1a2238acb734d8b1144ecd75cccc2e7',1,'sf::InputSoundFile']]], + ['gettransform_95',['getTransform',['../classsf_1_1View.html#ac9c1dab0cb8c1ac143b031035d821ce5',1,'sf::View::getTransform()'],['../classsf_1_1Transformable.html#a3e1b4772a451ec66ac7e6af655726154',1,'sf::Transformable::getTransform()']]], + ['getunderlineposition_96',['getUnderlinePosition',['../classsf_1_1Font.html#a726a55f40c19ac108e348b103190caad',1,'sf::Font']]], + ['getunderlinethickness_97',['getUnderlineThickness',['../classsf_1_1Font.html#ad6d0a5bc6c026fe85c239f1f822b54e6',1,'sf::Font']]], + ['getupvector_98',['getUpVector',['../classsf_1_1Listener.html#ae1427dd7e9b425b0c23b7b766bd6c6e6',1,'sf::Listener']]], + ['getusage_99',['getUsage',['../classsf_1_1VertexBuffer.html#a5e36f2b3955bb35648c17550a9c096e1',1,'sf::VertexBuffer']]], + ['getvalue_100',['getValue',['../classsf_1_1ThreadLocal.html#a3273f1976f96a838e386937eae33fc21',1,'sf::ThreadLocal::getValue()'],['../classsf_1_1Sensor.html#ab9a2710f55ead2f7b4e1b0bead34457e',1,'sf::Sensor::getValue()']]], + ['getvertexcount_101',['getVertexCount',['../classsf_1_1VertexArray.html#abda90e8d841a273d93164f0c0032bd8d',1,'sf::VertexArray::getVertexCount()'],['../classsf_1_1VertexBuffer.html#a6c534536ed186a2ad65e75484c8abafe',1,'sf::VertexBuffer::getVertexCount()']]], + ['getview_102',['getView',['../classsf_1_1RenderTarget.html#adbf8dc5a1f4abbe15a3fbb915844c7ea',1,'sf::RenderTarget']]], + ['getviewport_103',['getViewport',['../classsf_1_1RenderTarget.html#a865d462915dc2a1fae2ebfb3300382ac',1,'sf::RenderTarget::getViewport()'],['../classsf_1_1View.html#aa2006fa4269078be4fd5ca999dcb6244',1,'sf::View::getViewport()']]], + ['getvolume_104',['getVolume',['../classsf_1_1SoundSource.html#a04243fb5edf64561689b1d58953fc4ce',1,'sf::SoundSource']]], + ['getworkingdirectory_105',['getWorkingDirectory',['../classsf_1_1Ftp.html#a79c654fcdd0c81e68c4fa29af3b45e0c',1,'sf::Ftp']]], + ['glresource_106',['GlResource',['../classsf_1_1GlResource.html#ad8fb7a0674f0f77e530dacc2a3b0dc6a',1,'sf::GlResource::GlResource()'],['../classsf_1_1GlResource.html',1,'sf::GlResource']]], + ['glyph_107',['Glyph',['../classsf_1_1Glyph.html#ab15cfc37eb7b40a94b3b3aedf934010b',1,'sf::Glyph::Glyph()'],['../classsf_1_1Glyph.html',1,'sf::Glyph']]], + ['gpupreference_2ehpp_108',['GpuPreference.hpp',['../GpuPreference_8hpp.html',1,'']]], + ['graphics_20module_109',['Graphics module',['../group__graphics.html',1,'']]], + ['grave_110',['Grave',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a813711cd9de71dab611b7155b36880f5',1,'sf::Keyboard::Scan::Grave()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a2da2429e6db8efbf923151f00a9b21e0',1,'sf::Keyboard::Grave()']]], + ['gravity_111',['Gravity',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84afab4d098cc64e791a0c4a9ef6b32db92',1,'sf::Sensor']]], + ['green_112',['Green',['../classsf_1_1Color.html#a95629b30de8c6856aa7d3afed12eb865',1,'sf::Color']]], + ['gyroscope_113',['Gyroscope',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84a1c43984aacd29b1fda5356883fb19656',1,'sf::Sensor']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_7.js b/Space-Invaders/sfml/doc/html/search/all_7.js new file mode 100644 index 000000000..2746dc834 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_7.js @@ -0,0 +1,17 @@ +var searchData= +[ + ['h_0',['H',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a40615dc67be807478f924c9aabf81915',1,'sf::Keyboard::Scan::H()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142adfa19328304890e17f4a3f4263eed04d',1,'sf::Keyboard::H()']]], + ['hand_1',['Hand',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aae826935374aa0414723918ba79f13368',1,'sf::Cursor']]], + ['hasaxis_2',['hasAxis',['../classsf_1_1Joystick.html#a268e8f2a11ae6af4a47c727cb4ab4d95',1,'sf::Joystick']]], + ['hasfocus_3',['hasFocus',['../classsf_1_1WindowBase.html#ad87bd19e979c426cb819ccde8c95232e',1,'sf::WindowBase']]], + ['hasglyph_4',['hasGlyph',['../classsf_1_1Font.html#ae577efa14d9f538208c98ded59a3f68e',1,'sf::Font']]], + ['head_5',['Head',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598a4df23138be7ed60f47aba6548ba65e7b',1,'sf::Http::Request']]], + ['height_6',['height',['../classsf_1_1Rect.html#a6fa0fc7de1636d78cae1a1b54eef95cd',1,'sf::Rect::height()'],['../structsf_1_1Event_1_1SizeEvent.html#af0f76a599d5f48189cb8d78d4e5facdb',1,'sf::Event::SizeEvent::height()'],['../classsf_1_1VideoMode.html#a5a88d44c9470db7474361a42a189342d',1,'sf::VideoMode::height()']]], + ['help_7',['Help',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aaf2c0ed3674b334ebf8365aee243186f5',1,'sf::Cursor::Help()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a4e8eeeae3acd3740053d2041e22dbf95',1,'sf::Keyboard::Scan::Help()']]], + ['helpmessage_8',['HelpMessage',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba840fd2a1872fd4310b046541f57fdeb7',1,'sf::Ftp::Response']]], + ['home_9',['Home',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae5d4c031080001f1449e3d55e8571e3a',1,'sf::Keyboard::Scan::Home()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af41ae7c3927cc5ea8b43ee2fefe890e8',1,'sf::Keyboard::Home()']]], + ['homepage_10',['HomePage',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a97afbc93fdb29797ed0fbfe45b93b80d',1,'sf::Keyboard::Scan']]], + ['horizontalwheel_11',['HorizontalWheel',['../classsf_1_1Mouse.html#a60dd479a43f26f200e7957aa11803ff4a785768d5e33c77de9fdcfdd02219f4e2',1,'sf::Mouse']]], + ['http_12',['Http',['../classsf_1_1Http.html#abe2360194f99bdde402c9f97a85cf067',1,'sf::Http::Http()'],['../classsf_1_1Http.html#a79efd844a735f083fcce0edbf1092385',1,'sf::Http::Http(const std::string &host, unsigned short port=0)'],['../classsf_1_1Http.html',1,'sf::Http']]], + ['hyphen_13',['Hyphen',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae6888d3715971e533b4379452cbae94a',1,'sf::Keyboard::Scan::Hyphen()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a5bde2cf47e6182e6f45d0d2197223c35',1,'sf::Keyboard::Hyphen()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_8.js b/Space-Invaders/sfml/doc/html/search/all_8.js new file mode 100644 index 000000000..4d34a4096 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_8.js @@ -0,0 +1,42 @@ +var searchData= +[ + ['i_0',['I',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142abaef09665b4d94ebbed50345cab3981e',1,'sf::Keyboard::I()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875acfe0506f6ce3d306b47134e99260d984',1,'sf::Keyboard::Scan::I()']]], + ['identification_1',['Identification',['../structsf_1_1Joystick_1_1Identification.html',1,'sf::Joystick']]], + ['identity_2',['Identity',['../classsf_1_1Transform.html#aa4eb1eecbcb9979d76e2543b337fdb13',1,'sf::Transform']]], + ['image_3',['Image',['../classsf_1_1Image.html#abb4caf3cb167b613345ebe36fc883f12',1,'sf::Image::Image()'],['../classsf_1_1Image.html',1,'sf::Image']]], + ['info_4',['Info',['../structsf_1_1Font_1_1Info.html',1,'sf::Font::Info'],['../structsf_1_1SoundFileReader_1_1Info.html',1,'sf::SoundFileReader::Info']]], + ['initialize_5',['initialize',['../classsf_1_1SoundStream.html#a9c351711198ee1aa77c2fefd3ced4d2c',1,'sf::SoundStream::initialize()'],['../classsf_1_1RenderTarget.html#af530274b34159d644e509b4b4dc43eb7',1,'sf::RenderTarget::initialize()']]], + ['inputsoundfile_6',['InputSoundFile',['../classsf_1_1InputSoundFile.html#a3b95347de25d1d93a3230287cf47a077',1,'sf::InputSoundFile::InputSoundFile()'],['../classsf_1_1InputSoundFile.html',1,'sf::InputSoundFile']]], + ['inputstream_7',['InputStream',['../classsf_1_1InputStream.html',1,'sf']]], + ['insert_8',['insert',['../classsf_1_1String.html#ad0b1455deabf07af13ee79812e05fa02',1,'sf::String']]], + ['insert_9',['Insert',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a8935170f7f2ea9ea6586c3c686edc72a',1,'sf::Keyboard::Scan::Insert()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a616c8cae362d229155c5c6e10b969943',1,'sf::Keyboard::Insert()']]], + ['insufficientstoragespace_10',['InsufficientStorageSpace',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba5d9f3666222c808553c27e4e099c7c6d',1,'sf::Ftp::Response']]], + ['internalservererror_11',['InternalServerError',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8adae2b2a936414349d55b4ed8c583fed1',1,'sf::Http::Response']]], + ['intersects_12',['intersects',['../classsf_1_1Rect.html#ac77531698f39203e4bbe023097bb6a13',1,'sf::Rect::intersects(const Rect< T > &rectangle) const'],['../classsf_1_1Rect.html#ad512c4a1127279e2d7464d0ace62500d',1,'sf::Rect::intersects(const Rect< T > &rectangle, Rect< T > &intersection) const']]], + ['invalidfile_13',['InvalidFile',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baed2c74a9f335dee1463ca1a4f41c6478',1,'sf::Ftp::Response']]], + ['invalidpos_14',['InvalidPos',['../classsf_1_1String.html#abaadecaf12a6b41c54d725c75fd28527',1,'sf::String']]], + ['invalidresponse_15',['InvalidResponse',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba59e041e4ef186e8ae8d6035973fc46bd',1,'sf::Ftp::Response::InvalidResponse()'],['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a0af0090420e60bf54da4860749345c95',1,'sf::Http::Response::InvalidResponse()']]], + ['ipaddress_16',['IpAddress',['../classsf_1_1IpAddress.html#af32a0574baa0f46e48deb2d83ca7658b',1,'sf::IpAddress::IpAddress()'],['../classsf_1_1IpAddress.html#a656b7445ab04cabaa7398685bc09c3f7',1,'sf::IpAddress::IpAddress(const std::string &address)'],['../classsf_1_1IpAddress.html#a92f2a9be74334a61b96c2fc79fe6eb78',1,'sf::IpAddress::IpAddress(const char *address)'],['../classsf_1_1IpAddress.html#a1d289dcb9ce7a64c600c6f84cba88cc6',1,'sf::IpAddress::IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3)'],['../classsf_1_1IpAddress.html#a8ed34ba3a40d70eb9f09ac5ae779a162',1,'sf::IpAddress::IpAddress(Uint32 address)'],['../classsf_1_1IpAddress.html',1,'sf::IpAddress']]], + ['isavailable_17',['isAvailable',['../classsf_1_1SoundRecorder.html#aab2bd0fee9e48d6cfd449b1cb078ce5a',1,'sf::SoundRecorder::isAvailable()'],['../classsf_1_1Shader.html#ad22474690bafe4a305c1b9826b1bd86a',1,'sf::Shader::isAvailable()'],['../classsf_1_1VertexBuffer.html#a6304bc4134dc0164dc94eff887b08847',1,'sf::VertexBuffer::isAvailable()'],['../classsf_1_1Sensor.html#a7b7a2570218221781233bd495323abf0',1,'sf::Sensor::isAvailable()'],['../classsf_1_1Vulkan.html#a88ddd65cc8732316e3066541084c32a0',1,'sf::Vulkan::isAvailable()']]], + ['isblocking_18',['isBlocking',['../classsf_1_1Socket.html#ab1ceca9ac114b8baeeda3b34a0aca468',1,'sf::Socket']]], + ['isbuttonpressed_19',['isButtonPressed',['../classsf_1_1Joystick.html#ae0d97a4b84268cbe6a7078e1b2717835',1,'sf::Joystick::isButtonPressed()'],['../classsf_1_1Mouse.html#ab647159eb88e369a0332a9c5a7ba6687',1,'sf::Mouse::isButtonPressed()']]], + ['isconnected_20',['isConnected',['../classsf_1_1Joystick.html#ac7d4e1923e9f9420174f26703ea63d6c',1,'sf::Joystick']]], + ['isdown_21',['isDown',['../classsf_1_1Touch.html#a2f85297123ea4e401d02c346e50d48a3',1,'sf::Touch']]], + ['isempty_22',['isEmpty',['../classsf_1_1String.html#a2ba26cb6945d2bbb210b822f222aa7f6',1,'sf::String']]], + ['isextensionavailable_23',['isExtensionAvailable',['../classsf_1_1Context.html#a163c7f72c0c20133606657d895faa147',1,'sf::Context']]], + ['isgeometryavailable_24',['isGeometryAvailable',['../classsf_1_1Shader.html#a45db14baf1bbc688577f81813b1fce96',1,'sf::Shader']]], + ['iskeypressed_25',['isKeyPressed',['../classsf_1_1Keyboard.html#a80a04b2f53005886957f49eee3531599',1,'sf::Keyboard::isKeyPressed(Key key)'],['../classsf_1_1Keyboard.html#a8364065ca899275ce3e9314cce98ed3e',1,'sf::Keyboard::isKeyPressed(Scancode code)']]], + ['isok_26',['isOk',['../classsf_1_1Ftp_1_1Response.html#a5102552955a2652c1a39e9046e617b36',1,'sf::Ftp::Response']]], + ['isopen_27',['isOpen',['../classsf_1_1WindowBase.html#aa43559822564ef958dc664a90c57cba0',1,'sf::WindowBase']]], + ['isready_28',['isReady',['../classsf_1_1SocketSelector.html#a917a4bac708290a6782e6686fd3bf889',1,'sf::SocketSelector']]], + ['isrelativetolistener_29',['isRelativeToListener',['../classsf_1_1SoundSource.html#adcdb4ef32c2f4481d34aff0b5c31534b',1,'sf::SoundSource']]], + ['isrepeated_30',['isRepeated',['../classsf_1_1RenderTexture.html#a81c5a453a21c7e78299b062b97dc8c87',1,'sf::RenderTexture::isRepeated()'],['../classsf_1_1Texture.html#af1a1a32ca5c799204b2bea4040df7647',1,'sf::Texture::isRepeated()']]], + ['issmooth_31',['isSmooth',['../classsf_1_1Font.html#ae5b59162507d5dd35f3ea0ee91e322ca',1,'sf::Font::isSmooth()'],['../classsf_1_1RenderTexture.html#a5b43c007ab6643accc5dae84b5bc8f61',1,'sf::RenderTexture::isSmooth()'],['../classsf_1_1Texture.html#a3ebb050b5a71e1d40ba66eb1a060e103',1,'sf::Texture::isSmooth()']]], + ['issrgb_32',['isSrgb',['../classsf_1_1RenderTarget.html#aea6b58e5b2423c917e2664ecd4952687',1,'sf::RenderTarget::isSrgb()'],['../classsf_1_1RenderTexture.html#a994f2fa5a4235cbbdb60d9d9a5eed07b',1,'sf::RenderTexture::isSrgb()'],['../classsf_1_1RenderWindow.html#ad943b4797fe6e1d609f12ce413b6a093',1,'sf::RenderWindow::isSrgb()'],['../classsf_1_1Texture.html#a9d77ce4f8124abfda96900a6bd53bfe9',1,'sf::Texture::isSrgb()']]], + ['isvalid_33',['isValid',['../classsf_1_1VideoMode.html#ad5e04c044b0925523c75ecb173d2129a',1,'sf::VideoMode']]], + ['italic_34',['Italic',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82aee249eb803848723c542c2062ebe69d8',1,'sf::Text']]], + ['iterator_35',['Iterator',['../classsf_1_1String.html#ac90f2b7b28f703020f8d027e98806235',1,'sf::String']]], + ['ivec2_36',['Ivec2',['../namespacesf_1_1Glsl.html#aab803ee70c4b7bfcd63ec09e10408fd3',1,'sf::Glsl']]], + ['ivec3_37',['Ivec3',['../namespacesf_1_1Glsl.html#a64f403dd0219e7f128ffddca641394df',1,'sf::Glsl']]], + ['ivec4_38',['Ivec4',['../namespacesf_1_1Glsl.html#a778682c4f085d2daeb90c724791f3f68',1,'sf::Glsl']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_9.js b/Space-Invaders/sfml/doc/html/search/all_9.js new file mode 100644 index 000000000..5466eaf43 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_9.js @@ -0,0 +1,17 @@ +var searchData= +[ + ['j_0',['J',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aaf9b207522e37466a19f92b8dc836735',1,'sf::Keyboard::Scan::J()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a948c634009beacdab42c3419253a5e85',1,'sf::Keyboard::J()']]], + ['joystick_1',['Joystick',['../classsf_1_1Joystick.html',1,'sf']]], + ['joystickbutton_2',['joystickButton',['../classsf_1_1Event.html#a42aad27a054c1c05bd5c3d020e1db174',1,'sf::Event']]], + ['joystickbuttonevent_3',['JoystickButtonEvent',['../structsf_1_1Event_1_1JoystickButtonEvent.html',1,'sf::Event']]], + ['joystickbuttonpressed_4',['JoystickButtonPressed',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa6d46855f0253f065689b69cd09437222',1,'sf::Event']]], + ['joystickbuttonreleased_5',['JoystickButtonReleased',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa2246ef5ee33f7fa4b2a53f042ceeac3d',1,'sf::Event']]], + ['joystickconnect_6',['joystickConnect',['../classsf_1_1Event.html#aa354335c9ad73362442bc54ffe81118f',1,'sf::Event']]], + ['joystickconnected_7',['JoystickConnected',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aaabb8877ec2f0c92904170deded09321e',1,'sf::Event']]], + ['joystickconnectevent_8',['JoystickConnectEvent',['../structsf_1_1Event_1_1JoystickConnectEvent.html',1,'sf::Event']]], + ['joystickdisconnected_9',['JoystickDisconnected',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aab6e161dab7abaf154cc1c7b554558cb6',1,'sf::Event']]], + ['joystickid_10',['joystickId',['../structsf_1_1Event_1_1JoystickConnectEvent.html#a08e58e8559d3e4fe4654855fec79194b',1,'sf::Event::JoystickConnectEvent::joystickId()'],['../structsf_1_1Event_1_1JoystickMoveEvent.html#a7bf2b2f2941a21ed26a67c95f5e4232f',1,'sf::Event::JoystickMoveEvent::joystickId()'],['../structsf_1_1Event_1_1JoystickButtonEvent.html#a2f80ecdb964a5ae0fc30726a404c41ec',1,'sf::Event::JoystickButtonEvent::joystickId()']]], + ['joystickmove_11',['joystickMove',['../classsf_1_1Event.html#ac479e8351cc2024d5c1094dc33970f7f',1,'sf::Event']]], + ['joystickmoved_12',['JoystickMoved',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa4d6ad228485c135967831be16ec074dd',1,'sf::Event']]], + ['joystickmoveevent_13',['JoystickMoveEvent',['../structsf_1_1Event_1_1JoystickMoveEvent.html',1,'sf::Event']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_a.js b/Space-Invaders/sfml/doc/html/search/all_a.js new file mode 100644 index 000000000..fc38181da --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_a.js @@ -0,0 +1,12 @@ +var searchData= +[ + ['k_0',['K',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a1e65a1d66582b430961cfc4e7cc76816',1,'sf::Keyboard::Scan::K()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a25beb62393ff666a4bec18ea2a66f3f2',1,'sf::Keyboard::K()']]], + ['keepalive_1',['keepAlive',['../classsf_1_1Ftp.html#aa1127d442b4acb2105aa8060a39d04fc',1,'sf::Ftp']]], + ['key_2',['key',['../classsf_1_1Event.html#a45b92fc6757ca7c193f06b302e424ab0',1,'sf::Event']]], + ['key_3',['Key',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142',1,'sf::Keyboard']]], + ['keyboard_4',['Keyboard',['../classsf_1_1Keyboard.html',1,'sf']]], + ['keycount_5',['KeyCount',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a93e6ffa0320fe9b2f29aec14a58be36b',1,'sf::Keyboard']]], + ['keyevent_6',['KeyEvent',['../structsf_1_1Event_1_1KeyEvent.html',1,'sf::Event']]], + ['keypressed_7',['KeyPressed',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aac3c7abfaa98c73bfe6be0b57df09c71b',1,'sf::Event']]], + ['keyreleased_8',['KeyReleased',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aaa5bcc1e603d5a6f4c137af39558bd5d1',1,'sf::Event']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_b.js b/Space-Invaders/sfml/doc/html/search/all_b.js new file mode 100644 index 000000000..51dcfc670 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_b.js @@ -0,0 +1,40 @@ +var searchData= +[ + ['l_0',['L',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ab6da0281265c57b9570de8be294d73b8',1,'sf::Keyboard::Scan::L()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a5ef1839ffe19b7e9c24f2ca017614ff9',1,'sf::Keyboard::L()']]], + ['lalt_1',['LAlt',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a9d640314aaa812b4646178409910043d',1,'sf::Keyboard::Scan::LAlt()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a000ecf5145296d7d52b6871c54e6718d',1,'sf::Keyboard::LAlt()']]], + ['launch_2',['launch',['../classsf_1_1Thread.html#a74f75a9e86e1eb47479496314048b5f6',1,'sf::Thread']]], + ['launchapplication1_3',['LaunchApplication1',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac195d6bb66bd43b6c89f70df8ecc7d4d',1,'sf::Keyboard::Scan']]], + ['launchapplication2_4',['LaunchApplication2',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a7fd8f0dfcbccd3e4c72269f8159b2170',1,'sf::Keyboard::Scan']]], + ['launchmail_5',['LaunchMail',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ab91775c7cc9288d35cadc11bc65b6994',1,'sf::Keyboard::Scan']]], + ['launchmediaselect_6',['LaunchMediaSelect',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a200b5a6f78bebcf697bb4e046c41fe4c',1,'sf::Keyboard::Scan']]], + ['lbracket_7',['LBracket',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3e4bb5cf828df8c4660d323df8589c43',1,'sf::Keyboard::Scan::LBracket()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142afbe21cad5f264d685cf7f25060004184',1,'sf::Keyboard::LBracket()']]], + ['lcontrol_8',['LControl',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa81bc64b2e4ca7eae223891075a1d754',1,'sf::Keyboard::Scan::LControl()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142acc76c9dec76d8ae806ae9d6515066e53',1,'sf::Keyboard::LControl()']]], + ['left_9',['Left',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac3fe5df11d15b57317c053a2ae13d9a9',1,'sf::Keyboard::Left()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a24060c475e1887a28d821b6174df10c9',1,'sf::Keyboard::Scan::Left()']]], + ['left_10',['left',['../classsf_1_1Rect.html#aa49960fa465103d9cb7069ceb25c7c32',1,'sf::Rect']]], + ['left_11',['Left',['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90a8bb4856e1ec7f6b6a8605effdfc0eee8',1,'sf::Mouse']]], + ['length_12',['length',['../structsf_1_1Music_1_1Span.html#a509fdbef69a8fc0f8430ecb7b9e76221',1,'sf::Music::Span']]], + ['lines_13',['Lines',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba2bf015eeff9f798dfc3d6d744d669f1e',1,'sf']]], + ['linesstrip_14',['LinesStrip',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba5b09910f5d0f39641342184ccd0d1de3',1,'sf']]], + ['linestrip_15',['LineStrip',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba14d9eeec2c7c314f239a57bde35949fa',1,'sf']]], + ['listen_16',['listen',['../classsf_1_1TcpListener.html#a9504758ea3570e62cb20b209c11776a1',1,'sf::TcpListener']]], + ['listener_17',['Listener',['../classsf_1_1Listener.html',1,'sf']]], + ['listingresponse_18',['ListingResponse',['../classsf_1_1Ftp_1_1ListingResponse.html#a7e98d0aed70105c71adb52e5b6ce0bb8',1,'sf::Ftp::ListingResponse::ListingResponse()'],['../classsf_1_1Ftp_1_1ListingResponse.html',1,'sf::Ftp::ListingResponse']]], + ['loadfromfile_19',['loadFromFile',['../classsf_1_1SoundBuffer.html#a2be6a8025c97eb622a7dff6cf2594394',1,'sf::SoundBuffer::loadFromFile()'],['../classsf_1_1Font.html#ab020052ef4e01f6c749a85571c0f3fd1',1,'sf::Font::loadFromFile()'],['../classsf_1_1Image.html#a9e4f2aa8e36d0cabde5ed5a4ef80290b',1,'sf::Image::loadFromFile()'],['../classsf_1_1Shader.html#a053a5632848ebaca2fcd8ba29abe9e6e',1,'sf::Shader::loadFromFile(const std::string &filename, Type type)'],['../classsf_1_1Shader.html#ac9d7289966fcef562eeb92271c03e3dc',1,'sf::Shader::loadFromFile(const std::string &vertexShaderFilename, const std::string &fragmentShaderFilename)'],['../classsf_1_1Shader.html#a295d8468811ca15bf9c5401a7a7d4f54',1,'sf::Shader::loadFromFile(const std::string &vertexShaderFilename, const std::string &geometryShaderFilename, const std::string &fragmentShaderFilename)'],['../classsf_1_1Texture.html#a8e1b56eabfe33e2e0e1cb03712c7fcc7',1,'sf::Texture::loadFromFile(const std::string &filename, const IntRect &area=IntRect())']]], + ['loadfromimage_20',['loadFromImage',['../classsf_1_1Texture.html#abec4567ad9856a3596dc74803f26fba2',1,'sf::Texture']]], + ['loadfrommemory_21',['loadFromMemory',['../classsf_1_1Image.html#aaa6c7afa5851a51cec6ab438faa7354c',1,'sf::Image::loadFromMemory()'],['../classsf_1_1Shader.html#ac92d46bf71dff2d791117e4e472148aa',1,'sf::Shader::loadFromMemory(const std::string &shader, Type type)'],['../classsf_1_1Shader.html#ae34e94070d7547a890166b7993658a9b',1,'sf::Shader::loadFromMemory(const std::string &vertexShader, const std::string &fragmentShader)'],['../classsf_1_1Shader.html#ab8c8b715b02aba2cf7c0a0e0c0984250',1,'sf::Shader::loadFromMemory(const std::string &vertexShader, const std::string &geometryShader, const std::string &fragmentShader)'],['../classsf_1_1Texture.html#a2c4adb19dd4cbee0a588eeb85e52a249',1,'sf::Texture::loadFromMemory()'],['../classsf_1_1SoundBuffer.html#af8cfa5599739a7edae69c5cba273d33f',1,'sf::SoundBuffer::loadFromMemory()'],['../classsf_1_1Font.html#abf2f8d6de31eb4e1db02e061c323e346',1,'sf::Font::loadFromMemory()']]], + ['loadfrompixels_22',['loadFromPixels',['../classsf_1_1Cursor.html#ac24ecf82ac7d9ba6703389397f948b3a',1,'sf::Cursor']]], + ['loadfromsamples_23',['loadFromSamples',['../classsf_1_1SoundBuffer.html#a42d51ce4bb3b60c7ea06f63c273fd063',1,'sf::SoundBuffer']]], + ['loadfromstream_24',['loadFromStream',['../classsf_1_1SoundBuffer.html#ad292156b1e01f6dabd4c0c277d5e079e',1,'sf::SoundBuffer::loadFromStream()'],['../classsf_1_1Font.html#abc3f37a354ce8b9a21f8eb93bd9fdafb',1,'sf::Font::loadFromStream()'],['../classsf_1_1Image.html#a21122ded0e8368bb06ed3b9acfbfb501',1,'sf::Image::loadFromStream()'],['../classsf_1_1Shader.html#a2ee1b130c0606e4f8bcdf65c1efc2a53',1,'sf::Shader::loadFromStream(InputStream &stream, Type type)'],['../classsf_1_1Shader.html#a3b7958159ffb5596c4babc3052e35465',1,'sf::Shader::loadFromStream(InputStream &vertexShaderStream, InputStream &fragmentShaderStream)'],['../classsf_1_1Shader.html#aa08f1c091806205e6654db9d83197fcd',1,'sf::Shader::loadFromStream(InputStream &vertexShaderStream, InputStream &geometryShaderStream, InputStream &fragmentShaderStream)'],['../classsf_1_1Texture.html#a786b486a46b1c6d1c16ff4af61ecc601',1,'sf::Texture::loadFromStream()']]], + ['loadfromsystem_25',['loadFromSystem',['../classsf_1_1Cursor.html#ad41999c8633c2fbaa2364e379c1ab25b',1,'sf::Cursor']]], + ['localerror_26',['LocalError',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bae54e84baaca95a7b36271ca3f3fdb900',1,'sf::Ftp::Response']]], + ['localhost_27',['LocalHost',['../classsf_1_1IpAddress.html#a594d3a8e2559f8fa8ab0a96fa597333b',1,'sf::IpAddress']]], + ['localize_28',['localize',['../classsf_1_1Keyboard.html#a4f77c97de21fbb14b9df79e320b12d9a',1,'sf::Keyboard']]], + ['lock_29',['lock',['../classsf_1_1Mutex.html#a1a16956a6bbea764480c1b80f2e45763',1,'sf::Mutex']]], + ['lock_30',['Lock',['../classsf_1_1Lock.html#a1a4c5d7a15da61103d85c9aa7f118920',1,'sf::Lock::Lock()'],['../classsf_1_1Lock.html',1,'sf::Lock']]], + ['loggedin_31',['LoggedIn',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba54a88210386cb72e35d737813a221754',1,'sf::Ftp::Response']]], + ['login_32',['login',['../classsf_1_1Ftp.html#a686262bc377584cd50e52e1576aa3a9b',1,'sf::Ftp::login()'],['../classsf_1_1Ftp.html#a99d8114793c1659e9d51d45cecdcd965',1,'sf::Ftp::login(const std::string &name, const std::string &password)']]], + ['lostfocus_33',['LostFocus',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aabd7877b5011a337268357c973e8347bd',1,'sf::Event']]], + ['lsbdelta_34',['lsbDelta',['../classsf_1_1Glyph.html#ab82761e8995ebd05c03d47ff0e064100',1,'sf::Glyph']]], + ['lshift_35',['LShift',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a99aa94c6db970fe2d06d6a0b265084d7',1,'sf::Keyboard::Scan::LShift()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a270db49f76cb4dbe72da36153d3aa45c',1,'sf::Keyboard::LShift()']]], + ['lsystem_36',['LSystem',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5e1b12c4476475396c6f04eccbbf04f7',1,'sf::Keyboard::Scan::LSystem()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a718171426307a0f5f26b4ae82a322b24',1,'sf::Keyboard::LSystem()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_c.js b/Space-Invaders/sfml/doc/html/search/all_c.js new file mode 100644 index 000000000..49aeaff05 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_c.js @@ -0,0 +1,50 @@ +var searchData= +[ + ['m_0',['M',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5a8351cbbb24d61c47f146f414ef825d',1,'sf::Keyboard::Scan::M()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a9718de9940f723c956587dcb90450a0a',1,'sf::Keyboard::M()']]], + ['m_5fsource_1',['m_source',['../classsf_1_1SoundSource.html#a0223cef4b1c587e6e1e17b4c92c4479c',1,'sf::SoundSource']]], + ['magenta_2',['Magenta',['../classsf_1_1Color.html#a6fe70d90b65b2163dd066a84ac00426c',1,'sf::Color']]], + ['magnetometer_3',['Magnetometer',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84ae706bb678bde8d3c370e246ffde6a63d',1,'sf::Sensor']]], + ['majorversion_4',['majorVersion',['../structsf_1_1ContextSettings.html#a99a680d5c15a7e34c935654155dd5166',1,'sf::ContextSettings']]], + ['mapcoordstopixel_5',['mapCoordsToPixel',['../classsf_1_1RenderTarget.html#ad92a9f0283aa5f3f67e473c1105b68cf',1,'sf::RenderTarget::mapCoordsToPixel(const Vector2f &point) const'],['../classsf_1_1RenderTarget.html#a848eee44b72ac3f16fa9182df26e83bc',1,'sf::RenderTarget::mapCoordsToPixel(const Vector2f &point, const View &view) const']]], + ['mappixeltocoords_6',['mapPixelToCoords',['../classsf_1_1RenderTarget.html#a0103ebebafa43a97e6e6414f8560d5e3',1,'sf::RenderTarget::mapPixelToCoords(const Vector2i &point) const'],['../classsf_1_1RenderTarget.html#a2d3e9d7c4a1f5ea7e52b06f53e3011f9',1,'sf::RenderTarget::mapPixelToCoords(const Vector2i &point, const View &view) const']]], + ['mat3_7',['Mat3',['../namespacesf_1_1Glsl.html#a9e984ebdc1cebc693a12f01a32b2d28d',1,'sf::Glsl']]], + ['mat4_8',['Mat4',['../namespacesf_1_1Glsl.html#a769de806596348a8e56ed6506c688271',1,'sf::Glsl']]], + ['max_9',['Max',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32a40ddfddfaafccc8b58478eeef52e4281',1,'sf::BlendMode']]], + ['maxdatagramsize_10',['MaxDatagramSize',['../classsf_1_1UdpSocket.html#a8ad087820b1ae07267858212f3d0fac5a728a7d33027bee0d65f70f964dd9c9eb',1,'sf::UdpSocket']]], + ['medianexttrack_11',['MediaNextTrack',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a08b48a760a2a550f21b3b6b184797742',1,'sf::Keyboard::Scan']]], + ['mediaplaypause_12',['MediaPlayPause',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a421303fdaaa4cbcf571ff6905808b69b',1,'sf::Keyboard::Scan']]], + ['mediaprevioustrack_13',['MediaPreviousTrack',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac2ac37264e076dcab002e24e54090dbc',1,'sf::Keyboard::Scan']]], + ['mediastop_14',['MediaStop',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6afe82e357291a40a03c85773eae734d',1,'sf::Keyboard::Scan']]], + ['memoryinputstream_15',['MemoryInputStream',['../classsf_1_1MemoryInputStream.html#a2d78851a69a8956a79872be41bcdfe0e',1,'sf::MemoryInputStream::MemoryInputStream()'],['../classsf_1_1MemoryInputStream.html',1,'sf::MemoryInputStream']]], + ['menu_16',['Menu',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad74c4a46669c3bd59ef93154e4669632',1,'sf::Keyboard::Scan::Menu()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a4aac50ce7c4923f96323fe84d592b139',1,'sf::Keyboard::Menu()']]], + ['method_17',['Method',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598',1,'sf::Http::Request']]], + ['microseconds_18',['microseconds',['../classsf_1_1Time.html#a8a6ae28a1962198a69b92355649c6aa0',1,'sf::Time']]], + ['middle_19',['Middle',['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90a2c353189c4b11cf216d7caddafcc609d',1,'sf::Mouse']]], + ['milliseconds_20',['milliseconds',['../classsf_1_1Time.html#a9231f886d925a24d181c8dcfa6448d87',1,'sf::Time']]], + ['min_21',['Min',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32aaaac595afe61d785aa8fd4b401acffc5',1,'sf::BlendMode']]], + ['minorversion_22',['minorVersion',['../structsf_1_1ContextSettings.html#aaeb0efe9d2658b840da93b30554b100f',1,'sf::ContextSettings']]], + ['modechange_23',['ModeChange',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adbd3b55bd8d0f7c790f30d5a5bb6660c',1,'sf::Keyboard::Scan']]], + ['mouse_24',['Mouse',['../classsf_1_1Mouse.html',1,'sf']]], + ['mousebutton_25',['mouseButton',['../classsf_1_1Event.html#a20886a16ab7624de070b97145bb1dcac',1,'sf::Event']]], + ['mousebuttonevent_26',['MouseButtonEvent',['../structsf_1_1Event_1_1MouseButtonEvent.html',1,'sf::Event']]], + ['mousebuttonpressed_27',['MouseButtonPressed',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa55a3dcc8bf6c40e37f9ff2cdf606481f',1,'sf::Event']]], + ['mousebuttonreleased_28',['MouseButtonReleased',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa9be69ecc07e484467ebbb133182fe5c1',1,'sf::Event']]], + ['mouseentered_29',['MouseEntered',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa50d98590a953e74c7ccf3dabadb22067',1,'sf::Event']]], + ['mouseleft_30',['MouseLeft',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aaa90b8526b328e0246d04b026de17c6e7',1,'sf::Event']]], + ['mousemove_31',['mouseMove',['../classsf_1_1Event.html#a786620ec4315d40c7c4cf4ddf3a1881f',1,'sf::Event']]], + ['mousemoved_32',['MouseMoved',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa4ff4fc3b3dc857e3617a63feb54be209',1,'sf::Event']]], + ['mousemoveevent_33',['MouseMoveEvent',['../structsf_1_1Event_1_1MouseMoveEvent.html',1,'sf::Event']]], + ['mousewheel_34',['mouseWheel',['../classsf_1_1Event.html#a8758c6d7998757978fd9146099a02a1e',1,'sf::Event']]], + ['mousewheelevent_35',['MouseWheelEvent',['../structsf_1_1Event_1_1MouseWheelEvent.html',1,'sf::Event']]], + ['mousewheelmoved_36',['MouseWheelMoved',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa5cc9d3941af2a36049f4f9922c934a80',1,'sf::Event']]], + ['mousewheelscroll_37',['mouseWheelScroll',['../classsf_1_1Event.html#a5fd91c82198a31a0cd3dc93c4d1ae4c6',1,'sf::Event']]], + ['mousewheelscrolled_38',['MouseWheelScrolled',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa2fb6925eb3e7f3d468faf639dbd129ad',1,'sf::Event']]], + ['mousewheelscrollevent_39',['MouseWheelScrollEvent',['../structsf_1_1Event_1_1MouseWheelScrollEvent.html',1,'sf::Event']]], + ['move_40',['move',['../classsf_1_1Transformable.html#a86b461d6a941ad390c2ad8b6a4a20391',1,'sf::Transformable::move(float offsetX, float offsetY)'],['../classsf_1_1Transformable.html#ab9ca691522f6ddc1a40406849b87c469',1,'sf::Transformable::move(const Vector2f &offset)'],['../classsf_1_1View.html#a0c82144b837caf812f7cb25a43d80c41',1,'sf::View::move(float offsetX, float offsetY)'],['../classsf_1_1View.html#a4c98a6e04fed756dfaff8f629de50862',1,'sf::View::move(const Vector2f &offset)']]], + ['movedpermanently_41',['MovedPermanently',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a2f91651db3a09628faf68cbcefa0810a',1,'sf::Http::Response']]], + ['movedtemporarily_42',['MovedTemporarily',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a05c50d7b17c844e0b909e5802d5f1587',1,'sf::Http::Response']]], + ['multiplechoices_43',['MultipleChoices',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8add95cbd8fa27516821f763488557f96b',1,'sf::Http::Response']]], + ['multiply_44',['Multiply',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a10623ae71db8a6b5d97189fc21fb91ae',1,'sf::Keyboard']]], + ['music_45',['Music',['../classsf_1_1Music.html#a0bc787d8e022b3a9b89cf2c28befd42e',1,'sf::Music::Music()'],['../classsf_1_1Music.html',1,'sf::Music']]], + ['mutex_46',['Mutex',['../classsf_1_1Mutex.html#a9bd52a48320fd7b6db8a78037aad276e',1,'sf::Mutex::Mutex()'],['../classsf_1_1Mutex.html',1,'sf::Mutex']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_d.js b/Space-Invaders/sfml/doc/html/search/all_d.js new file mode 100644 index 000000000..11fdc52d4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_d.js @@ -0,0 +1,52 @@ +var searchData= +[ + ['n_0',['N',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a72b52a30a5f3aee77dc52e7c54c8db9f',1,'sf::Keyboard::Scan::N()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab652ed6b308db95a74dc4ff5229ac9c8',1,'sf::Keyboard::N()']]], + ['name_1',['name',['../structsf_1_1Joystick_1_1Identification.html#a135a9a3a4dc11c2b5cde51159b4d136d',1,'sf::Joystick::Identification']]], + ['needaccounttologin_2',['NeedAccountToLogIn',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba9e048185f253f6eb6f5ff9e063b712fa',1,'sf::Ftp::Response']]], + ['needaccounttostore_3',['NeedAccountToStore',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba1af0f173062a471739b50d8e0f40d5f7',1,'sf::Ftp::Response']]], + ['needinformation_4',['NeedInformation',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba02e6f05964ecb829e9b6fb6020d6528a',1,'sf::Ftp::Response']]], + ['needpassword_5',['NeedPassword',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba9249e3fe9818eb93f181fbbf3ae3bc56',1,'sf::Ftp::Response']]], + ['network_20module_6',['Network module',['../group__network.html',1,'']]], + ['next_7',['next',['../classsf_1_1Utf_3_0116_01_4.html#ab899108d77ce088eb001588e84d91525',1,'sf::Utf< 16 >::next()'],['../classsf_1_1Utf_3_018_01_4.html#a0365a0b38700baa161843563d083edf6',1,'sf::Utf< 8 >::next()'],['../classsf_1_1Utf_3_0132_01_4.html#a788b4ebc728dde2aaba38f3605d4867c',1,'sf::Utf< 32 >::next()']]], + ['nocontent_8',['NoContent',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8aefde9e4abf5682dcd314d63143be42e0',1,'sf::Http::Response']]], + ['noloop_9',['NoLoop',['../classsf_1_1SoundStream.html#a7707214e7cd4ffcf1c123e7bcab4092aa2f2c638731fdff0d6fe4e3e82b6f6146',1,'sf::SoundStream']]], + ['noncopyable_10',['NonCopyable',['../classsf_1_1NonCopyable.html#a2110add170580fdb946f887719da6860',1,'sf::NonCopyable::NonCopyable()'],['../classsf_1_1NonCopyable.html',1,'sf::NonCopyable']]], + ['none_11',['None',['../classsf_1_1IpAddress.html#a4619b4abbe3c8fef056e7299db967404',1,'sf::IpAddress::None()'],['../group__window.html#gga97d7ee508bea4507ab40271518c732ffa8c35a9c8507559e455387fc4a83ce422',1,'sf::Style::None()']]], + ['nonusbackslash_12',['NonUsBackslash',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a44a8cbe245638c8431b233930f543a87',1,'sf::Keyboard::Scan']]], + ['normalized_13',['Normalized',['../classsf_1_1Texture.html#aa6fd3bbe3c334b3c4428edfb2765a82ea69d6228950882e4d68be4ba4dbe7df73',1,'sf::Texture']]], + ['notallowed_14',['NotAllowed',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aadb1ec726725dd81ec9906cbe06fec805',1,'sf::Cursor']]], + ['notenoughmemory_15',['NotEnoughMemory',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baf418e54753e0b8f9cb0325dd618acd14',1,'sf::Ftp::Response']]], + ['notfound_16',['NotFound',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8affca8a8319a62d98bd3ef90ff5cfc030',1,'sf::Http::Response']]], + ['notimplemented_17',['NotImplemented',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a6920ba06d7e2bcf0b325da23ee95ef68',1,'sf::Http::Response']]], + ['notloggedin_18',['NotLoggedIn',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bafcfbaff2c6fed941b6bcbc0999db764e',1,'sf::Ftp::Response']]], + ['notmodified_19',['NotModified',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a060ebc3af266e6bfe045b89e298e2545',1,'sf::Http::Response']]], + ['notready_20',['NotReady',['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dca8554848daae98f996e131bdeed076c09',1,'sf::Socket']]], + ['num0_21',['Num0',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adb7e8aa25d5d5204de03a5aa1ee0b390',1,'sf::Keyboard::Scan::Num0()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af026fd133ee93a0bd8c70762cc3be4bc',1,'sf::Keyboard::Num0()']]], + ['num1_22',['Num1',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adbf8eb09afd75e2081b009ad7a3596ef',1,'sf::Keyboard::Scan::Num1()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a506bd962cab80722a8c5a4b178912c59',1,'sf::Keyboard::Num1()']]], + ['num2_23',['Num2',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a16cfef5671ce6401aaf00316c88c0c7b',1,'sf::Keyboard::Scan::Num2()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a2d6eb5118179bb140fdb3485bb08c182',1,'sf::Keyboard::Num2()']]], + ['num3_24',['Num3',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3301c6093c6f2a78158c1e44e3431227',1,'sf::Keyboard::Scan::Num3()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aee78e5ed27d31598fc285400166c0dd5',1,'sf::Keyboard::Num3()']]], + ['num4_25',['Num4',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a15943e415124e0848e6b065d24b1b1e7',1,'sf::Keyboard::Scan::Num4()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a5fbd8a089460dc33c22f68b36e1fdc98',1,'sf::Keyboard::Num4()']]], + ['num5_26',['Num5',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875abf2de94b5156b86a228d7e5ec66d056a',1,'sf::Keyboard::Scan::Num5()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a1dc7e87810b8d4b7039e202b0adcc4ee',1,'sf::Keyboard::Num5()']]], + ['num6_27',['Num6',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6cd9d57ae648639eedcd16cb83da1af5',1,'sf::Keyboard::Scan::Num6()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af86dafb69d922ad2b0f4bd4c37696575',1,'sf::Keyboard::Num6()']]], + ['num7_28',['Num7',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aaf5540b714391414c06503b8aaee908a',1,'sf::Keyboard::Scan::Num7()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a8fa0056a0a6f5a7d9fcef3402c9c916d',1,'sf::Keyboard::Num7()']]], + ['num8_29',['Num8',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aee7fee4dc6a4dbfe9e038a5366cc1e4b',1,'sf::Keyboard::Scan::Num8()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142adb9f2549fd57bfd99d4713ff1845c530',1,'sf::Keyboard::Num8()']]], + ['num9_30',['Num9',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af003329d2c5a26d0262caf3ddef0a45e',1,'sf::Keyboard::Scan::Num9()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a9bc0d0727958bef97e2b6a58e23743db',1,'sf::Keyboard::Num9()']]], + ['numlock_31',['NumLock',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad1d1d7ce47ea768bcb565633fe9962b5',1,'sf::Keyboard::Scan']]], + ['numpad0_32',['Numpad0',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5852c4163a2cacb7979415d09412d500',1,'sf::Keyboard::Scan::Numpad0()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af0b2af83a7a8c358f7b8f7c403089a4e',1,'sf::Keyboard::Numpad0()']]], + ['numpad1_33',['Numpad1',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac17746b6b36dc8b79a222fa73ef2501e',1,'sf::Keyboard::Scan::Numpad1()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a03536d369ae55cc18024f7e4a341a5ac',1,'sf::Keyboard::Numpad1()']]], + ['numpad2_34',['Numpad2',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a53e419e5206289bcc16b4500bd8105af',1,'sf::Keyboard::Scan::Numpad2()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a8ad9ccf62631d583f44f06aebd662093',1,'sf::Keyboard::Numpad2()']]], + ['numpad3_35',['Numpad3',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a185a36e136a349d9073312919cede6a7',1,'sf::Keyboard::Scan::Numpad3()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab63ae26e90126b1842bde25d6dedb205',1,'sf::Keyboard::Numpad3()']]], + ['numpad4_36',['Numpad4',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a25c36d972efaf310f4f9d4ec23b89df5',1,'sf::Keyboard::Scan::Numpad4()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a65336d823bd823a0d246a872ff90e08a',1,'sf::Keyboard::Numpad4()']]], + ['numpad5_37',['Numpad5',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a8bc5041f12fdfbefba1dbd823c7e1054',1,'sf::Keyboard::Numpad5()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a8e370bc5b50d37f1ed280453fa6d47f6',1,'sf::Keyboard::Scan::Numpad5()']]], + ['numpad6_38',['Numpad6',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a58523c54f6cfb3844021e7a9526eb34b',1,'sf::Keyboard::Scan::Numpad6()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aaf28fdf0d3da6a18030e685478e3a713',1,'sf::Keyboard::Numpad6()']]], + ['numpad7_39',['Numpad7',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3d0502d5ad29d2e8bdfd5e4ab03252ee',1,'sf::Keyboard::Scan::Numpad7()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a3f9bf9835d65a0df5cce2d3842a40541',1,'sf::Keyboard::Numpad7()']]], + ['numpad8_40',['Numpad8',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a74fda39289bc3e8ff17d4aec863b7029',1,'sf::Keyboard::Scan::Numpad8()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a25dcd4e4183ceceb3ac06c72995bae49',1,'sf::Keyboard::Numpad8()']]], + ['numpad9_41',['Numpad9',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a335a1aa0289d7e582fdc924ca710cbc1',1,'sf::Keyboard::Scan::Numpad9()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a365eb80f54003670a78e3b850c28df21',1,'sf::Keyboard::Numpad9()']]], + ['numpaddecimal_42',['NumpadDecimal',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a62ce565c4d62bcbd9a9af09f8d4f80df',1,'sf::Keyboard::Scan']]], + ['numpaddivide_43',['NumpadDivide',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac3dc3e9289a9b7db8aa346c3f02b327d',1,'sf::Keyboard::Scan']]], + ['numpadenter_44',['NumpadEnter',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad6da599320b8c485ca42eb16e81d0ad0',1,'sf::Keyboard::Scan']]], + ['numpadequal_45',['NumpadEqual',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5b96402c34611cd5a7661c9c93e8dc0a',1,'sf::Keyboard::Scan']]], + ['numpadminus_46',['NumpadMinus',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae48b0805330de77fbf671644d446a9ef',1,'sf::Keyboard::Scan']]], + ['numpadmultiply_47',['NumpadMultiply',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875abd043b0e9270f97b4c1d6c2e4bf94288',1,'sf::Keyboard::Scan']]], + ['numpadplus_48',['NumpadPlus',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875abb76cfff74d39902a4c7b286520f1d5b',1,'sf::Keyboard::Scan']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_e.js b/Space-Invaders/sfml/doc/html/search/all_e.js new file mode 100644 index 000000000..d089f106c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_e.js @@ -0,0 +1,53 @@ +var searchData= +[ + ['o_0',['O',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aafe949e3a5c03b8981026f5b9621154b',1,'sf::Keyboard::Scan::O()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a7739288cc628dfa8c50ba712be7c03e1',1,'sf::Keyboard::O()']]], + ['offset_1',['offset',['../structsf_1_1Music_1_1Span.html#a49bb6a3c4239288cf47c1298c3e5e1a3',1,'sf::Music::Span']]], + ['ok_2',['Ok',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baa956e229ba6c0cdf0d88b0e05b286210',1,'sf::Ftp::Response::Ok()'],['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a0158f932254d3f09647dd1f64bd43832',1,'sf::Http::Response::Ok()']]], + ['oncreate_3',['onCreate',['../classsf_1_1RenderWindow.html#a5bef0040b0fa87bed9fbd459c980d53a',1,'sf::RenderWindow::onCreate()'],['../classsf_1_1WindowBase.html#a3397a7265f654be7ce9ccde3a53a39df',1,'sf::WindowBase::onCreate()']]], + ['one_4',['One',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbaa2d3ba8b8bb2233c9d357cbb94bf4181',1,'sf::BlendMode']]], + ['oneminusdstalpha_5',['OneMinusDstAlpha',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbab4e5c63f189f26075e5939ad1a2ce4e4',1,'sf::BlendMode']]], + ['oneminusdstcolor_6',['OneMinusDstColor',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbac8198db20d14506a841d1091ced1cae2',1,'sf::BlendMode']]], + ['oneminussrcalpha_7',['OneMinusSrcAlpha',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbaab57e8616bf4c21d8ee923178acdf2c8',1,'sf::BlendMode']]], + ['oneminussrccolor_8',['OneMinusSrcColor',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbba5971ffdbca63382058ccba76bfce219e',1,'sf::BlendMode']]], + ['ongetdata_9',['onGetData',['../classsf_1_1Music.html#aca1bcb4e5d56a854133e74bd86374463',1,'sf::Music::onGetData()'],['../classsf_1_1SoundStream.html#a968ec024a6e45490962c8a1121cb7c5f',1,'sf::SoundStream::onGetData(Chunk &data)=0']]], + ['onloop_10',['onLoop',['../classsf_1_1SoundStream.html#a3f717d18846f261fc375d71d6c7e41da',1,'sf::SoundStream::onLoop()'],['../classsf_1_1Music.html#aa68a64bdaf5d16e9ed64f202f5c45e03',1,'sf::Music::onLoop()']]], + ['onprocesssamples_11',['onProcessSamples',['../classsf_1_1SoundRecorder.html#a2670124cbe7a87c7e46b4840807f4fd7',1,'sf::SoundRecorder::onProcessSamples()'],['../classsf_1_1SoundBufferRecorder.html#a9ceb94de14632ae8c1b78faf603b4767',1,'sf::SoundBufferRecorder::onProcessSamples()']]], + ['onreceive_12',['onReceive',['../classsf_1_1Packet.html#ab71a31ef0f1d5d856de6f9fc75434128',1,'sf::Packet']]], + ['onresize_13',['onResize',['../classsf_1_1WindowBase.html#a8be41815cbeb89bc49e8752b62283192',1,'sf::WindowBase::onResize()'],['../classsf_1_1RenderWindow.html#a5c85fe482313562d33ffd24a194b6fef',1,'sf::RenderWindow::onResize()']]], + ['onseek_14',['onSeek',['../classsf_1_1Music.html#a15119cc0419c16bb334fa0698699c02e',1,'sf::Music::onSeek()'],['../classsf_1_1SoundStream.html#a907036dd2ca7d3af5ead316e54b75997',1,'sf::SoundStream::onSeek()']]], + ['onsend_15',['onSend',['../classsf_1_1Packet.html#af0003506bcb290407dcf5fe7f13a887d',1,'sf::Packet']]], + ['onstart_16',['onStart',['../classsf_1_1SoundBufferRecorder.html#a531a7445fc8a48eaf9fc039c83f17c6f',1,'sf::SoundBufferRecorder::onStart()'],['../classsf_1_1SoundRecorder.html#a7af418fb036201d3f85745bef78ce77f',1,'sf::SoundRecorder::onStart()']]], + ['onstop_17',['onStop',['../classsf_1_1SoundBufferRecorder.html#ab8e53849312413431873a5869d509f1e',1,'sf::SoundBufferRecorder::onStop()'],['../classsf_1_1SoundRecorder.html#aefc36138ca1e96c658301280e4a31b64',1,'sf::SoundRecorder::onStop()']]], + ['open_18',['open',['../classsf_1_1MemoryInputStream.html#ad3cfb4f4f915f7803d6a0784e394ac19',1,'sf::MemoryInputStream::open()'],['../classsf_1_1SoundFileReader.html#aa1d2fee2ba8f359c833ab74590d55935',1,'sf::SoundFileReader::open()'],['../classsf_1_1SoundFileWriter.html#a5c92bcaaa880ef4d3eaab18dae1d3d07',1,'sf::SoundFileWriter::open()'],['../classsf_1_1FileInputStream.html#a87a95dc3a71746097a99c86ee58bb353',1,'sf::FileInputStream::open()']]], + ['openfromfile_19',['openFromFile',['../classsf_1_1OutputSoundFile.html#ae5e55f01c53c1422c44eaed2eed67fce',1,'sf::OutputSoundFile::openFromFile()'],['../classsf_1_1InputSoundFile.html#af68e54bc9bfac19554c84601156fe93f',1,'sf::InputSoundFile::openFromFile()'],['../classsf_1_1Music.html#a3edc66e5f5b3f11e84b90eaec9c7d7c0',1,'sf::Music::openFromFile()']]], + ['openfrommemory_20',['openFromMemory',['../classsf_1_1InputSoundFile.html#a4e034a8e9e69ca3c33a3f11180250400',1,'sf::InputSoundFile::openFromMemory()'],['../classsf_1_1Music.html#ae93b21bcf28ff0b5fec458039111386e',1,'sf::Music::openFromMemory()']]], + ['openfromstream_21',['openFromStream',['../classsf_1_1InputSoundFile.html#a32b76497aeb088a2b46dc6efd819b909',1,'sf::InputSoundFile::openFromStream()'],['../classsf_1_1Music.html#a4e55d1910a26858b44778c26b237d673',1,'sf::Music::openFromStream()']]], + ['openingdataconnection_22',['OpeningDataConnection',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba794ebe743688be611447638bf9e49d86',1,'sf::Ftp::Response']]], + ['operator_20booltype_23',['operator BoolType',['../classsf_1_1Packet.html#a8ab20be4a63921b7cb1a4d8ca5c30f75',1,'sf::Packet']]], + ['operator_20t_2a_24',['operator T*',['../classsf_1_1ThreadLocalPtr.html#a81ca089ae5cda72c7470ca93041c3cb2',1,'sf::ThreadLocalPtr']]], + ['operator_21_3d_25',['operator!=',['../classsf_1_1VideoMode.html#a34b5c266a7b9cd5bc95de62f8beafc5a',1,'sf::VideoMode::operator!=()'],['../classsf_1_1Vector2.html#a01673da35ef9c52d0e54b8263549a956',1,'sf::Vector2::operator!=()'],['../classsf_1_1Vector3.html#a608500d1ad3b78082cb5bb4356742bd4',1,'sf::Vector3::operator!=()'],['../structsf_1_1BlendMode.html#aee6169f8983f5e92298c4ad6829563ba',1,'sf::BlendMode::operator!=()'],['../classsf_1_1Color.html#a394c3495753c4b17f9cd45556ef00b8c',1,'sf::Color::operator!=()'],['../classsf_1_1Rect.html#a03fc4c105687b7d0f07b6b4ed4b45581',1,'sf::Rect::operator!=()'],['../classsf_1_1Transform.html#a5eee840ff0b2db9e5f57a87281cc2b01',1,'sf::Transform::operator!=()'],['../classsf_1_1String.html#a3bfb9217788a9978499b8d5696bb0ef2',1,'sf::String::operator!=()'],['../classsf_1_1Time.html#a3a142729f295af8b1baf2d8762bc39ac',1,'sf::Time::operator!=(Time left, Time right)']]], + ['operator_25_26',['operator%',['../classsf_1_1Time.html#abe7206e15c2bf7ce8695f82219d466d2',1,'sf::Time']]], + ['operator_25_3d_27',['operator%=',['../classsf_1_1Time.html#a880fb0137cd426bd4457fd9e4a2f9d83',1,'sf::Time']]], + ['operator_2a_28',['operator*',['../classsf_1_1ThreadLocalPtr.html#adcbb45ae077df714bf9c61e936d97770',1,'sf::ThreadLocalPtr::operator*()'],['../classsf_1_1Color.html#a1bae779fb49bb92dbf820a65e45a6602',1,'sf::Color::operator*()'],['../classsf_1_1Transform.html#a85ea4e5539795f9b2ceb7d4b06736c8f',1,'sf::Transform::operator*(const Transform &left, const Transform &right)'],['../classsf_1_1Transform.html#a4eeee49125c3c72c250062eef35ceb75',1,'sf::Transform::operator*(const Transform &left, const Vector2f &right)'],['../classsf_1_1Time.html#ab891d4f3dbb454f6c1c484a7844bb581',1,'sf::Time::operator*(Time left, float right)'],['../classsf_1_1Time.html#a667d1568893f4e2520a223fa4e2b6ee2',1,'sf::Time::operator*(Time left, Int64 right)'],['../classsf_1_1Time.html#a61e3255c79b3d98a1a04ed8968a87863',1,'sf::Time::operator*(float left, Time right)'],['../classsf_1_1Time.html#a998a2ae6bd79e753bf9f4dea5b06370c',1,'sf::Time::operator*(Int64 left, Time right)'],['../classsf_1_1Vector2.html#a5f48ca928995b41c89f155afe8d16b02',1,'sf::Vector2::operator*(const Vector2< T > &left, T right)'],['../classsf_1_1Vector2.html#ad8b3e1cf7b156a984bc1427539ca8605',1,'sf::Vector2::operator*(T left, const Vector2< T > &right)'],['../classsf_1_1Vector3.html#a44ec312b31c1a85dcff4863795f98329',1,'sf::Vector3::operator*(const Vector3< T > &left, T right)'],['../classsf_1_1Vector3.html#aa6f2b0d9f79c1b9774759b7087affbb1',1,'sf::Vector3::operator*(T left, const Vector3< T > &right)']]], + ['operator_2a_3d_29',['operator*=',['../classsf_1_1Time.html#ac883749b4e0a72c32e166ad802220539',1,'sf::Time::operator*=()'],['../classsf_1_1Vector2.html#abea24cb28c0d6e2957e259ba4e65d70e',1,'sf::Vector2::operator*=()'],['../classsf_1_1Vector3.html#ad5fb972775ce8ab58cd9670789e806a7',1,'sf::Vector3::operator*=()'],['../classsf_1_1Color.html#a7d1ea2b9bd5dbe29bb2e54feba9b4b38',1,'sf::Color::operator*=()'],['../classsf_1_1Transform.html#a189899674616490f6250953ac581ac30',1,'sf::Transform::operator*=()'],['../classsf_1_1Time.html#a3f7baa961b8961fc5e6a37dea7de10e3',1,'sf::Time::operator*=(Time &left, float right)']]], + ['operator_2b_30',['operator+',['../classsf_1_1Time.html#a8249d3a28c8062c7c46cc426186f76c8',1,'sf::Time::operator+()'],['../classsf_1_1Vector2.html#a72421239823c38a6b780c86a710ead07',1,'sf::Vector2::operator+()'],['../classsf_1_1Vector3.html#a6500a0cb00e07801e9e9d7e96852ddd3',1,'sf::Vector3::operator+()'],['../classsf_1_1Color.html#a0355ba6bfd2f83ffd8f8fafdca26cdd0',1,'sf::Color::operator+()'],['../classsf_1_1String.html#af140f992b7698cf1448677c2c8e11bf1',1,'sf::String::operator+(const String &left, const String &right)']]], + ['operator_2b_3d_31',['operator+=',['../classsf_1_1String.html#afdae61e813b2951a6e39015e34a143f7',1,'sf::String::operator+=()'],['../classsf_1_1Color.html#af39790b2e677c9ab418787f5ff4583ef',1,'sf::Color::operator+=()'],['../classsf_1_1Time.html#a34b983deefecaf2725131771d54631e0',1,'sf::Time::operator+=()'],['../classsf_1_1Vector2.html#ad4b7a9d355d57790bfc7df0ade8bb628',1,'sf::Vector2::operator+=()'],['../classsf_1_1Vector3.html#abc28859af163c63318ea2723b81c5ad9',1,'sf::Vector3::operator+=()']]], + ['operator_2d_32',['operator-',['../classsf_1_1Vector2.html#a3885c2e66dc427cec7eaa178d59d8e8b',1,'sf::Vector2::operator-()'],['../classsf_1_1Vector3.html#a9b75d2fb9b0f2fd9fe33f8f06f9dda75',1,'sf::Vector3::operator-()'],['../classsf_1_1Vector2.html#ad027adae53ec547a86c20deeb05c9e85',1,'sf::Vector2::operator-()'],['../classsf_1_1Color.html#a4586e31d668f183fc46576511169bf2c',1,'sf::Color::operator-()'],['../classsf_1_1Time.html#acaead0aa2de9f82a548fcd8208a40f70',1,'sf::Time::operator-(Time right)'],['../classsf_1_1Time.html#aebd95ec0cd0b2dc5d858e70149ccd136',1,'sf::Time::operator-(Time left, Time right)'],['../classsf_1_1Vector3.html#abe0b9411c00cf807bf8a5f835874bd2a',1,'sf::Vector3::operator-()']]], + ['operator_2d_3d_33',['operator-=',['../classsf_1_1Color.html#a6927a7dba8b0d330f912fefb43b0c148',1,'sf::Color::operator-=()'],['../classsf_1_1Time.html#ae0a16136d024a44bbaa4ca49ac172c8f',1,'sf::Time::operator-=()'],['../classsf_1_1Vector2.html#a30a5a12ad03c9a3a982a0a313bf84e6f',1,'sf::Vector2::operator-=()'],['../classsf_1_1Vector3.html#aa465672d2a4ee5fd354e585cf08d2ab9',1,'sf::Vector3::operator-=()']]], + ['operator_2d_3e_34',['operator->',['../classsf_1_1ThreadLocalPtr.html#a25646e1014a933d1a45b9ce17bab7703',1,'sf::ThreadLocalPtr']]], + ['operator_2f_35',['operator/',['../classsf_1_1Time.html#a67510d018fd010819ee075db2cbd004f',1,'sf::Time::operator/(Time left, float right)'],['../classsf_1_1Time.html#a5f7b24dd13c0068d5cba678e1d5db9a6',1,'sf::Time::operator/(Time left, Int64 right)'],['../classsf_1_1Time.html#a097cf1326d2d50e0043ff4e865c1bbac',1,'sf::Time::operator/(Time left, Time right)'],['../classsf_1_1Vector2.html#a7409dd89cb3aad6c3bc6622311107311',1,'sf::Vector2::operator/()'],['../classsf_1_1Vector3.html#ad4ba4a83de236ddeb92a7b759187e90d',1,'sf::Vector3::operator/()']]], + ['operator_2f_3d_36',['operator/=',['../classsf_1_1Time.html#ad513a413be41bc66feb0ff2b29d5f947',1,'sf::Time::operator/=(Time &left, float right)'],['../classsf_1_1Time.html#ac4b8df6ef282ee71808fd185f91490aa',1,'sf::Time::operator/=(Time &left, Int64 right)'],['../classsf_1_1Vector2.html#ac4d293c9dc7954ccfd5e373972f38b03',1,'sf::Vector2::operator/=()'],['../classsf_1_1Vector3.html#a8995a700f9dffccc6dddb3696ae17b64',1,'sf::Vector3::operator/=()']]], + ['operator_3c_37',['operator<',['../classsf_1_1IpAddress.html#a4886da3f195b8c30d415a94a7009fdd7',1,'sf::IpAddress::operator<()'],['../classsf_1_1String.html#a5158a142e0966685ec7fb4e147b24ef0',1,'sf::String::operator<()'],['../classsf_1_1Time.html#a3bad89721b8c026e80082a7aa539f244',1,'sf::Time::operator<()'],['../classsf_1_1VideoMode.html#a54cc77c0b6c4b133e0147a43d6829b13',1,'sf::VideoMode::operator<()']]], + ['operator_3c_3c_38',['operator<<',['../classsf_1_1Packet.html#ae02c874e0aac18a0497fca982a8f9083',1,'sf::Packet::operator<<(bool data)'],['../classsf_1_1Packet.html#a97aa4ecba66b8f528438fc41ed020825',1,'sf::Packet::operator<<(Int8 data)'],['../classsf_1_1Packet.html#ad5cc1857ed14878ab7a8509db8d99335',1,'sf::Packet::operator<<(Uint8 data)'],['../classsf_1_1Packet.html#a9d9c5a1bef415046aa46d51e7d2a9f1c',1,'sf::Packet::operator<<(Int16 data)'],['../classsf_1_1Packet.html#afb6b2958f8a55923297da432c2a4f3e9',1,'sf::Packet::operator<<(Uint16 data)'],['../classsf_1_1Packet.html#af7f5c31c2d2749d3088783525f9fc974',1,'sf::Packet::operator<<(Int32 data)'],['../classsf_1_1Packet.html#ad1837e0990f71e3727e0e118ab9fd20e',1,'sf::Packet::operator<<(Uint32 data)'],['../classsf_1_1Packet.html#a6dc89edcfcf19daf781b776439aba94a',1,'sf::Packet::operator<<(Int64 data)'],['../classsf_1_1Packet.html#af3802406ed3430e20259e8551fa6554b',1,'sf::Packet::operator<<(Uint64 data)'],['../classsf_1_1Packet.html#acf1a231e48452a1cd55af2c027a1c1ee',1,'sf::Packet::operator<<(float data)'],['../classsf_1_1Packet.html#abee2df335bdc3ab40521248cdb187c02',1,'sf::Packet::operator<<(double data)'],['../classsf_1_1Packet.html#a94522071d95189ddff1ae7ca832695ff',1,'sf::Packet::operator<<(const char *data)'],['../classsf_1_1Packet.html#ac45aab054ddee7de9599bc3b2d8e025f',1,'sf::Packet::operator<<(const std::string &data)'],['../classsf_1_1Packet.html#ac5a13e3280cac77799f7fdadfe3e37b6',1,'sf::Packet::operator<<(const wchar_t *data)'],['../classsf_1_1Packet.html#a97acaefaee7d3ffb36f4e8a00d4c3970',1,'sf::Packet::operator<<(const std::wstring &data)'],['../classsf_1_1Packet.html#a5ef2e3308b93b80214b42a7d4683704a',1,'sf::Packet::operator<<(const String &data)']]], + ['operator_3c_3d_39',['operator<=',['../classsf_1_1String.html#ac1c1bb5dcf02aad3b2c0a1bf74a11cc9',1,'sf::String::operator<=()'],['../classsf_1_1Time.html#aafb9de87ed6047956cd9487ab807371f',1,'sf::Time::operator<=()'],['../classsf_1_1VideoMode.html#aa094b7b9ae4c0194892ebda7b4b9bb37',1,'sf::VideoMode::operator<=()']]], + ['operator_3d_40',['operator=',['../classsf_1_1Sound.html#a8eee9197359bfdf20d399544a894af8b',1,'sf::Sound::operator=()'],['../classsf_1_1SoundBuffer.html#ad0b6f45d3008cd7d29d340195e68459a',1,'sf::SoundBuffer::operator=()'],['../classsf_1_1SoundSource.html#a4b494e4a0b819bae9cd99b43e2f3f59d',1,'sf::SoundSource::operator=()'],['../classsf_1_1Font.html#af9be4336df9121ec1b6f14fa9063e46e',1,'sf::Font::operator=()'],['../classsf_1_1Texture.html#a8d856e3b5865984d6ba0c25ac04fbedb',1,'sf::Texture::operator=()'],['../classsf_1_1VertexBuffer.html#ae9d19f938e30e1bb1788067e3c134653',1,'sf::VertexBuffer::operator=()'],['../classsf_1_1SocketSelector.html#af7247f1c8badd43932f3adcbc1fec7e8',1,'sf::SocketSelector::operator=()'],['../classsf_1_1String.html#af14c8e1bf351cf18486f0258c36260d7',1,'sf::String::operator=()'],['../classsf_1_1ThreadLocalPtr.html#a14dcf1cdf5f6b3bcdd633014b2b671f5',1,'sf::ThreadLocalPtr::operator=(T *value)'],['../classsf_1_1ThreadLocalPtr.html#a6792a6a808af06f0d13e3ceecf2fc947',1,'sf::ThreadLocalPtr::operator=(const ThreadLocalPtr< T > &right)']]], + ['operator_3d_3d_41',['operator==',['../structsf_1_1BlendMode.html#a20d1be06061109c3cef58e0cc38729ea',1,'sf::BlendMode::operator==()'],['../classsf_1_1Color.html#a2adc3f68860f7aa5e4d7c79dcbb31d30',1,'sf::Color::operator==()'],['../classsf_1_1Rect.html#ab3488b5dbd0e587c4d7cb80605affc46',1,'sf::Rect::operator==()'],['../classsf_1_1Transform.html#aa2de0a3ee2f8af05dbc94bf3b4633b4a',1,'sf::Transform::operator==()'],['../classsf_1_1String.html#a483931724196c580552b68751fb4d837',1,'sf::String::operator==()'],['../classsf_1_1Time.html#a9bbb2368cf012149f1001535a20c664a',1,'sf::Time::operator==()'],['../classsf_1_1Vector2.html#a9a7b2d36c3850828fdb651facfd25136',1,'sf::Vector2::operator==()'],['../classsf_1_1Vector3.html#a388d72db973306a35ba467016b3dee30',1,'sf::Vector3::operator==()'],['../classsf_1_1VideoMode.html#aca24086fd94d11014f3a0b5ca9a3acd6',1,'sf::VideoMode::operator==()']]], + ['operator_3e_42',['operator>',['../classsf_1_1String.html#ac96278a8cbe282632b11f0c8c007df0c',1,'sf::String::operator>()'],['../classsf_1_1Time.html#a9a472ce6d82aa0caf8e20af4a4b309f2',1,'sf::Time::operator>()'],['../classsf_1_1VideoMode.html#a5b894cab5f2a3a14597e4c6d200179a4',1,'sf::VideoMode::operator>()']]], + ['operator_3e_3d_43',['operator>=',['../classsf_1_1String.html#a112689eec28e0ca9489e8c4ec6a34493',1,'sf::String::operator>=()'],['../classsf_1_1Time.html#a158c5f9a6abf575651b7b2f6af8aedaa',1,'sf::Time::operator>=()'],['../classsf_1_1VideoMode.html#a6e3d91683fcabb88c5b640e9884fe3df',1,'sf::VideoMode::operator>=()']]], + ['operator_3e_3e_44',['operator>>',['../classsf_1_1Packet.html#a8b6403506fec6b69f033278de33c8145',1,'sf::Packet::operator>>(bool &data)'],['../classsf_1_1Packet.html#a1c7814f9dbc637986ac498094add5ca5',1,'sf::Packet::operator>>(Int8 &data)'],['../classsf_1_1Packet.html#a48df8986fc24551f1287144d3e990859',1,'sf::Packet::operator>>(Uint8 &data)'],['../classsf_1_1Packet.html#ae455be24bfd8dbaa4cd5097e0fb70ecd',1,'sf::Packet::operator>>(Int16 &data)'],['../classsf_1_1Packet.html#a6bc20f1be9a63407079e6d26171ac71f',1,'sf::Packet::operator>>(Uint16 &data)'],['../classsf_1_1Packet.html#a663e71b25a9352e3c4ddf4a3ce9db921',1,'sf::Packet::operator>>(Int32 &data)'],['../classsf_1_1Packet.html#aa3b0fabe6c14bcfa29bb04844b8bb987',1,'sf::Packet::operator>>(Uint32 &data)'],['../classsf_1_1Packet.html#ae76105996a6c2217bb3a4571603e92f6',1,'sf::Packet::operator>>(Int64 &data)'],['../classsf_1_1Packet.html#a79f7c144fd07a4036ffc7b0870a36613',1,'sf::Packet::operator>>(Uint64 &data)'],['../classsf_1_1Packet.html#a741849607d428e93c532e11eadcc39f1',1,'sf::Packet::operator>>(float &data)'],['../classsf_1_1Packet.html#a1854ca771105fb281edf349fc6507c73',1,'sf::Packet::operator>>(double &data)'],['../classsf_1_1Packet.html#aaed01fec1a3eae27a028506195607f82',1,'sf::Packet::operator>>(char *data)'],['../classsf_1_1Packet.html#a60484dff69997db11e2d4ab3704ab921',1,'sf::Packet::operator>>(std::string &data)'],['../classsf_1_1Packet.html#a8805e66013f9f84ec8a883e42ae259d4',1,'sf::Packet::operator>>(wchar_t *data)'],['../classsf_1_1Packet.html#a8621056995c32bcf59809e2aecf08635',1,'sf::Packet::operator>>(std::wstring &data)'],['../classsf_1_1Packet.html#a27d0ae92891dbf8a7914e5d5232940d0',1,'sf::Packet::operator>>(String &data)']]], + ['operator_5b_5d_45',['operator[]',['../classsf_1_1VertexArray.html#a913953848726c1c65f8617497e8fccd6',1,'sf::VertexArray::operator[](std::size_t index)'],['../classsf_1_1VertexArray.html#a8336081e73a14a5e4ad0aa9f926d82be',1,'sf::VertexArray::operator[](std::size_t index) const'],['../classsf_1_1String.html#a035c1b585a0ebed81e773ecafed57926',1,'sf::String::operator[](std::size_t index) const'],['../classsf_1_1String.html#a3e2041bd9ae84d223e6b12e46e5aa5d6',1,'sf::String::operator[](std::size_t index)']]], + ['orientation_46',['Orientation',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84aa428c5260446555de87c69b65f6edf00',1,'sf::Sensor']]], + ['outputsoundfile_47',['OutputSoundFile',['../classsf_1_1OutputSoundFile.html#a7ae9f2dbd0991fa9394726a3d58bb19e',1,'sf::OutputSoundFile::OutputSoundFile()'],['../classsf_1_1OutputSoundFile.html',1,'sf::OutputSoundFile']]], + ['string_48',['string',['../classsf_1_1String.html#a884816a0f688cfd48f9324c9741dc257',1,'sf::String']]], + ['wstring_49',['wstring',['../classsf_1_1String.html#a6bd1444bebaca9bbf01ba203061f5076',1,'sf::String']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/all_f.js b/Space-Invaders/sfml/doc/html/search/all_f.js new file mode 100644 index 000000000..7f7cde815 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/all_f.js @@ -0,0 +1,34 @@ +var searchData= +[ + ['p_0',['P',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a0943cf62e03a8616a8a41b72539ded38',1,'sf::Keyboard::Scan::P()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aaeac1db209a64a0221277a835de986e6',1,'sf::Keyboard::P()']]], + ['packet_1',['Packet',['../classsf_1_1Packet.html#a786e5d4ced83992ceefa1799963ea858',1,'sf::Packet::Packet()'],['../classsf_1_1Packet.html',1,'sf::Packet']]], + ['pagedown_2',['PageDown',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a395ec644184fe789a12ee2ed98d19ee3',1,'sf::Keyboard::Scan::PageDown()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a21c73323d9a8b6017f3bac0cb8c8ac1a',1,'sf::Keyboard::PageDown()']]], + ['pagetypeunknown_3',['PageTypeUnknown',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bad220bc12dc45593af6e5079ea6c532c3',1,'sf::Ftp::Response']]], + ['pageup_4',['PageUp',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a0c1f655bf99a3c7d2052814385fb222d',1,'sf::Keyboard::Scan::PageUp()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aa24fe33bba1c3639c3aeaa317bd89d7e',1,'sf::Keyboard::PageUp()']]], + ['parameternotimplemented_5',['ParameterNotImplemented',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba8807473b8590e1debfb3740b7a3d081c',1,'sf::Ftp::Response']]], + ['parametersunknown_6',['ParametersUnknown',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baf4c7c88815981bbb7c3a3461f9f48b67',1,'sf::Ftp::Response']]], + ['parentdirectory_7',['parentDirectory',['../classsf_1_1Ftp.html#ad295cf77f30f9ad07b5c401fd9849189',1,'sf::Ftp']]], + ['partial_8',['Partial',['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dca181c163fad2eaea927185d127c392706',1,'sf::Socket']]], + ['partialcontent_9',['PartialContent',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a0cfae3ab0469b73dfddc54312a5e6a8a',1,'sf::Http::Response']]], + ['paste_10',['Paste',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ab5417583410afc02cad51e66cb97b196',1,'sf::Keyboard::Scan']]], + ['pause_11',['pause',['../classsf_1_1Sound.html#a5eeb25815bfa8cdc4a6cc000b7b19ad5',1,'sf::Sound::pause()'],['../classsf_1_1SoundSource.html#a21553d4e8fcf136231dd8c7ad4630aba',1,'sf::SoundSource::pause()'],['../classsf_1_1SoundStream.html#a932ff181e661503cad288b4bb6fe45ca',1,'sf::SoundStream::pause()']]], + ['pause_12',['Pause',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a40a805122e3ce91bde95d98ac43be234',1,'sf::Keyboard::Scan::Pause()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a95daf340fcc3d5c2846f69d184170d9b',1,'sf::Keyboard::Pause()']]], + ['paused_13',['Paused',['../classsf_1_1SoundSource.html#ac43af72c98c077500b239bc75b812f03ac3ca1fcc0394267c9bdbe3dc0a8a7e41',1,'sf::SoundSource']]], + ['period_14',['Period',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae09b8ab0fa58ee31f499678d3e93a411',1,'sf::Keyboard::Scan::Period()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac72ba959ab1946957e8dfd4f81ea811d',1,'sf::Keyboard::Period()']]], + ['pixels_15',['Pixels',['../classsf_1_1Texture.html#aa6fd3bbe3c334b3c4428edfb2765a82ea6372f9c3a10203a7a69d8d5da59d82ff',1,'sf::Texture']]], + ['play_16',['play',['../classsf_1_1Sound.html#a2953ffe632536e72e696fd880ced2532',1,'sf::Sound::play()'],['../classsf_1_1SoundSource.html#a6e1bbb1f247ed8743faf3b1ed6f2bc21',1,'sf::SoundSource::play()'],['../classsf_1_1SoundStream.html#afdc08b69cab5f243d9324940a85a1144',1,'sf::SoundStream::play()']]], + ['playing_17',['Playing',['../classsf_1_1SoundSource.html#ac43af72c98c077500b239bc75b812f03af07bdea9f70ef7606dfc9f955beeee18',1,'sf::SoundSource']]], + ['pointlesscommand_18',['PointlessCommand',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba38adc424f1adcd332745de8cd3b7737a',1,'sf::Ftp::Response']]], + ['points_19',['Points',['../group__graphics.html#gga5ee56ac1339984909610713096283b1bac7097d3e01778b9318def1f7ac35a785',1,'sf']]], + ['pollevent_20',['pollEvent',['../classsf_1_1WindowBase.html#a6a143de089c8716bd42c38c781268f7f',1,'sf::WindowBase']]], + ['popglstates_21',['popGLStates',['../classsf_1_1RenderTarget.html#ad5a98401113df931ddcd54c080f7aa8e',1,'sf::RenderTarget']]], + ['position_22',['position',['../classsf_1_1Vertex.html#a8a4e0f4dfa7f1eb215c92e93d04f0ac0',1,'sf::Vertex::position()'],['../structsf_1_1Event_1_1JoystickMoveEvent.html#aba5a70815420161375fd2e756689c32a',1,'sf::Event::JoystickMoveEvent::position()']]], + ['post_23',['Post',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598ae8ec4048b9550f8d0747d4199603141a',1,'sf::Http::Request']]], + ['povx_24',['PovX',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a06420f7714e4dfd8b841885a0b5f3954',1,'sf::Joystick']]], + ['povy_25',['PovY',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a0f8ffb2dcddf91b98ab910a4f8327ad9',1,'sf::Joystick']]], + ['primitivetype_26',['PrimitiveType',['../group__graphics.html#ga5ee56ac1339984909610713096283b1b',1,'sf']]], + ['printscreen_27',['PrintScreen',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a8699683af17a0a4031bccf52f5222302',1,'sf::Keyboard::Scan']]], + ['productid_28',['productId',['../structsf_1_1Joystick_1_1Identification.html#a18c21317789f51f9a5f132677727ff77',1,'sf::Joystick::Identification']]], + ['pushglstates_29',['pushGLStates',['../classsf_1_1RenderTarget.html#a8d1998464ccc54e789aaf990242b47f7',1,'sf::RenderTarget']]], + ['put_30',['Put',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598a523b94f9af069c1f35061d32011e2495',1,'sf::Http::Request']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_0.js b/Space-Invaders/sfml/doc/html/search/classes_0.js new file mode 100644 index 000000000..4f0dabfff --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['alresource_0',['AlResource',['../classsf_1_1AlResource.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_1.js b/Space-Invaders/sfml/doc/html/search/classes_1.js new file mode 100644 index 000000000..7fa8f18e1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_1.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['blendmode_0',['BlendMode',['../structsf_1_1BlendMode.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_10.js b/Space-Invaders/sfml/doc/html/search/classes_10.js new file mode 100644 index 000000000..b84a465c6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_10.js @@ -0,0 +1,13 @@ +var searchData= +[ + ['rect_0',['Rect',['../classsf_1_1Rect.html',1,'sf']]], + ['rect_3c_20float_20_3e_1',['Rect< float >',['../classsf_1_1Rect.html',1,'sf']]], + ['rect_3c_20int_20_3e_2',['Rect< int >',['../classsf_1_1Rect.html',1,'sf']]], + ['rectangleshape_3',['RectangleShape',['../classsf_1_1RectangleShape.html',1,'sf']]], + ['renderstates_4',['RenderStates',['../classsf_1_1RenderStates.html',1,'sf']]], + ['rendertarget_5',['RenderTarget',['../classsf_1_1RenderTarget.html',1,'sf']]], + ['rendertexture_6',['RenderTexture',['../classsf_1_1RenderTexture.html',1,'sf']]], + ['renderwindow_7',['RenderWindow',['../classsf_1_1RenderWindow.html',1,'sf']]], + ['request_8',['Request',['../classsf_1_1Http_1_1Request.html',1,'sf::Http']]], + ['response_9',['Response',['../classsf_1_1Ftp_1_1Response.html',1,'sf::Ftp::Response'],['../classsf_1_1Http_1_1Response.html',1,'sf::Http::Response']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_11.js b/Space-Invaders/sfml/doc/html/search/classes_11.js new file mode 100644 index 000000000..da0978dde --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_11.js @@ -0,0 +1,24 @@ +var searchData= +[ + ['scan_0',['Scan',['../structsf_1_1Keyboard_1_1Scan.html',1,'sf::Keyboard']]], + ['sensor_1',['Sensor',['../classsf_1_1Sensor.html',1,'sf']]], + ['sensorevent_2',['SensorEvent',['../structsf_1_1Event_1_1SensorEvent.html',1,'sf::Event']]], + ['shader_3',['Shader',['../classsf_1_1Shader.html',1,'sf']]], + ['shape_4',['Shape',['../classsf_1_1Shape.html',1,'sf']]], + ['sizeevent_5',['SizeEvent',['../structsf_1_1Event_1_1SizeEvent.html',1,'sf::Event']]], + ['socket_6',['Socket',['../classsf_1_1Socket.html',1,'sf']]], + ['socketselector_7',['SocketSelector',['../classsf_1_1SocketSelector.html',1,'sf']]], + ['sound_8',['Sound',['../classsf_1_1Sound.html',1,'sf']]], + ['soundbuffer_9',['SoundBuffer',['../classsf_1_1SoundBuffer.html',1,'sf']]], + ['soundbufferrecorder_10',['SoundBufferRecorder',['../classsf_1_1SoundBufferRecorder.html',1,'sf']]], + ['soundfilefactory_11',['SoundFileFactory',['../classsf_1_1SoundFileFactory.html',1,'sf']]], + ['soundfilereader_12',['SoundFileReader',['../classsf_1_1SoundFileReader.html',1,'sf']]], + ['soundfilewriter_13',['SoundFileWriter',['../classsf_1_1SoundFileWriter.html',1,'sf']]], + ['soundrecorder_14',['SoundRecorder',['../classsf_1_1SoundRecorder.html',1,'sf']]], + ['soundsource_15',['SoundSource',['../classsf_1_1SoundSource.html',1,'sf']]], + ['soundstream_16',['SoundStream',['../classsf_1_1SoundStream.html',1,'sf']]], + ['span_17',['Span',['../structsf_1_1Music_1_1Span.html',1,'sf::Music']]], + ['span_3c_20uint64_20_3e_18',['Span< Uint64 >',['../structsf_1_1Music_1_1Span.html',1,'sf::Music']]], + ['sprite_19',['Sprite',['../classsf_1_1Sprite.html',1,'sf']]], + ['string_20',['String',['../classsf_1_1String.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_12.js b/Space-Invaders/sfml/doc/html/search/classes_12.js new file mode 100644 index 000000000..181ec4674 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_12.js @@ -0,0 +1,17 @@ +var searchData= +[ + ['tcplistener_0',['TcpListener',['../classsf_1_1TcpListener.html',1,'sf']]], + ['tcpsocket_1',['TcpSocket',['../classsf_1_1TcpSocket.html',1,'sf']]], + ['text_2',['Text',['../classsf_1_1Text.html',1,'sf']]], + ['textevent_3',['TextEvent',['../structsf_1_1Event_1_1TextEvent.html',1,'sf::Event']]], + ['texture_4',['Texture',['../classsf_1_1Texture.html',1,'sf']]], + ['thread_5',['Thread',['../classsf_1_1Thread.html',1,'sf']]], + ['threadlocal_6',['ThreadLocal',['../classsf_1_1ThreadLocal.html',1,'sf']]], + ['threadlocalptr_7',['ThreadLocalPtr',['../classsf_1_1ThreadLocalPtr.html',1,'sf']]], + ['time_8',['Time',['../classsf_1_1Time.html',1,'sf']]], + ['touch_9',['Touch',['../classsf_1_1Touch.html',1,'sf']]], + ['touchevent_10',['TouchEvent',['../structsf_1_1Event_1_1TouchEvent.html',1,'sf::Event']]], + ['transform_11',['Transform',['../classsf_1_1Transform.html',1,'sf']]], + ['transformable_12',['Transformable',['../classsf_1_1Transformable.html',1,'sf']]], + ['transientcontextlock_13',['TransientContextLock',['../classsf_1_1GlResource_1_1TransientContextLock.html',1,'sf::GlResource']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_13.js b/Space-Invaders/sfml/doc/html/search/classes_13.js new file mode 100644 index 000000000..32fc63d1d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_13.js @@ -0,0 +1,8 @@ +var searchData= +[ + ['udpsocket_0',['UdpSocket',['../classsf_1_1UdpSocket.html',1,'sf']]], + ['utf_1',['Utf',['../classsf_1_1Utf.html',1,'sf']]], + ['utf_3c_2016_20_3e_2',['Utf< 16 >',['../classsf_1_1Utf_3_0116_01_4.html',1,'sf']]], + ['utf_3c_2032_20_3e_3',['Utf< 32 >',['../classsf_1_1Utf_3_0132_01_4.html',1,'sf']]], + ['utf_3c_208_20_3e_4',['Utf< 8 >',['../classsf_1_1Utf_3_018_01_4.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_14.js b/Space-Invaders/sfml/doc/html/search/classes_14.js new file mode 100644 index 000000000..56df1a98c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_14.js @@ -0,0 +1,13 @@ +var searchData= +[ + ['vector2_0',['Vector2',['../classsf_1_1Vector2.html',1,'sf']]], + ['vector2_3c_20float_20_3e_1',['Vector2< float >',['../classsf_1_1Vector2.html',1,'sf']]], + ['vector2_3c_20unsigned_20int_20_3e_2',['Vector2< unsigned int >',['../classsf_1_1Vector2.html',1,'sf']]], + ['vector3_3',['Vector3',['../classsf_1_1Vector3.html',1,'sf']]], + ['vertex_4',['Vertex',['../classsf_1_1Vertex.html',1,'sf']]], + ['vertexarray_5',['VertexArray',['../classsf_1_1VertexArray.html',1,'sf']]], + ['vertexbuffer_6',['VertexBuffer',['../classsf_1_1VertexBuffer.html',1,'sf']]], + ['videomode_7',['VideoMode',['../classsf_1_1VideoMode.html',1,'sf']]], + ['view_8',['View',['../classsf_1_1View.html',1,'sf']]], + ['vulkan_9',['Vulkan',['../classsf_1_1Vulkan.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_15.js b/Space-Invaders/sfml/doc/html/search/classes_15.js new file mode 100644 index 000000000..8fafe6ed1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_15.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['window_0',['Window',['../classsf_1_1Window.html',1,'sf']]], + ['windowbase_1',['WindowBase',['../classsf_1_1WindowBase.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_2.js b/Space-Invaders/sfml/doc/html/search/classes_2.js new file mode 100644 index 000000000..61eb4e188 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_2.js @@ -0,0 +1,13 @@ +var searchData= +[ + ['chunk_0',['Chunk',['../structsf_1_1SoundStream_1_1Chunk.html',1,'sf::SoundStream']]], + ['circleshape_1',['CircleShape',['../classsf_1_1CircleShape.html',1,'sf']]], + ['clipboard_2',['Clipboard',['../classsf_1_1Clipboard.html',1,'sf']]], + ['clock_3',['Clock',['../classsf_1_1Clock.html',1,'sf']]], + ['color_4',['Color',['../classsf_1_1Color.html',1,'sf']]], + ['context_5',['Context',['../classsf_1_1Context.html',1,'sf']]], + ['contextsettings_6',['ContextSettings',['../structsf_1_1ContextSettings.html',1,'sf']]], + ['convexshape_7',['ConvexShape',['../classsf_1_1ConvexShape.html',1,'sf']]], + ['currenttexturetype_8',['CurrentTextureType',['../structsf_1_1Shader_1_1CurrentTextureType.html',1,'sf::Shader']]], + ['cursor_9',['Cursor',['../classsf_1_1Cursor.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_3.js b/Space-Invaders/sfml/doc/html/search/classes_3.js new file mode 100644 index 000000000..3f87af8f6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_3.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['directoryresponse_0',['DirectoryResponse',['../classsf_1_1Ftp_1_1DirectoryResponse.html',1,'sf::Ftp']]], + ['drawable_1',['Drawable',['../classsf_1_1Drawable.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_4.js b/Space-Invaders/sfml/doc/html/search/classes_4.js new file mode 100644 index 000000000..be1aadf7d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_4.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['event_0',['Event',['../classsf_1_1Event.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_5.js b/Space-Invaders/sfml/doc/html/search/classes_5.js new file mode 100644 index 000000000..0a9a1581a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_5.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['fileinputstream_0',['FileInputStream',['../classsf_1_1FileInputStream.html',1,'sf']]], + ['font_1',['Font',['../classsf_1_1Font.html',1,'sf']]], + ['ftp_2',['Ftp',['../classsf_1_1Ftp.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_6.js b/Space-Invaders/sfml/doc/html/search/classes_6.js new file mode 100644 index 000000000..fdc8b9d7e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_6.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['glresource_0',['GlResource',['../classsf_1_1GlResource.html',1,'sf']]], + ['glyph_1',['Glyph',['../classsf_1_1Glyph.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_7.js b/Space-Invaders/sfml/doc/html/search/classes_7.js new file mode 100644 index 000000000..793e5e7ef --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_7.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['http_0',['Http',['../classsf_1_1Http.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_8.js b/Space-Invaders/sfml/doc/html/search/classes_8.js new file mode 100644 index 000000000..e6b15c520 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_8.js @@ -0,0 +1,9 @@ +var searchData= +[ + ['identification_0',['Identification',['../structsf_1_1Joystick_1_1Identification.html',1,'sf::Joystick']]], + ['image_1',['Image',['../classsf_1_1Image.html',1,'sf']]], + ['info_2',['Info',['../structsf_1_1Font_1_1Info.html',1,'sf::Font::Info'],['../structsf_1_1SoundFileReader_1_1Info.html',1,'sf::SoundFileReader::Info']]], + ['inputsoundfile_3',['InputSoundFile',['../classsf_1_1InputSoundFile.html',1,'sf']]], + ['inputstream_4',['InputStream',['../classsf_1_1InputStream.html',1,'sf']]], + ['ipaddress_5',['IpAddress',['../classsf_1_1IpAddress.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_9.js b/Space-Invaders/sfml/doc/html/search/classes_9.js new file mode 100644 index 000000000..4a64015d3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_9.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['joystick_0',['Joystick',['../classsf_1_1Joystick.html',1,'sf']]], + ['joystickbuttonevent_1',['JoystickButtonEvent',['../structsf_1_1Event_1_1JoystickButtonEvent.html',1,'sf::Event']]], + ['joystickconnectevent_2',['JoystickConnectEvent',['../structsf_1_1Event_1_1JoystickConnectEvent.html',1,'sf::Event']]], + ['joystickmoveevent_3',['JoystickMoveEvent',['../structsf_1_1Event_1_1JoystickMoveEvent.html',1,'sf::Event']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_a.js b/Space-Invaders/sfml/doc/html/search/classes_a.js new file mode 100644 index 000000000..e6a380b10 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_a.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['keyboard_0',['Keyboard',['../classsf_1_1Keyboard.html',1,'sf']]], + ['keyevent_1',['KeyEvent',['../structsf_1_1Event_1_1KeyEvent.html',1,'sf::Event']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_b.js b/Space-Invaders/sfml/doc/html/search/classes_b.js new file mode 100644 index 000000000..5d5a01dd2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_b.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['listener_0',['Listener',['../classsf_1_1Listener.html',1,'sf']]], + ['listingresponse_1',['ListingResponse',['../classsf_1_1Ftp_1_1ListingResponse.html',1,'sf::Ftp']]], + ['lock_2',['Lock',['../classsf_1_1Lock.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_c.js b/Space-Invaders/sfml/doc/html/search/classes_c.js new file mode 100644 index 000000000..cb57e07a9 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_c.js @@ -0,0 +1,11 @@ +var searchData= +[ + ['memoryinputstream_0',['MemoryInputStream',['../classsf_1_1MemoryInputStream.html',1,'sf']]], + ['mouse_1',['Mouse',['../classsf_1_1Mouse.html',1,'sf']]], + ['mousebuttonevent_2',['MouseButtonEvent',['../structsf_1_1Event_1_1MouseButtonEvent.html',1,'sf::Event']]], + ['mousemoveevent_3',['MouseMoveEvent',['../structsf_1_1Event_1_1MouseMoveEvent.html',1,'sf::Event']]], + ['mousewheelevent_4',['MouseWheelEvent',['../structsf_1_1Event_1_1MouseWheelEvent.html',1,'sf::Event']]], + ['mousewheelscrollevent_5',['MouseWheelScrollEvent',['../structsf_1_1Event_1_1MouseWheelScrollEvent.html',1,'sf::Event']]], + ['music_6',['Music',['../classsf_1_1Music.html',1,'sf']]], + ['mutex_7',['Mutex',['../classsf_1_1Mutex.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_d.js b/Space-Invaders/sfml/doc/html/search/classes_d.js new file mode 100644 index 000000000..baaaaa4b0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_d.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['noncopyable_0',['NonCopyable',['../classsf_1_1NonCopyable.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_e.js b/Space-Invaders/sfml/doc/html/search/classes_e.js new file mode 100644 index 000000000..a396d70ea --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_e.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['outputsoundfile_0',['OutputSoundFile',['../classsf_1_1OutputSoundFile.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/classes_f.js b/Space-Invaders/sfml/doc/html/search/classes_f.js new file mode 100644 index 000000000..64dda625f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/classes_f.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['packet_0',['Packet',['../classsf_1_1Packet.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/close.svg b/Space-Invaders/sfml/doc/html/search/close.svg new file mode 100644 index 000000000..a933eea1a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/close.svg @@ -0,0 +1,31 @@ + + + + + + image/svg+xml + + + + + + + + diff --git a/Space-Invaders/sfml/doc/html/search/defines_0.js b/Space-Invaders/sfml/doc/html/search/defines_0.js new file mode 100644 index 000000000..3e1998d4a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/defines_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['sfml_5fdefine_5fdiscrete_5fgpu_5fpreference_0',['SFML_DEFINE_DISCRETE_GPU_PREFERENCE',['../GpuPreference_8hpp.html#ab0233c2d867cbd561036ed2440a4fec0',1,'GpuPreference.hpp']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_0.js b/Space-Invaders/sfml/doc/html/search/enums_0.js new file mode 100644 index 000000000..107375892 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_0.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['attribute_0',['Attribute',['../structsf_1_1ContextSettings.html#af2e91e57e8d26c40afe2ec8efaa32a2c',1,'sf::ContextSettings']]], + ['axis_1',['Axis',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7',1,'sf::Joystick']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_1.js b/Space-Invaders/sfml/doc/html/search/enums_1.js new file mode 100644 index 000000000..7998970d1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_1.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['button_0',['Button',['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90',1,'sf::Mouse']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_2.js b/Space-Invaders/sfml/doc/html/search/enums_2.js new file mode 100644 index 000000000..22ec444ec --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_2.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['coordinatetype_0',['CoordinateType',['../classsf_1_1Texture.html#aa6fd3bbe3c334b3c4428edfb2765a82e',1,'sf::Texture']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_3.js b/Space-Invaders/sfml/doc/html/search/enums_3.js new file mode 100644 index 000000000..3275c3723 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_3.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['equation_0',['Equation',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32',1,'sf::BlendMode']]], + ['eventtype_1',['EventType',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4a',1,'sf::Event']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_4.js b/Space-Invaders/sfml/doc/html/search/enums_4.js new file mode 100644 index 000000000..807e96cef --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_4.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['factor_0',['Factor',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbb',1,'sf::BlendMode']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_5.js b/Space-Invaders/sfml/doc/html/search/enums_5.js new file mode 100644 index 000000000..ca8e21115 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_5.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['key_0',['Key',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142',1,'sf::Keyboard']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_6.js b/Space-Invaders/sfml/doc/html/search/enums_6.js new file mode 100644 index 000000000..a98d21810 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_6.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['method_0',['Method',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598',1,'sf::Http::Request']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_7.js b/Space-Invaders/sfml/doc/html/search/enums_7.js new file mode 100644 index 000000000..37b0fb8fa --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_7.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['primitivetype_0',['PrimitiveType',['../group__graphics.html#ga5ee56ac1339984909610713096283b1b',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_8.js b/Space-Invaders/sfml/doc/html/search/enums_8.js new file mode 100644 index 000000000..18958d15d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_8.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['scancode_0',['Scancode',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875',1,'sf::Keyboard::Scan']]], + ['status_1',['Status',['../classsf_1_1SoundSource.html#ac43af72c98c077500b239bc75b812f03',1,'sf::SoundSource::Status()'],['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3b',1,'sf::Ftp::Response::Status()'],['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8',1,'sf::Http::Response::Status()'],['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dc',1,'sf::Socket::Status()']]], + ['style_2',['Style',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82',1,'sf::Text']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_9.js b/Space-Invaders/sfml/doc/html/search/enums_9.js new file mode 100644 index 000000000..51ace95ed --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_9.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['transfermode_0',['TransferMode',['../classsf_1_1Ftp.html#a1cd6b89ad23253f6d97e6d4ca4d558cb',1,'sf::Ftp']]], + ['type_1',['Type',['../classsf_1_1Shader.html#afaa1aa65e5de37b74d047da9def9f9b3',1,'sf::Shader::Type()'],['../classsf_1_1Socket.html#a5d3ff44e56e68f02816bb0fabc34adf8',1,'sf::Socket::Type()'],['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930a',1,'sf::Cursor::Type()'],['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84',1,'sf::Sensor::Type()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_a.js b/Space-Invaders/sfml/doc/html/search/enums_a.js new file mode 100644 index 000000000..aa5549481 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_a.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['usage_0',['Usage',['../classsf_1_1VertexBuffer.html#a3a531528684e63ecb45edd51282f5cb7',1,'sf::VertexBuffer']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enums_b.js b/Space-Invaders/sfml/doc/html/search/enums_b.js new file mode 100644 index 000000000..0c599c0d2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enums_b.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['wheel_0',['Wheel',['../classsf_1_1Mouse.html#a60dd479a43f26f200e7957aa11803ff4',1,'sf::Mouse']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_0.js b/Space-Invaders/sfml/doc/html/search/enumvalues_0.js new file mode 100644 index 000000000..a6536d044 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_0.js @@ -0,0 +1,14 @@ +var searchData= +[ + ['a_0',['A',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af835596d7ce007d5c34c356dee6740c6',1,'sf::Keyboard::Scan::A()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a9d06fa7ac9af597034ea724fb08b991e',1,'sf::Keyboard::A()']]], + ['accelerometer_1',['Accelerometer',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84a11bc58199593e217de23641755ecc867',1,'sf::Sensor']]], + ['accepted_2',['Accepted',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8ad328945457bd2f0d65107ba6b5ccd443',1,'sf::Http::Response']]], + ['add_3',['Add',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32a50c081d8f36cf7b77632966e15d38966',1,'sf::BlendMode::Add()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a158c586cbe8609031d1a7932e1a8dba2',1,'sf::Keyboard::Add()']]], + ['anyport_4',['AnyPort',['../classsf_1_1Socket.html#aa3e6c984bcb81a35234dcc9cc8369d75a5a3c30fd128895403afc11076f461b19',1,'sf::Socket']]], + ['apostrophe_5',['Apostrophe',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac391cefe75135833aea37c75293db820',1,'sf::Keyboard::Scan::Apostrophe()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a77b44e1f040360d71126fa1c4ad12bec',1,'sf::Keyboard::Apostrophe()']]], + ['application_6',['Application',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5a7f9d3ad8d2528dc7648b682b069211',1,'sf::Keyboard::Scan']]], + ['arrow_7',['Arrow',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa8d9a9cd284dabb4246ab4f147ba779a3',1,'sf::Cursor']]], + ['arrowwait_8',['ArrowWait',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa16c3acb967f2175434d6bbad7f1300bf',1,'sf::Cursor']]], + ['ascii_9',['Ascii',['../classsf_1_1Ftp.html#a1cd6b89ad23253f6d97e6d4ca4d558cbac9e544a22dce8ef3177449cb235d15c2',1,'sf::Ftp']]], + ['axiscount_10',['AxisCount',['../classsf_1_1Joystick.html#aee00dd432eacd8369d279b47c3ab4cc5accf3e487c9f6ee2f384351323626a42c',1,'sf::Joystick']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_1.js b/Space-Invaders/sfml/doc/html/search/enumvalues_1.js new file mode 100644 index 000000000..9e31b2114 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_1.js @@ -0,0 +1,15 @@ +var searchData= +[ + ['b_0',['B',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5a277726531303b8ba5212999e9664cb',1,'sf::Keyboard::Scan::B()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aca3142235e5c4199f0b8b45d8368ef94',1,'sf::Keyboard::B()']]], + ['back_1',['Back',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae5c30910d66a7706ec731fff17e552d2',1,'sf::Keyboard::Scan']]], + ['backslash_2',['Backslash',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a01ce415ff140d34d25a7bdbbbb785287',1,'sf::Keyboard::Scan::Backslash()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142adbd7d6f90a1009e91acf7bb1dc068512',1,'sf::Keyboard::Backslash()']]], + ['backslash_3',['BackSlash',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a536df84e73859aa44e11e192459470b6',1,'sf::Keyboard']]], + ['backspace_4',['BackSpace',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a33aeaab900abcd01eebf2fcc4f6d97e2',1,'sf::Keyboard']]], + ['backspace_5',['Backspace',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6621384ae8e5b8f0faf0b879c7813817',1,'sf::Keyboard::Scan::Backspace()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aa7c1581bac0f20164512572e6c60e98e',1,'sf::Keyboard::Backspace()']]], + ['badcommandsequence_6',['BadCommandSequence',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bad0c7ab07f01c1f7af16a1852650d7c47',1,'sf::Ftp::Response']]], + ['badgateway_7',['BadGateway',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8aad0cbad4cdaf448beb763e86bc1f747c',1,'sf::Http::Response']]], + ['badrequest_8',['BadRequest',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a3f88a714cf5483ee22f9051e5a3c080a',1,'sf::Http::Response']]], + ['binary_9',['Binary',['../classsf_1_1Ftp.html#a1cd6b89ad23253f6d97e6d4ca4d558cba6f253b362639fb5e059dc292762a21ee',1,'sf::Ftp']]], + ['bold_10',['Bold',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82af1b47f98fb1e10509ba930a596987171',1,'sf::Text']]], + ['buttoncount_11',['ButtonCount',['../classsf_1_1Joystick.html#aee00dd432eacd8369d279b47c3ab4cc5a2f1b8a0a59f2c12a4775c0e1e69e1816',1,'sf::Joystick::ButtonCount()'],['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90a52a1d434289774240ddaa22496762402',1,'sf::Mouse::ButtonCount()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_10.js b/Space-Invaders/sfml/doc/html/search/enumvalues_10.js new file mode 100644 index 000000000..f6152e237 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_10.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['q_0',['Q',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af9b34314661202a2f73c2d71d95fcfeb',1,'sf::Keyboard::Scan::Q()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a27e3d50587c9789d2592d275d22fbada',1,'sf::Keyboard::Q()']]], + ['quads_1',['Quads',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba5041359b76b4bd3d3e6ef738826b8743',1,'sf']]], + ['quote_2',['Quote',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af031edb6bcf319734a6664388958c475',1,'sf::Keyboard']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_11.js b/Space-Invaders/sfml/doc/html/search/enumvalues_11.js new file mode 100644 index 000000000..c380431ca --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_11.js @@ -0,0 +1,20 @@ +var searchData= +[ + ['r_0',['R',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7aeebbcdb0828850f4d69e6a084801fab8',1,'sf::Joystick::R()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af04c2611e3ee0855a044927d5bd0e194',1,'sf::Keyboard::Scan::R()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142add852cadaa6fff2d982bbab3551c31d0',1,'sf::Keyboard::R()']]], + ['ralt_1',['RAlt',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a2d6f466aef0f34d0d794d79362002ae3',1,'sf::Keyboard::Scan::RAlt()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a21dcf098233296462bc7c632b93369cc',1,'sf::Keyboard::RAlt()']]], + ['rangenotsatisfiable_2',['RangeNotSatisfiable',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a12533d00093b190e6d4c0076577e2239',1,'sf::Http::Response']]], + ['rbracket_3',['RBracket',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5b278a8f7b97c3972ec572412d855660',1,'sf::Keyboard::Scan::RBracket()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a578253a70b48e61830aa08292d44680f',1,'sf::Keyboard::RBracket()']]], + ['rcontrol_4',['RControl',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ab80b18e7c688d4cd1bbb52b40b9699fe',1,'sf::Keyboard::Scan::RControl()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a275d3fd207a9c0b22ce404012c71dc17',1,'sf::Keyboard::RControl()']]], + ['redo_5',['Redo',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad7b33839e3d1dc8048ed4e32297113ad',1,'sf::Keyboard::Scan']]], + ['refresh_6',['Refresh',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a21a543fae6b497b61df6e58d315f9e12',1,'sf::Keyboard::Scan']]], + ['regular_7',['Regular',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82a2af9ae5e1cda126570f744448e0caa32',1,'sf::Text']]], + ['resetcontent_8',['ResetContent',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a77327cc2a5e34cc64030b322e61d12a8',1,'sf::Http::Response']]], + ['resize_9',['Resize',['../group__window.html#gga97d7ee508bea4507ab40271518c732ffaccff967648ebcd5db2007eff7352b50f',1,'sf::Style']]], + ['resized_10',['Resized',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa67fd26d7e520bc6722db3ff47ef24941',1,'sf::Event']]], + ['restartmarkerreply_11',['RestartMarkerReply',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba07e06d3326ba2d078583bef93930d909',1,'sf::Ftp::Response']]], + ['return_12',['Return',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac291de81bdee518d636bc359f2ca77de',1,'sf::Keyboard']]], + ['reversesubtract_13',['ReverseSubtract',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32a2d04acf59e91811128e7d0ef076f65f0',1,'sf::BlendMode']]], + ['right_14',['Right',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a03d293668313031e7ff7eb9b7894e5c7',1,'sf::Keyboard::Scan::Right()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a2aeb083dea103a8e36b6850b51ef3632',1,'sf::Keyboard::Right()'],['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90af2cff24ab6c26daf079b11189f982fc4',1,'sf::Mouse::Right()']]], + ['rshift_15',['RShift',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a81b7e74173912d98493b62b13a7ed648',1,'sf::Keyboard::Scan::RShift()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a5be69e3b2f25bd5f4eed75d063f42b90',1,'sf::Keyboard::RShift()']]], + ['rsystem_16',['RSystem',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a62f3504c695ca7968e710cfdc1d8c61b',1,'sf::Keyboard::Scan::RSystem()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac1b3fd7424feeda242cedbb64f3f5a7f',1,'sf::Keyboard::RSystem()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_12.js b/Space-Invaders/sfml/doc/html/search/enumvalues_12.js new file mode 100644 index 000000000..0de5b3c54 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_12.js @@ -0,0 +1,40 @@ +var searchData= +[ + ['s_0',['S',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3c650be640718237a3241e8da1602dae',1,'sf::Keyboard::Scan::S()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aca13014bf9ed5887d347060a0334ea5a',1,'sf::Keyboard::S()']]], + ['scancodecount_1',['ScancodeCount',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a28c5ad8524e1e653b43440e660d441d0',1,'sf::Keyboard::Scan']]], + ['scrolllock_2',['ScrollLock',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875abbf3aeeb831834f97684647c1495d333',1,'sf::Keyboard::Scan']]], + ['search_3',['Search',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a1b0d59ec95a4d6b585cdc7f0756ff6f0',1,'sf::Keyboard::Scan']]], + ['select_4',['Select',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a30a8160d16b2ee9cc2d56a1a3394efa1',1,'sf::Keyboard::Scan']]], + ['semicolon_5',['SemiColon',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a460ab09a36f9ed230504b89b9815de88',1,'sf::Keyboard']]], + ['semicolon_6',['Semicolon',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a60e05ed7eb42bf7d283d7ea4aafeef90',1,'sf::Keyboard::Scan::Semicolon()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab50635b9c913837d1bd4453eec7cb506',1,'sf::Keyboard::Semicolon()']]], + ['sensorchanged_7',['SensorChanged',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aaadf9a44c788eb9467a83c074fbf12613',1,'sf::Event']]], + ['servicenotavailable_8',['ServiceNotAvailable',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8ac4fffba9d5ad4c14171a1bbe4f6adf87',1,'sf::Http::Response']]], + ['serviceready_9',['ServiceReady',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baea2ee2007d7843c21108bb686ef03757',1,'sf::Ftp::Response']]], + ['servicereadysoon_10',['ServiceReadySoon',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba22413357ade6b586f6ceb0d704f35075',1,'sf::Ftp::Response']]], + ['serviceunavailable_11',['ServiceUnavailable',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba43022ddf49b68a4f5aff0bea7e09e89f',1,'sf::Ftp::Response']]], + ['sizeall_12',['SizeAll',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa256a64be04f0347e6a44cbf84e5410bd',1,'sf::Cursor']]], + ['sizebottom_13',['SizeBottom',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aaafd57cfee8747f202db04a549057e185',1,'sf::Cursor']]], + ['sizebottomleft_14',['SizeBottomLeft',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa62fb130f4aa6ecf39c8366e0de549cc2',1,'sf::Cursor']]], + ['sizebottomlefttopright_15',['SizeBottomLeftTopRight',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aac047cea5795b6074fbb4d6479452e8ef',1,'sf::Cursor']]], + ['sizebottomright_16',['SizeBottomRight',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa581edf98abd0b4905329b516a45eeef8',1,'sf::Cursor']]], + ['sizehorizontal_17',['SizeHorizontal',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa0131508eaa8802dba34b8c9b41aec6e9',1,'sf::Cursor']]], + ['sizeleft_18',['SizeLeft',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa4725e9d5f8117997732f8dcccce45be4',1,'sf::Cursor']]], + ['sizeright_19',['SizeRight',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aaebc3670bd27360a7de429daa07921a4d',1,'sf::Cursor']]], + ['sizetop_20',['SizeTop',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa605e36bf335a0d801b4e7d67995a9e85',1,'sf::Cursor']]], + ['sizetopleft_21',['SizeTopLeft',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa2cc42c06dd701af7211f351333b629ca',1,'sf::Cursor']]], + ['sizetopleftbottomright_22',['SizeTopLeftBottomRight',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa934ddc380262a94358ccb5a4ab7bbe1c',1,'sf::Cursor']]], + ['sizetopright_23',['SizeTopRight',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa84d9478fdeef2f727f06f3fe5bdb1be6',1,'sf::Cursor']]], + ['sizevertical_24',['SizeVertical',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aab3cefa56d3a0fe9fe64680c7ec11eab5',1,'sf::Cursor']]], + ['slash_25',['Slash',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5c37f9adf66e083d85950db1597c45f5',1,'sf::Keyboard::Scan::Slash()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a7424bf901434a587a6c202c423e6786c',1,'sf::Keyboard::Slash()']]], + ['space_26',['Space',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a37fceb15fd79c29859aeb30e4b34237d',1,'sf::Keyboard::Scan::Space()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a6fdaa93b6b8d1a2b73bc239e9ada94ef',1,'sf::Keyboard::Space()']]], + ['srcalpha_27',['SrcAlpha',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbaac0ae68df2930b4d616c3e7abeec7d41',1,'sf::BlendMode']]], + ['srccolor_28',['SrcColor',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbad679bb0ecaf15c188d7f2e1fab572188',1,'sf::BlendMode']]], + ['static_29',['Static',['../classsf_1_1VertexBuffer.html#a3a531528684e63ecb45edd51282f5cb7a041ab564f6cd1b6775bd0ebff06b6d7e',1,'sf::VertexBuffer']]], + ['stop_30',['Stop',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a03a70c06d505acb1473f68a63c712faa',1,'sf::Keyboard::Scan']]], + ['stopped_31',['Stopped',['../classsf_1_1SoundSource.html#ac43af72c98c077500b239bc75b812f03adabb01e8aa85b2f54b344890addf764a',1,'sf::SoundSource']]], + ['stream_32',['Stream',['../classsf_1_1VertexBuffer.html#a3a531528684e63ecb45edd51282f5cb7aeed06a391698772af58a9cfdff77deaf',1,'sf::VertexBuffer']]], + ['strikethrough_33',['StrikeThrough',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82a9ed1f5bb154c21269e1190c5aa97d479',1,'sf::Text']]], + ['subtract_34',['Subtract',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32a14c825be24f8412fc5ed5b49f19bc0d0',1,'sf::BlendMode::Subtract()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a68983f67bd30d27b27c90d6794c78aa2',1,'sf::Keyboard::Subtract()']]], + ['systemstatus_35',['SystemStatus',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba9bdd02ae119b8be639e778859ee74060',1,'sf::Ftp::Response']]], + ['systemtype_36',['SystemType',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba78391f73aa11f07f1514c7d070b93c08',1,'sf::Ftp::Response']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_13.js b/Space-Invaders/sfml/doc/html/search/enumvalues_13.js new file mode 100644 index 000000000..371acfaf8 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_13.js @@ -0,0 +1,19 @@ +var searchData= +[ + ['t_0',['T',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a55bee4759c12cb033659e8d8de796ae9',1,'sf::Keyboard::Scan::T()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a19f59109111fc5271d3581bcd0c43187',1,'sf::Keyboard::T()']]], + ['tab_1',['Tab',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa724a5e6b812f12b06957717fd78d4a3',1,'sf::Keyboard::Scan::Tab()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a20c552c39c8356b1078f1cfff7936b4a',1,'sf::Keyboard::Tab()']]], + ['tcp_2',['Tcp',['../classsf_1_1Socket.html#a5d3ff44e56e68f02816bb0fabc34adf8acc02e97e90234b957eaad4dff7f22214',1,'sf::Socket']]], + ['text_3',['Text',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aa1a9979392de58ff11d5b4ab330e6393d',1,'sf::Cursor']]], + ['textentered_4',['TextEntered',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa7e09871dc984080ff528e4f7e073e874',1,'sf::Event']]], + ['tilde_5',['Tilde',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a90be0882086bccb516e3afc5c7fb82eb',1,'sf::Keyboard']]], + ['titlebar_6',['Titlebar',['../group__window.html#gga97d7ee508bea4507ab40271518c732ffab4c8b32b05ed715928513787cb1e85b6',1,'sf::Style']]], + ['touchbegan_7',['TouchBegan',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aae6f8231ad6013d063929a09b6c28f515',1,'sf::Event']]], + ['touchended_8',['TouchEnded',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aabc7123492dbca320da5c03fea1a141e5',1,'sf::Event']]], + ['touchmoved_9',['TouchMoved',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa9524b7d7665212c6d56f623b5b8311a9',1,'sf::Event']]], + ['transferaborted_10',['TransferAborted',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba7cfefcc586c12ba70f752353fde7126e',1,'sf::Ftp::Response']]], + ['trianglefan_11',['TriangleFan',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba363f7762b33706c805c6a451ad554f5e',1,'sf']]], + ['triangles_12',['Triangles',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba880a7aa72c20b9f9beb7eb64d2434670',1,'sf']]], + ['trianglesfan_13',['TrianglesFan',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba5338a2c6d922151fe50f235036af8a20',1,'sf']]], + ['trianglesstrip_14',['TrianglesStrip',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba66643dbbb24bbacb405973ed80eebae0',1,'sf']]], + ['trianglestrip_15',['TriangleStrip',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba05e55fec6d32c2fc8328f94d07f91184',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_14.js b/Space-Invaders/sfml/doc/html/search/enumvalues_14.js new file mode 100644 index 000000000..4279a2d76 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_14.js @@ -0,0 +1,11 @@ +var searchData= +[ + ['u_0',['U',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a0a901f61e75292dd2f642b6e4f33a214',1,'sf::Joystick::U()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aeaecd56929398797033710d1cb274003',1,'sf::Keyboard::Scan::U()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab4f30ae34848ee934dd4f5496a8fb4a1',1,'sf::Keyboard::U()']]], + ['udp_1',['Udp',['../classsf_1_1Socket.html#a5d3ff44e56e68f02816bb0fabc34adf8a6ebf3094830db4820191a327f3cc6ce2',1,'sf::Socket']]], + ['unauthorized_2',['Unauthorized',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8ab7a79b7bff50fb1902c19eecbb4e2a2d',1,'sf::Http::Response']]], + ['underlined_3',['Underlined',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82a664bd143f92b6e8c709d7f788e8b20df',1,'sf::Text']]], + ['undo_4',['Undo',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac7476165cf08ca489e6949441d4e0715',1,'sf::Keyboard::Scan']]], + ['unknown_5',['Unknown',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af29c5f0133653ccd3cbc947b51e97895',1,'sf::Keyboard::Scan::Unknown()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a840c43fa8e05ff854f6fe9a86c7c939e',1,'sf::Keyboard::Unknown()']]], + ['up_6',['Up',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6b3aa7f474aba344035fb34c037cdc05',1,'sf::Keyboard::Scan::Up()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac4cf6ef2d2632445e9e26c8f2b70e82d',1,'sf::Keyboard::Up()']]], + ['useracceleration_7',['UserAcceleration',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84ad3a399e0025892b7c53e8767cebb9215',1,'sf::Sensor']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_15.js b/Space-Invaders/sfml/doc/html/search/enumvalues_15.js new file mode 100644 index 000000000..13ed78dd0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_15.js @@ -0,0 +1,10 @@ +var searchData= +[ + ['v_0',['V',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7aa2e2c8ffa1837e7911ee0c7d045bf8f4',1,'sf::Joystick::V()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875acf235c9f74c25df943ead5f38a01945a',1,'sf::Keyboard::Scan::V()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aec9074abd2d41628d1ecdc14e1b2cd96',1,'sf::Keyboard::V()']]], + ['versionnotsupported_1',['VersionNotSupported',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8aeb32a1a087d5fcf1a42663eb40c3c305',1,'sf::Http::Response']]], + ['vertex_2',['Vertex',['../classsf_1_1Shader.html#afaa1aa65e5de37b74d047da9def9f9b3a8718008f827eb32e29bbdd1791c62dce',1,'sf::Shader']]], + ['verticalwheel_3',['VerticalWheel',['../classsf_1_1Mouse.html#a60dd479a43f26f200e7957aa11803ff4abd571de908d2b2c4b9f165f29c678496',1,'sf::Mouse']]], + ['volumedown_4',['VolumeDown',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa32039062878ff1d9ed8fb062949f976',1,'sf::Keyboard::Scan']]], + ['volumemute_5',['VolumeMute',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3af7a1640f764386171d4cba53e6d5e2',1,'sf::Keyboard::Scan']]], + ['volumeup_6',['VolumeUp',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa76641e5826ca3a7fb09cefa4d922270',1,'sf::Keyboard::Scan']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_16.js b/Space-Invaders/sfml/doc/html/search/enumvalues_16.js new file mode 100644 index 000000000..dab62d444 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_16.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['w_0',['W',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a287b960abc4c422a8f4c1bbfc0dfd2a9',1,'sf::Keyboard::Scan::W()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a258aa89e9c6c9aad1ccbaeb41839c5e0',1,'sf::Keyboard::W()']]], + ['wait_1',['Wait',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aabeb51ea58e48e4477ab802d46ad2cbdd',1,'sf::Cursor']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_17.js b/Space-Invaders/sfml/doc/html/search/enumvalues_17.js new file mode 100644 index 000000000..9b5f81820 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_17.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['x_0',['X',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a95dc8b9bf7b0a2157fc67891c54c401e',1,'sf::Joystick::X()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af4f6ad0b93dd6bc360badd5abe812a67',1,'sf::Keyboard::Scan::X()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a012f5ee9d518e9e24caa087fbddc0594',1,'sf::Keyboard::X()']]], + ['xbutton1_1',['XButton1',['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90aecc7f3ce9ad6a60b9b0027876446b8d7',1,'sf::Mouse']]], + ['xbutton2_2',['XButton2',['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90a03fa056fd0dd9d629c205d91a8ef1b5a',1,'sf::Mouse']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_18.js b/Space-Invaders/sfml/doc/html/search/enumvalues_18.js new file mode 100644 index 000000000..ed781712c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_18.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['y_0',['Y',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a51ef1455f7511ad4a78ba241d66593ce',1,'sf::Joystick::Y()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6305407064e0beb4f0499166e087ff22',1,'sf::Keyboard::Scan::Y()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a5d877e63d1353e0fc0a0757a87a7bd0e',1,'sf::Keyboard::Y()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_19.js b/Space-Invaders/sfml/doc/html/search/enumvalues_19.js new file mode 100644 index 000000000..95870b39f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_19.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['z_0',['Z',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a7c37a1240b2dafbbfc5c1a0e23911315',1,'sf::Joystick::Z()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a2aca2d41fc86e4e31be7220d81ce589a',1,'sf::Keyboard::Scan::Z()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a4e12efd6478a2d174264f29b0b41ab43',1,'sf::Keyboard::Z()']]], + ['zero_1',['Zero',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbafda2d66c3c3da15cd3b42338fbf6d2ba',1,'sf::BlendMode']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_2.js b/Space-Invaders/sfml/doc/html/search/enumvalues_2.js new file mode 100644 index 000000000..ebedc81c0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_2.js @@ -0,0 +1,20 @@ +var searchData= +[ + ['c_0',['C',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad3acc09d4a2dc958837e48b80af01a4c',1,'sf::Keyboard::Scan::C()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a0d586c4ec0cd6b537cb6f49180fedecc',1,'sf::Keyboard::C()']]], + ['capslock_1',['CapsLock',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6a1c1f6a4dfac0c5170296a88da1dd57',1,'sf::Keyboard::Scan']]], + ['close_2',['Close',['../group__window.html#gga97d7ee508bea4507ab40271518c732ffae07a7d411d5acf28f4a9a4b76a3a9493',1,'sf::Style']]], + ['closed_3',['Closed',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa316e4212e083f1dce79efd8d9e9c0a95',1,'sf::Event']]], + ['closingconnection_4',['ClosingConnection',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bab23931490fc2d1df3081d651fe0f4d6e',1,'sf::Ftp::Response']]], + ['closingdataconnection_5',['ClosingDataConnection',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bac723ebc8a38913bbf0d9504556cbaaa6',1,'sf::Ftp::Response']]], + ['comma_6',['Comma',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a035f3ce4c48fecfd7d2c77987710e5fa',1,'sf::Keyboard::Scan::Comma()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab7374f48cc79e3085739160b8e3ef2f9',1,'sf::Keyboard::Comma()']]], + ['commandnotimplemented_7',['CommandNotImplemented',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba2ca4834c756c81b924ebed696fcba0a8',1,'sf::Ftp::Response']]], + ['commandunknown_8',['CommandUnknown',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba75bdf0b6844fa9c07b3c25647d22c269',1,'sf::Ftp::Response']]], + ['connectionclosed_9',['ConnectionClosed',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bad1e5dcf298ce30c528261435f1a2eb53',1,'sf::Ftp::Response']]], + ['connectionfailed_10',['ConnectionFailed',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba51aa367cc1e85a45ea3c7be48730e990',1,'sf::Ftp::Response::ConnectionFailed()'],['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a7f307376f13bdc06b24fc274ecd2aa60',1,'sf::Http::Response::ConnectionFailed()']]], + ['copy_11',['Copy',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a7ecdffb69ce6c849414e4a818d3103a7',1,'sf::Keyboard::Scan']]], + ['core_12',['Core',['../structsf_1_1ContextSettings.html#af2e91e57e8d26c40afe2ec8efaa32a2cacb581130734cbd87cbbc9438429f4a8b',1,'sf::ContextSettings']]], + ['count_13',['Count',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aae51749211243cab2ab270b29cdc32a70',1,'sf::Event::Count()'],['../classsf_1_1Joystick.html#aee00dd432eacd8369d279b47c3ab4cc5a6e0a2a95bc1da277610c04d80f52715e',1,'sf::Joystick::Count()'],['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84afcb4a80eb9e3f927c5837207a1b9eb29',1,'sf::Sensor::Count()']]], + ['created_14',['Created',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a0a6e8bafa9365a0ed10b8a9cbfd0649b',1,'sf::Http::Response']]], + ['cross_15',['Cross',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aaf3b3213aad68863c7dec96587681fecd',1,'sf::Cursor']]], + ['cut_16',['Cut',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af5b15a621ad19b8f357821f7adfc6bb1',1,'sf::Keyboard::Scan']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_3.js b/Space-Invaders/sfml/doc/html/search/enumvalues_3.js new file mode 100644 index 000000000..fa6196678 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_3.js @@ -0,0 +1,20 @@ +var searchData= +[ + ['d_0',['D',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a96ec4a613d00dce6f8d90adc8728864a',1,'sf::Keyboard::Scan::D()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ae778600bd3e878b59df1dbdd5877ba7a',1,'sf::Keyboard::D()']]], + ['dash_1',['Dash',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a401a183dcfde0a06cb60fe6c91fa1e39',1,'sf::Keyboard']]], + ['dataconnectionalreadyopened_2',['DataConnectionAlreadyOpened',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bafa52d19bc813d69055f4cc390d4a76ca',1,'sf::Ftp::Response']]], + ['dataconnectionopened_3',['DataConnectionOpened',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3badc78ed87d5bddb174fa3c16707ac2f2d',1,'sf::Ftp::Response']]], + ['dataconnectionunavailable_4',['DataConnectionUnavailable',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba757b89ff1f236941f7759b0ed0c28b88',1,'sf::Ftp::Response']]], + ['debug_5',['Debug',['../structsf_1_1ContextSettings.html#af2e91e57e8d26c40afe2ec8efaa32a2ca6043f67afb3d48918d5336474eabaafc',1,'sf::ContextSettings']]], + ['default_6',['Default',['../structsf_1_1ContextSettings.html#af2e91e57e8d26c40afe2ec8efaa32a2cabf868dcb751b909bf031484ed42a93bb',1,'sf::ContextSettings::Default()'],['../group__window.html#gga97d7ee508bea4507ab40271518c732ffa5597cd420fc461807e4a201c92adea37',1,'sf::Style::Default()']]], + ['delete_7',['Delete',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598abc9555b94c1b896185015ec3990999f9',1,'sf::Http::Request::Delete()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a2f071cf261d91b0facc044c2ba11ae94',1,'sf::Keyboard::Scan::Delete()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab66187002fc7f6695ef3d05237b93a38',1,'sf::Keyboard::Delete()']]], + ['directoryok_8',['DirectoryOk',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba06d26e95a170fc422af13def415e0437',1,'sf::Ftp::Response']]], + ['directorystatus_9',['DirectoryStatus',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba8729460a695013cc96330e2fced0ae1f',1,'sf::Ftp::Response']]], + ['disconnected_10',['Disconnected',['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dcab215141f756acdc23c67fad149710eb1',1,'sf::Socket']]], + ['divide_11',['Divide',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142afae3dc28752954f0bfe298ac52f58cb6',1,'sf::Keyboard']]], + ['done_12',['Done',['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dca1de3a85bc56d3ae85b3d0f3cfd04ae90',1,'sf::Socket']]], + ['down_13',['Down',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a18774f082756cdee120731cd53689008',1,'sf::Keyboard::Scan::Down()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a33dd676edbdf0817d7a65b21df3d0dca',1,'sf::Keyboard::Down()']]], + ['dstalpha_14',['DstAlpha',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbba5e3dc9a6f117aaa5f7433e1f4662a5f7',1,'sf::BlendMode']]], + ['dstcolor_15',['DstColor',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbba3d85281c3eab7153f2bd9faae3e7523a',1,'sf::BlendMode']]], + ['dynamic_16',['Dynamic',['../classsf_1_1VertexBuffer.html#a3a531528684e63ecb45edd51282f5cb7a13365282a5933ecd9cc6a3ef39ba58f7',1,'sf::VertexBuffer']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_4.js b/Space-Invaders/sfml/doc/html/search/enumvalues_4.js new file mode 100644 index 000000000..bf8ee5143 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_4.js @@ -0,0 +1,12 @@ +var searchData= +[ + ['e_0',['E',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adc59d37687890a0efbac55992448e41f',1,'sf::Keyboard::Scan::E()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a0e027c08438a8bf77e2e1e5d5d75bd84',1,'sf::Keyboard::E()']]], + ['ebcdic_1',['Ebcdic',['../classsf_1_1Ftp.html#a1cd6b89ad23253f6d97e6d4ca4d558cbabb1e34435231e73c96534c71090be7f4',1,'sf::Ftp']]], + ['end_2',['End',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a60da82f685e98127043da8ffd04b7442',1,'sf::Keyboard::Scan::End()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a4478343b2b7efc310f995fd4251a264d',1,'sf::Keyboard::End()']]], + ['enter_3',['Enter',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adb4984ca4b4e90eae95e32bb0de29c8e',1,'sf::Keyboard::Scan::Enter()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a59e26db0965305492875d7da68f6a990',1,'sf::Keyboard::Enter()']]], + ['enteringpassivemode_4',['EnteringPassiveMode',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba48314fc47a72ad0aacdea93b91756f6e',1,'sf::Ftp::Response']]], + ['equal_5',['Equal',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6cd11681bbd83c0565c9c63e4d512a86',1,'sf::Keyboard::Scan::Equal()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ae55c35f6b6417e1dbbfa351c64dfc743',1,'sf::Keyboard::Equal()']]], + ['error_6',['Error',['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dca1dc9854433a28c22e192721179a2df5d',1,'sf::Socket']]], + ['escape_7',['Escape',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac8409d6faf55c88bc01c722c51e99b93',1,'sf::Keyboard::Scan::Escape()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a64b7ecb543c5d03bec8383dde123c95d',1,'sf::Keyboard::Escape()']]], + ['execute_8',['Execute',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a12c94b4dc55153a952283aff554ae3a0',1,'sf::Keyboard::Scan']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_5.js b/Space-Invaders/sfml/doc/html/search/enumvalues_5.js new file mode 100644 index 000000000..cff9bc0bc --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_5.js @@ -0,0 +1,38 @@ +var searchData= +[ + ['f_0',['F',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a2d87edd4fa1f6ae355cabcccb5844ea3',1,'sf::Keyboard::Scan::F()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab8021fbbe5483bc98f124df6f7090002',1,'sf::Keyboard::F()']]], + ['f1_1',['F1',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a60bdd99ca0d0ab177a65078a185333a6',1,'sf::Keyboard::Scan::F1()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ae59c7e28858e970c9d4f0e418179b632',1,'sf::Keyboard::F1()']]], + ['f10_2',['F10',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aee4c9257be218585114cf27602892572',1,'sf::Keyboard::Scan::F10()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aec695ecf296e7084a8f7f3ec408e16ac',1,'sf::Keyboard::F10()']]], + ['f11_3',['F11',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5047f3be2633e101840945b58867be6e',1,'sf::Keyboard::Scan::F11()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af9a8de90d90a7a7582269bc5c41f5afd',1,'sf::Keyboard::F11()']]], + ['f12_4',['F12',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa068df80ff6d72b0bdab149e3a3d26af',1,'sf::Keyboard::Scan::F12()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af9d8807117d946de5e403bcbd4d7161d',1,'sf::Keyboard::F12()']]], + ['f13_5',['F13',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af3416f863ce92ae05b26aed80e72a52f',1,'sf::Keyboard::Scan::F13()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a9e28e971941ca2900c1eea17cda50a04',1,'sf::Keyboard::F13()']]], + ['f14_6',['F14',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a8589f17d8b4170b7f51711c1d6611f21',1,'sf::Keyboard::Scan::F14()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a9a0327a4ef876338d5f3c34c514f190c',1,'sf::Keyboard::F14()']]], + ['f15_7',['F15',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875acad0fde63b2171cc56d42a1d23d679ba',1,'sf::Keyboard::Scan::F15()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a8949ce79077cc8bf64f4fa42bb6a2808',1,'sf::Keyboard::F15()']]], + ['f16_8',['F16',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a1c3d4ce6fc1826f1da081b942676cccd',1,'sf::Keyboard::Scan']]], + ['f17_9',['F17',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa416a15ec21b4957d740992f446a5224',1,'sf::Keyboard::Scan']]], + ['f18_10',['F18',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae50807a7d06cc5324eac783bf4d0b96d',1,'sf::Keyboard::Scan']]], + ['f19_11',['F19',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a51ff7425b98bbcd8e777908de15f3d10',1,'sf::Keyboard::Scan']]], + ['f2_12',['F2',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3ea5468548feaccb419a8c4c160c16b0',1,'sf::Keyboard::Scan::F2()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a6a2faa5f876a1e75f24a596b658ff413',1,'sf::Keyboard::F2()']]], + ['f20_13',['F20',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a06d01cd179c76fe33c2f61006176f076',1,'sf::Keyboard::Scan']]], + ['f21_14',['F21',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad86a6e71ba08ffc8167d003b92cadb77',1,'sf::Keyboard::Scan']]], + ['f22_15',['F22',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a538c92aa44eae29b23ef3c096c1b571b',1,'sf::Keyboard::Scan']]], + ['f23_16',['F23',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac66a8fea90d7307b434b4a09b0822202',1,'sf::Keyboard::Scan']]], + ['f24_17',['F24',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a069f7f10bbdb13aeea8cfdebee4752f4',1,'sf::Keyboard::Scan']]], + ['f3_18',['F3',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af2e1be02540c0794302ec9e1d2262ef4',1,'sf::Keyboard::Scan::F3()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a1fb58d66f9c0183db3e70b2b0576074e',1,'sf::Keyboard::F3()']]], + ['f4_19',['F4',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae4a9bcd1df4becc4994c676f44a5a101',1,'sf::Keyboard::Scan::F4()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a71311e21238cf2c0df1bbf096bba68f2',1,'sf::Keyboard::F4()']]], + ['f5_20',['F5',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a4fe3daf6c23906249b87f0ffffb458be',1,'sf::Keyboard::Scan::F5()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a01fd2f93eddf2887186ea91180a789a8',1,'sf::Keyboard::F5()']]], + ['f6_21',['F6',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3c3934e6efc54b366de1e27f5099276e',1,'sf::Keyboard::Scan::F6()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac756a19b31eb28cd2c35c29d8e54ea04',1,'sf::Keyboard::F6()']]], + ['f7_22',['F7',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5dc33031068713ce55bb332672d9bb9a',1,'sf::Keyboard::Scan::F7()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a060d30d36a3e08208b2bc46d0f549b6c',1,'sf::Keyboard::F7()']]], + ['f8_23',['F8',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae1faf360e99035dff729917bee051daa',1,'sf::Keyboard::Scan::F8()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ade468cd27716b9c2a0d0158afa2f8621',1,'sf::Keyboard::F8()']]], + ['f9_24',['F9',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae0cb68ca4ec3844548d4e089ec9ea8c5',1,'sf::Keyboard::Scan::F9()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a3c5c2342003a7191de6636b5ef44e1b9',1,'sf::Keyboard::F9()']]], + ['favorites_25',['Favorites',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad54aa9735cb59fe6fbd9a54939dadb53',1,'sf::Keyboard::Scan']]], + ['fileactionaborted_26',['FileActionAborted',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baf822d1b0abf3e9ae7dd44684549d512d',1,'sf::Ftp::Response']]], + ['fileactionok_27',['FileActionOk',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baf988b69b0a5f55f8122da5ba001932e0',1,'sf::Ftp::Response']]], + ['filenamenotallowed_28',['FilenameNotAllowed',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba03254aba823298179a98056e15568c5b',1,'sf::Ftp::Response']]], + ['filestatus_29',['FileStatus',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baebddfc7997dca289c83068dff3f47dce',1,'sf::Ftp::Response']]], + ['fileunavailable_30',['FileUnavailable',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba3f8f931e499936fde6b750d81f5ecfef',1,'sf::Ftp::Response']]], + ['forbidden_31',['Forbidden',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a64492842e823ebe12a85539b6b454986',1,'sf::Http::Response']]], + ['forward_32',['Forward',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adb5993c42ae3794c0e755f8e4b4666ea',1,'sf::Keyboard::Scan']]], + ['fragment_33',['Fragment',['../classsf_1_1Shader.html#afaa1aa65e5de37b74d047da9def9f9b3ace6e88eec3a56b2e55ee3c8e64e9b89a',1,'sf::Shader']]], + ['fullscreen_34',['Fullscreen',['../group__window.html#gga97d7ee508bea4507ab40271518c732ffa6288ec86830245cf957e2d234f79f50d',1,'sf::Style']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_6.js b/Space-Invaders/sfml/doc/html/search/enumvalues_6.js new file mode 100644 index 000000000..1cf42940b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_6.js @@ -0,0 +1,11 @@ +var searchData= +[ + ['g_0',['G',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a21dc36f8ac9ff44d3c6aca6a66503264',1,'sf::Keyboard::Scan::G()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aafb9e3d7679d88d86afc608d79c251f7',1,'sf::Keyboard::G()']]], + ['gainedfocus_1',['GainedFocus',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa8c5003ced508499933d540df8a6023ec',1,'sf::Event']]], + ['gatewaytimeout_2',['GatewayTimeout',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a215935d823ab44694709a184a71353b0',1,'sf::Http::Response']]], + ['geometry_3',['Geometry',['../classsf_1_1Shader.html#afaa1aa65e5de37b74d047da9def9f9b3a812421100fd57456727375938fb62788',1,'sf::Shader']]], + ['get_4',['Get',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598ab822baed393f3d0353621e5378b9fcb4',1,'sf::Http::Request']]], + ['grave_5',['Grave',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a813711cd9de71dab611b7155b36880f5',1,'sf::Keyboard::Scan::Grave()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a2da2429e6db8efbf923151f00a9b21e0',1,'sf::Keyboard::Grave()']]], + ['gravity_6',['Gravity',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84afab4d098cc64e791a0c4a9ef6b32db92',1,'sf::Sensor']]], + ['gyroscope_7',['Gyroscope',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84a1c43984aacd29b1fda5356883fb19656',1,'sf::Sensor']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_7.js b/Space-Invaders/sfml/doc/html/search/enumvalues_7.js new file mode 100644 index 000000000..29085395c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_7.js @@ -0,0 +1,12 @@ +var searchData= +[ + ['h_0',['H',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a40615dc67be807478f924c9aabf81915',1,'sf::Keyboard::Scan::H()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142adfa19328304890e17f4a3f4263eed04d',1,'sf::Keyboard::H()']]], + ['hand_1',['Hand',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aae826935374aa0414723918ba79f13368',1,'sf::Cursor']]], + ['head_2',['Head',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598a4df23138be7ed60f47aba6548ba65e7b',1,'sf::Http::Request']]], + ['help_3',['Help',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aaf2c0ed3674b334ebf8365aee243186f5',1,'sf::Cursor::Help()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a4e8eeeae3acd3740053d2041e22dbf95',1,'sf::Keyboard::Scan::Help()']]], + ['helpmessage_4',['HelpMessage',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba840fd2a1872fd4310b046541f57fdeb7',1,'sf::Ftp::Response']]], + ['home_5',['Home',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae5d4c031080001f1449e3d55e8571e3a',1,'sf::Keyboard::Scan::Home()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af41ae7c3927cc5ea8b43ee2fefe890e8',1,'sf::Keyboard::Home()']]], + ['homepage_6',['HomePage',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a97afbc93fdb29797ed0fbfe45b93b80d',1,'sf::Keyboard::Scan']]], + ['horizontalwheel_7',['HorizontalWheel',['../classsf_1_1Mouse.html#a60dd479a43f26f200e7957aa11803ff4a785768d5e33c77de9fdcfdd02219f4e2',1,'sf::Mouse']]], + ['hyphen_8',['Hyphen',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae6888d3715971e533b4379452cbae94a',1,'sf::Keyboard::Scan::Hyphen()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a5bde2cf47e6182e6f45d0d2197223c35',1,'sf::Keyboard::Hyphen()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_8.js b/Space-Invaders/sfml/doc/html/search/enumvalues_8.js new file mode 100644 index 000000000..6234e2202 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_8.js @@ -0,0 +1,10 @@ +var searchData= +[ + ['i_0',['I',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875acfe0506f6ce3d306b47134e99260d984',1,'sf::Keyboard::Scan::I()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142abaef09665b4d94ebbed50345cab3981e',1,'sf::Keyboard::I()']]], + ['insert_1',['Insert',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a8935170f7f2ea9ea6586c3c686edc72a',1,'sf::Keyboard::Scan::Insert()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a616c8cae362d229155c5c6e10b969943',1,'sf::Keyboard::Insert()']]], + ['insufficientstoragespace_2',['InsufficientStorageSpace',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba5d9f3666222c808553c27e4e099c7c6d',1,'sf::Ftp::Response']]], + ['internalservererror_3',['InternalServerError',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8adae2b2a936414349d55b4ed8c583fed1',1,'sf::Http::Response']]], + ['invalidfile_4',['InvalidFile',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baed2c74a9f335dee1463ca1a4f41c6478',1,'sf::Ftp::Response']]], + ['invalidresponse_5',['InvalidResponse',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba59e041e4ef186e8ae8d6035973fc46bd',1,'sf::Ftp::Response::InvalidResponse()'],['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a0af0090420e60bf54da4860749345c95',1,'sf::Http::Response::InvalidResponse()']]], + ['italic_6',['Italic',['../classsf_1_1Text.html#aa8add4aef484c6e6b20faff07452bd82aee249eb803848723c542c2062ebe69d8',1,'sf::Text']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_9.js b/Space-Invaders/sfml/doc/html/search/enumvalues_9.js new file mode 100644 index 000000000..5deddd6c2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_9.js @@ -0,0 +1,9 @@ +var searchData= +[ + ['j_0',['J',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aaf9b207522e37466a19f92b8dc836735',1,'sf::Keyboard::Scan::J()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a948c634009beacdab42c3419253a5e85',1,'sf::Keyboard::J()']]], + ['joystickbuttonpressed_1',['JoystickButtonPressed',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa6d46855f0253f065689b69cd09437222',1,'sf::Event']]], + ['joystickbuttonreleased_2',['JoystickButtonReleased',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa2246ef5ee33f7fa4b2a53f042ceeac3d',1,'sf::Event']]], + ['joystickconnected_3',['JoystickConnected',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aaabb8877ec2f0c92904170deded09321e',1,'sf::Event']]], + ['joystickdisconnected_4',['JoystickDisconnected',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aab6e161dab7abaf154cc1c7b554558cb6',1,'sf::Event']]], + ['joystickmoved_5',['JoystickMoved',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa4d6ad228485c135967831be16ec074dd',1,'sf::Event']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_a.js b/Space-Invaders/sfml/doc/html/search/enumvalues_a.js new file mode 100644 index 000000000..1b25cafce --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_a.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['k_0',['K',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a1e65a1d66582b430961cfc4e7cc76816',1,'sf::Keyboard::Scan::K()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a25beb62393ff666a4bec18ea2a66f3f2',1,'sf::Keyboard::K()']]], + ['keycount_1',['KeyCount',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a93e6ffa0320fe9b2f29aec14a58be36b',1,'sf::Keyboard']]], + ['keypressed_2',['KeyPressed',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aac3c7abfaa98c73bfe6be0b57df09c71b',1,'sf::Event']]], + ['keyreleased_3',['KeyReleased',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aaa5bcc1e603d5a6f4c137af39558bd5d1',1,'sf::Event']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_b.js b/Space-Invaders/sfml/doc/html/search/enumvalues_b.js new file mode 100644 index 000000000..aec74a436 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_b.js @@ -0,0 +1,20 @@ +var searchData= +[ + ['l_0',['L',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ab6da0281265c57b9570de8be294d73b8',1,'sf::Keyboard::Scan::L()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a5ef1839ffe19b7e9c24f2ca017614ff9',1,'sf::Keyboard::L()']]], + ['lalt_1',['LAlt',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a9d640314aaa812b4646178409910043d',1,'sf::Keyboard::Scan::LAlt()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a000ecf5145296d7d52b6871c54e6718d',1,'sf::Keyboard::LAlt()']]], + ['launchapplication1_2',['LaunchApplication1',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac195d6bb66bd43b6c89f70df8ecc7d4d',1,'sf::Keyboard::Scan']]], + ['launchapplication2_3',['LaunchApplication2',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a7fd8f0dfcbccd3e4c72269f8159b2170',1,'sf::Keyboard::Scan']]], + ['launchmail_4',['LaunchMail',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ab91775c7cc9288d35cadc11bc65b6994',1,'sf::Keyboard::Scan']]], + ['launchmediaselect_5',['LaunchMediaSelect',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a200b5a6f78bebcf697bb4e046c41fe4c',1,'sf::Keyboard::Scan']]], + ['lbracket_6',['LBracket',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3e4bb5cf828df8c4660d323df8589c43',1,'sf::Keyboard::Scan::LBracket()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142afbe21cad5f264d685cf7f25060004184',1,'sf::Keyboard::LBracket()']]], + ['lcontrol_7',['LControl',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aa81bc64b2e4ca7eae223891075a1d754',1,'sf::Keyboard::Scan::LControl()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142acc76c9dec76d8ae806ae9d6515066e53',1,'sf::Keyboard::LControl()']]], + ['left_8',['Left',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a24060c475e1887a28d821b6174df10c9',1,'sf::Keyboard::Scan::Left()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac3fe5df11d15b57317c053a2ae13d9a9',1,'sf::Keyboard::Left()'],['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90a8bb4856e1ec7f6b6a8605effdfc0eee8',1,'sf::Mouse::Left()']]], + ['lines_9',['Lines',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba2bf015eeff9f798dfc3d6d744d669f1e',1,'sf']]], + ['linesstrip_10',['LinesStrip',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba5b09910f5d0f39641342184ccd0d1de3',1,'sf']]], + ['linestrip_11',['LineStrip',['../group__graphics.html#gga5ee56ac1339984909610713096283b1ba14d9eeec2c7c314f239a57bde35949fa',1,'sf']]], + ['localerror_12',['LocalError',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bae54e84baaca95a7b36271ca3f3fdb900',1,'sf::Ftp::Response']]], + ['loggedin_13',['LoggedIn',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba54a88210386cb72e35d737813a221754',1,'sf::Ftp::Response']]], + ['lostfocus_14',['LostFocus',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aabd7877b5011a337268357c973e8347bd',1,'sf::Event']]], + ['lshift_15',['LShift',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a99aa94c6db970fe2d06d6a0b265084d7',1,'sf::Keyboard::Scan::LShift()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a270db49f76cb4dbe72da36153d3aa45c',1,'sf::Keyboard::LShift()']]], + ['lsystem_16',['LSystem',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5e1b12c4476475396c6f04eccbbf04f7',1,'sf::Keyboard::Scan::LSystem()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a718171426307a0f5f26b4ae82a322b24',1,'sf::Keyboard::LSystem()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_c.js b/Space-Invaders/sfml/doc/html/search/enumvalues_c.js new file mode 100644 index 000000000..577181e5d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_c.js @@ -0,0 +1,26 @@ +var searchData= +[ + ['m_0',['M',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5a8351cbbb24d61c47f146f414ef825d',1,'sf::Keyboard::Scan::M()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a9718de9940f723c956587dcb90450a0a',1,'sf::Keyboard::M()']]], + ['magnetometer_1',['Magnetometer',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84ae706bb678bde8d3c370e246ffde6a63d',1,'sf::Sensor']]], + ['max_2',['Max',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32a40ddfddfaafccc8b58478eeef52e4281',1,'sf::BlendMode']]], + ['maxdatagramsize_3',['MaxDatagramSize',['../classsf_1_1UdpSocket.html#a8ad087820b1ae07267858212f3d0fac5a728a7d33027bee0d65f70f964dd9c9eb',1,'sf::UdpSocket']]], + ['medianexttrack_4',['MediaNextTrack',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a08b48a760a2a550f21b3b6b184797742',1,'sf::Keyboard::Scan']]], + ['mediaplaypause_5',['MediaPlayPause',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a421303fdaaa4cbcf571ff6905808b69b',1,'sf::Keyboard::Scan']]], + ['mediaprevioustrack_6',['MediaPreviousTrack',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac2ac37264e076dcab002e24e54090dbc',1,'sf::Keyboard::Scan']]], + ['mediastop_7',['MediaStop',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6afe82e357291a40a03c85773eae734d',1,'sf::Keyboard::Scan']]], + ['menu_8',['Menu',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad74c4a46669c3bd59ef93154e4669632',1,'sf::Keyboard::Scan::Menu()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a4aac50ce7c4923f96323fe84d592b139',1,'sf::Keyboard::Menu()']]], + ['middle_9',['Middle',['../classsf_1_1Mouse.html#a4fb128be433f9aafe66bc0c605daaa90a2c353189c4b11cf216d7caddafcc609d',1,'sf::Mouse']]], + ['min_10',['Min',['../structsf_1_1BlendMode.html#a7bce470e2e384c4f9c8d9595faef7c32aaaac595afe61d785aa8fd4b401acffc5',1,'sf::BlendMode']]], + ['modechange_11',['ModeChange',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adbd3b55bd8d0f7c790f30d5a5bb6660c',1,'sf::Keyboard::Scan']]], + ['mousebuttonpressed_12',['MouseButtonPressed',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa55a3dcc8bf6c40e37f9ff2cdf606481f',1,'sf::Event']]], + ['mousebuttonreleased_13',['MouseButtonReleased',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa9be69ecc07e484467ebbb133182fe5c1',1,'sf::Event']]], + ['mouseentered_14',['MouseEntered',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa50d98590a953e74c7ccf3dabadb22067',1,'sf::Event']]], + ['mouseleft_15',['MouseLeft',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aaa90b8526b328e0246d04b026de17c6e7',1,'sf::Event']]], + ['mousemoved_16',['MouseMoved',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa4ff4fc3b3dc857e3617a63feb54be209',1,'sf::Event']]], + ['mousewheelmoved_17',['MouseWheelMoved',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa5cc9d3941af2a36049f4f9922c934a80',1,'sf::Event']]], + ['mousewheelscrolled_18',['MouseWheelScrolled',['../classsf_1_1Event.html#af41fa9ed45c02449030699f671331d4aa2fb6925eb3e7f3d468faf639dbd129ad',1,'sf::Event']]], + ['movedpermanently_19',['MovedPermanently',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a2f91651db3a09628faf68cbcefa0810a',1,'sf::Http::Response']]], + ['movedtemporarily_20',['MovedTemporarily',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a05c50d7b17c844e0b909e5802d5f1587',1,'sf::Http::Response']]], + ['multiplechoices_21',['MultipleChoices',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8add95cbd8fa27516821f763488557f96b',1,'sf::Http::Response']]], + ['multiply_22',['Multiply',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a10623ae71db8a6b5d97189fc21fb91ae',1,'sf::Keyboard']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_d.js b/Space-Invaders/sfml/doc/html/search/enumvalues_d.js new file mode 100644 index 000000000..8a4488917 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_d.js @@ -0,0 +1,48 @@ +var searchData= +[ + ['n_0',['N',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a72b52a30a5f3aee77dc52e7c54c8db9f',1,'sf::Keyboard::Scan::N()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab652ed6b308db95a74dc4ff5229ac9c8',1,'sf::Keyboard::N()']]], + ['needaccounttologin_1',['NeedAccountToLogIn',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba9e048185f253f6eb6f5ff9e063b712fa',1,'sf::Ftp::Response']]], + ['needaccounttostore_2',['NeedAccountToStore',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba1af0f173062a471739b50d8e0f40d5f7',1,'sf::Ftp::Response']]], + ['needinformation_3',['NeedInformation',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba02e6f05964ecb829e9b6fb6020d6528a',1,'sf::Ftp::Response']]], + ['needpassword_4',['NeedPassword',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba9249e3fe9818eb93f181fbbf3ae3bc56',1,'sf::Ftp::Response']]], + ['nocontent_5',['NoContent',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8aefde9e4abf5682dcd314d63143be42e0',1,'sf::Http::Response']]], + ['noloop_6',['NoLoop',['../classsf_1_1SoundStream.html#a7707214e7cd4ffcf1c123e7bcab4092aa2f2c638731fdff0d6fe4e3e82b6f6146',1,'sf::SoundStream']]], + ['none_7',['None',['../group__window.html#gga97d7ee508bea4507ab40271518c732ffa8c35a9c8507559e455387fc4a83ce422',1,'sf::Style']]], + ['nonusbackslash_8',['NonUsBackslash',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a44a8cbe245638c8431b233930f543a87',1,'sf::Keyboard::Scan']]], + ['normalized_9',['Normalized',['../classsf_1_1Texture.html#aa6fd3bbe3c334b3c4428edfb2765a82ea69d6228950882e4d68be4ba4dbe7df73',1,'sf::Texture']]], + ['notallowed_10',['NotAllowed',['../classsf_1_1Cursor.html#ab9ab152aec1f8a4955e34ccae08f930aadb1ec726725dd81ec9906cbe06fec805',1,'sf::Cursor']]], + ['notenoughmemory_11',['NotEnoughMemory',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baf418e54753e0b8f9cb0325dd618acd14',1,'sf::Ftp::Response']]], + ['notfound_12',['NotFound',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8affca8a8319a62d98bd3ef90ff5cfc030',1,'sf::Http::Response']]], + ['notimplemented_13',['NotImplemented',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a6920ba06d7e2bcf0b325da23ee95ef68',1,'sf::Http::Response']]], + ['notloggedin_14',['NotLoggedIn',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bafcfbaff2c6fed941b6bcbc0999db764e',1,'sf::Ftp::Response']]], + ['notmodified_15',['NotModified',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a060ebc3af266e6bfe045b89e298e2545',1,'sf::Http::Response']]], + ['notready_16',['NotReady',['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dca8554848daae98f996e131bdeed076c09',1,'sf::Socket']]], + ['num0_17',['Num0',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af026fd133ee93a0bd8c70762cc3be4bc',1,'sf::Keyboard::Num0()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adb7e8aa25d5d5204de03a5aa1ee0b390',1,'sf::Keyboard::Scan::Num0()']]], + ['num1_18',['Num1',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875adbf8eb09afd75e2081b009ad7a3596ef',1,'sf::Keyboard::Scan::Num1()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a506bd962cab80722a8c5a4b178912c59',1,'sf::Keyboard::Num1()']]], + ['num2_19',['Num2',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a16cfef5671ce6401aaf00316c88c0c7b',1,'sf::Keyboard::Scan::Num2()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a2d6eb5118179bb140fdb3485bb08c182',1,'sf::Keyboard::Num2()']]], + ['num3_20',['Num3',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3301c6093c6f2a78158c1e44e3431227',1,'sf::Keyboard::Scan::Num3()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aee78e5ed27d31598fc285400166c0dd5',1,'sf::Keyboard::Num3()']]], + ['num4_21',['Num4',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a15943e415124e0848e6b065d24b1b1e7',1,'sf::Keyboard::Scan::Num4()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a5fbd8a089460dc33c22f68b36e1fdc98',1,'sf::Keyboard::Num4()']]], + ['num5_22',['Num5',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875abf2de94b5156b86a228d7e5ec66d056a',1,'sf::Keyboard::Scan::Num5()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a1dc7e87810b8d4b7039e202b0adcc4ee',1,'sf::Keyboard::Num5()']]], + ['num6_23',['Num6',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a6cd9d57ae648639eedcd16cb83da1af5',1,'sf::Keyboard::Scan::Num6()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af86dafb69d922ad2b0f4bd4c37696575',1,'sf::Keyboard::Num6()']]], + ['num7_24',['Num7',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aaf5540b714391414c06503b8aaee908a',1,'sf::Keyboard::Scan::Num7()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a8fa0056a0a6f5a7d9fcef3402c9c916d',1,'sf::Keyboard::Num7()']]], + ['num8_25',['Num8',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142adb9f2549fd57bfd99d4713ff1845c530',1,'sf::Keyboard::Num8()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aee7fee4dc6a4dbfe9e038a5366cc1e4b',1,'sf::Keyboard::Scan::Num8()']]], + ['num9_26',['Num9',['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a9bc0d0727958bef97e2b6a58e23743db',1,'sf::Keyboard::Num9()'],['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875af003329d2c5a26d0262caf3ddef0a45e',1,'sf::Keyboard::Scan::Num9()']]], + ['numlock_27',['NumLock',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad1d1d7ce47ea768bcb565633fe9962b5',1,'sf::Keyboard::Scan']]], + ['numpad0_28',['Numpad0',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5852c4163a2cacb7979415d09412d500',1,'sf::Keyboard::Scan::Numpad0()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142af0b2af83a7a8c358f7b8f7c403089a4e',1,'sf::Keyboard::Numpad0()']]], + ['numpad1_29',['Numpad1',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac17746b6b36dc8b79a222fa73ef2501e',1,'sf::Keyboard::Scan::Numpad1()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a03536d369ae55cc18024f7e4a341a5ac',1,'sf::Keyboard::Numpad1()']]], + ['numpad2_30',['Numpad2',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a53e419e5206289bcc16b4500bd8105af',1,'sf::Keyboard::Scan::Numpad2()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a8ad9ccf62631d583f44f06aebd662093',1,'sf::Keyboard::Numpad2()']]], + ['numpad3_31',['Numpad3',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a185a36e136a349d9073312919cede6a7',1,'sf::Keyboard::Scan::Numpad3()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ab63ae26e90126b1842bde25d6dedb205',1,'sf::Keyboard::Numpad3()']]], + ['numpad4_32',['Numpad4',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a25c36d972efaf310f4f9d4ec23b89df5',1,'sf::Keyboard::Scan::Numpad4()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a65336d823bd823a0d246a872ff90e08a',1,'sf::Keyboard::Numpad4()']]], + ['numpad5_33',['Numpad5',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a8e370bc5b50d37f1ed280453fa6d47f6',1,'sf::Keyboard::Scan::Numpad5()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a8bc5041f12fdfbefba1dbd823c7e1054',1,'sf::Keyboard::Numpad5()']]], + ['numpad6_34',['Numpad6',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a58523c54f6cfb3844021e7a9526eb34b',1,'sf::Keyboard::Scan::Numpad6()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aaf28fdf0d3da6a18030e685478e3a713',1,'sf::Keyboard::Numpad6()']]], + ['numpad7_35',['Numpad7',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a3d0502d5ad29d2e8bdfd5e4ab03252ee',1,'sf::Keyboard::Scan::Numpad7()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a3f9bf9835d65a0df5cce2d3842a40541',1,'sf::Keyboard::Numpad7()']]], + ['numpad8_36',['Numpad8',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a74fda39289bc3e8ff17d4aec863b7029',1,'sf::Keyboard::Scan::Numpad8()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a25dcd4e4183ceceb3ac06c72995bae49',1,'sf::Keyboard::Numpad8()']]], + ['numpad9_37',['Numpad9',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a335a1aa0289d7e582fdc924ca710cbc1',1,'sf::Keyboard::Scan::Numpad9()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a365eb80f54003670a78e3b850c28df21',1,'sf::Keyboard::Numpad9()']]], + ['numpaddecimal_38',['NumpadDecimal',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a62ce565c4d62bcbd9a9af09f8d4f80df',1,'sf::Keyboard::Scan']]], + ['numpaddivide_39',['NumpadDivide',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ac3dc3e9289a9b7db8aa346c3f02b327d',1,'sf::Keyboard::Scan']]], + ['numpadenter_40',['NumpadEnter',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ad6da599320b8c485ca42eb16e81d0ad0',1,'sf::Keyboard::Scan']]], + ['numpadequal_41',['NumpadEqual',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a5b96402c34611cd5a7661c9c93e8dc0a',1,'sf::Keyboard::Scan']]], + ['numpadminus_42',['NumpadMinus',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae48b0805330de77fbf671644d446a9ef',1,'sf::Keyboard::Scan']]], + ['numpadmultiply_43',['NumpadMultiply',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875abd043b0e9270f97b4c1d6c2e4bf94288',1,'sf::Keyboard::Scan']]], + ['numpadplus_44',['NumpadPlus',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875abb76cfff74d39902a4c7b286520f1d5b',1,'sf::Keyboard::Scan']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_e.js b/Space-Invaders/sfml/doc/html/search/enumvalues_e.js new file mode 100644 index 000000000..194b64354 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_e.js @@ -0,0 +1,12 @@ +var searchData= +[ + ['o_0',['O',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875aafe949e3a5c03b8981026f5b9621154b',1,'sf::Keyboard::Scan::O()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a7739288cc628dfa8c50ba712be7c03e1',1,'sf::Keyboard::O()']]], + ['ok_1',['Ok',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baa956e229ba6c0cdf0d88b0e05b286210',1,'sf::Ftp::Response::Ok()'],['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a0158f932254d3f09647dd1f64bd43832',1,'sf::Http::Response::Ok()']]], + ['one_2',['One',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbaa2d3ba8b8bb2233c9d357cbb94bf4181',1,'sf::BlendMode']]], + ['oneminusdstalpha_3',['OneMinusDstAlpha',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbab4e5c63f189f26075e5939ad1a2ce4e4',1,'sf::BlendMode']]], + ['oneminusdstcolor_4',['OneMinusDstColor',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbac8198db20d14506a841d1091ced1cae2',1,'sf::BlendMode']]], + ['oneminussrcalpha_5',['OneMinusSrcAlpha',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbbaab57e8616bf4c21d8ee923178acdf2c8',1,'sf::BlendMode']]], + ['oneminussrccolor_6',['OneMinusSrcColor',['../structsf_1_1BlendMode.html#afb9852caf356b53bb0de460c58a9ebbba5971ffdbca63382058ccba76bfce219e',1,'sf::BlendMode']]], + ['openingdataconnection_7',['OpeningDataConnection',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba794ebe743688be611447638bf9e49d86',1,'sf::Ftp::Response']]], + ['orientation_8',['Orientation',['../classsf_1_1Sensor.html#a687375af3ab77b818fca73735bcaea84aa428c5260446555de87c69b65f6edf00',1,'sf::Sensor']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/enumvalues_f.js b/Space-Invaders/sfml/doc/html/search/enumvalues_f.js new file mode 100644 index 000000000..7b01e4efd --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/enumvalues_f.js @@ -0,0 +1,24 @@ +var searchData= +[ + ['p_0',['P',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a0943cf62e03a8616a8a41b72539ded38',1,'sf::Keyboard::Scan::P()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aaeac1db209a64a0221277a835de986e6',1,'sf::Keyboard::P()']]], + ['pagedown_1',['PageDown',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a395ec644184fe789a12ee2ed98d19ee3',1,'sf::Keyboard::Scan::PageDown()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a21c73323d9a8b6017f3bac0cb8c8ac1a',1,'sf::Keyboard::PageDown()']]], + ['pagetypeunknown_2',['PageTypeUnknown',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3bad220bc12dc45593af6e5079ea6c532c3',1,'sf::Ftp::Response']]], + ['pageup_3',['PageUp',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a0c1f655bf99a3c7d2052814385fb222d',1,'sf::Keyboard::Scan::PageUp()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142aa24fe33bba1c3639c3aeaa317bd89d7e',1,'sf::Keyboard::PageUp()']]], + ['parameternotimplemented_4',['ParameterNotImplemented',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba8807473b8590e1debfb3740b7a3d081c',1,'sf::Ftp::Response']]], + ['parametersunknown_5',['ParametersUnknown',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3baf4c7c88815981bbb7c3a3461f9f48b67',1,'sf::Ftp::Response']]], + ['partial_6',['Partial',['../classsf_1_1Socket.html#a51bf0fd51057b98a10fbb866246176dca181c163fad2eaea927185d127c392706',1,'sf::Socket']]], + ['partialcontent_7',['PartialContent',['../classsf_1_1Http_1_1Response.html#a663e071978e30fbbeb20ed045be874d8a0cfae3ab0469b73dfddc54312a5e6a8a',1,'sf::Http::Response']]], + ['paste_8',['Paste',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ab5417583410afc02cad51e66cb97b196',1,'sf::Keyboard::Scan']]], + ['pause_9',['Pause',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a40a805122e3ce91bde95d98ac43be234',1,'sf::Keyboard::Scan::Pause()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142a95daf340fcc3d5c2846f69d184170d9b',1,'sf::Keyboard::Pause()']]], + ['paused_10',['Paused',['../classsf_1_1SoundSource.html#ac43af72c98c077500b239bc75b812f03ac3ca1fcc0394267c9bdbe3dc0a8a7e41',1,'sf::SoundSource']]], + ['period_11',['Period',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875ae09b8ab0fa58ee31f499678d3e93a411',1,'sf::Keyboard::Scan::Period()'],['../classsf_1_1Keyboard.html#acb4cacd7cc5802dec45724cf3314a142ac72ba959ab1946957e8dfd4f81ea811d',1,'sf::Keyboard::Period()']]], + ['pixels_12',['Pixels',['../classsf_1_1Texture.html#aa6fd3bbe3c334b3c4428edfb2765a82ea6372f9c3a10203a7a69d8d5da59d82ff',1,'sf::Texture']]], + ['playing_13',['Playing',['../classsf_1_1SoundSource.html#ac43af72c98c077500b239bc75b812f03af07bdea9f70ef7606dfc9f955beeee18',1,'sf::SoundSource']]], + ['pointlesscommand_14',['PointlessCommand',['../classsf_1_1Ftp_1_1Response.html#af81738f06b6f571761696291276acb3ba38adc424f1adcd332745de8cd3b7737a',1,'sf::Ftp::Response']]], + ['points_15',['Points',['../group__graphics.html#gga5ee56ac1339984909610713096283b1bac7097d3e01778b9318def1f7ac35a785',1,'sf']]], + ['post_16',['Post',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598ae8ec4048b9550f8d0747d4199603141a',1,'sf::Http::Request']]], + ['povx_17',['PovX',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a06420f7714e4dfd8b841885a0b5f3954',1,'sf::Joystick']]], + ['povy_18',['PovY',['../classsf_1_1Joystick.html#a48db337092c2e263774f94de6d50baa7a0f8ffb2dcddf91b98ab910a4f8327ad9',1,'sf::Joystick']]], + ['printscreen_19',['PrintScreen',['../structsf_1_1Keyboard_1_1Scan.html#aa42fbf6954d6f81f7606e566c7abe875a8699683af17a0a4031bccf52f5222302',1,'sf::Keyboard::Scan']]], + ['put_20',['Put',['../classsf_1_1Http_1_1Request.html#a620f8bff6f43e1378f321bf53fbf5598a523b94f9af069c1f35061d32011e2495',1,'sf::Http::Request']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/files_0.js b/Space-Invaders/sfml/doc/html/search/files_0.js new file mode 100644 index 000000000..e4bcb9d15 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/files_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['gpupreference_2ehpp_0',['GpuPreference.hpp',['../GpuPreference_8hpp.html',1,'']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_0.js b/Space-Invaders/sfml/doc/html/search/functions_0.js new file mode 100644 index 000000000..15f500473 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_0.js @@ -0,0 +1,10 @@ +var searchData= +[ + ['accept_0',['accept',['../classsf_1_1TcpListener.html#ae2c83ce5a64d50b68180c46bef0a7346',1,'sf::TcpListener']]], + ['add_1',['add',['../classsf_1_1SocketSelector.html#ade952013232802ff7b9b33668f8d2096',1,'sf::SocketSelector']]], + ['alresource_2',['AlResource',['../classsf_1_1AlResource.html#a51b4f3a825c5d68386f8683e3e1053d7',1,'sf::AlResource']]], + ['append_3',['append',['../classsf_1_1VertexArray.html#a80c8f6865e53bd21fc6cb10fffa10035',1,'sf::VertexArray::append()'],['../classsf_1_1Packet.html#a7dd6e429b87520008326c4d71f1cf011',1,'sf::Packet::append()']]], + ['asmicroseconds_4',['asMicroseconds',['../classsf_1_1Time.html#a000c2c64b74658ebd228b9294a464275',1,'sf::Time']]], + ['asmilliseconds_5',['asMilliseconds',['../classsf_1_1Time.html#aa16858ca030a07eb18958c321f256e5a',1,'sf::Time']]], + ['asseconds_6',['asSeconds',['../classsf_1_1Time.html#aa3df2f992d0b0041b4eb02258d43f0e3',1,'sf::Time']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_1.js b/Space-Invaders/sfml/doc/html/search/functions_1.js new file mode 100644 index 000000000..f1612dbae --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_1.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['begin_0',['begin',['../classsf_1_1String.html#a8ec30ddc08e3a6bd11c99aed782f6dfe',1,'sf::String::begin()'],['../classsf_1_1String.html#a0e4755d6b4d51de7c3dc2e984b79f95d',1,'sf::String::begin() const']]], + ['bind_1',['bind',['../classsf_1_1Shader.html#a09778f78afcbeb854d608c8dacd8ea30',1,'sf::Shader::bind()'],['../classsf_1_1Texture.html#ae9a4274e7b95ebf7244d09c7445833b0',1,'sf::Texture::bind()'],['../classsf_1_1VertexBuffer.html#a1c623e9701b43125e4b3661bc0d0b65b',1,'sf::VertexBuffer::bind()'],['../classsf_1_1UdpSocket.html#ad764c3d06d90b4714dcc97a0d1647bcc',1,'sf::UdpSocket::bind()']]], + ['blendmode_2',['BlendMode',['../structsf_1_1BlendMode.html#a7faef75eae1fb47bbe93f45f38e3d345',1,'sf::BlendMode::BlendMode()'],['../structsf_1_1BlendMode.html#a23c7452cc8e9eb943c3aea6234ce4297',1,'sf::BlendMode::BlendMode(Factor sourceFactor, Factor destinationFactor, Equation blendEquation=Add)'],['../structsf_1_1BlendMode.html#a69a12c596114e77126616e7e0f7d798b',1,'sf::BlendMode::BlendMode(Factor colorSourceFactor, Factor colorDestinationFactor, Equation colorBlendEquation, Factor alphaSourceFactor, Factor alphaDestinationFactor, Equation alphaBlendEquation)']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_10.js b/Space-Invaders/sfml/doc/html/search/functions_10.js new file mode 100644 index 000000000..072ce1b3e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_10.js @@ -0,0 +1,96 @@ +var searchData= +[ + ['savetofile_0',['saveToFile',['../classsf_1_1SoundBuffer.html#aade64260c6375580a085314a30be007e',1,'sf::SoundBuffer::saveToFile()'],['../classsf_1_1Image.html#a51537fb667f47cbe80395cfd7f9e72a4',1,'sf::Image::saveToFile(const std::string &filename) const']]], + ['savetomemory_1',['saveToMemory',['../classsf_1_1Image.html#ae33432a31031ee501674efa9b6dc3f40',1,'sf::Image']]], + ['scale_2',['scale',['../classsf_1_1Transform.html#a846e9ff8567f50adea9b3ce4c70c1554',1,'sf::Transform::scale(float scaleX, float scaleY)'],['../classsf_1_1Transform.html#af1ad4ae13dacaf812b6411142243042b',1,'sf::Transform::scale(float scaleX, float scaleY, float centerX, float centerY)'],['../classsf_1_1Transform.html#a23fe4e63821354600b7592be90f2d65e',1,'sf::Transform::scale(const Vector2f &factors)'],['../classsf_1_1Transform.html#a486a4a1946208a883c7f8ec1e9cf2e35',1,'sf::Transform::scale(const Vector2f &factors, const Vector2f &center)'],['../classsf_1_1Transformable.html#a3de0c6d8957f3cf318092f3f60656391',1,'sf::Transformable::scale(float factorX, float factorY)'],['../classsf_1_1Transformable.html#adecaa6c69b1f27dd5194b067d96bb694',1,'sf::Transformable::scale(const Vector2f &factor)']]], + ['seconds_3',['seconds',['../classsf_1_1Time.html#af9fc40a6c0e687e3430da1cf296385b1',1,'sf::Time']]], + ['seek_4',['seek',['../classsf_1_1InputSoundFile.html#aaf97be15020a42e159ff88f76f22af20',1,'sf::InputSoundFile::seek(Uint64 sampleOffset)'],['../classsf_1_1InputSoundFile.html#a8eee7af58ad75ddc61f93ad72e2d66c1',1,'sf::InputSoundFile::seek(Time timeOffset)'],['../classsf_1_1SoundFileReader.html#a1e18ade5ffe882bdfa20a2ebe7e2b015',1,'sf::SoundFileReader::seek()'],['../classsf_1_1FileInputStream.html#abdaf5700d4e1de07568e7829106b4eb9',1,'sf::FileInputStream::seek()'],['../classsf_1_1InputStream.html#a76aba8e5d5cf9b1c5902d5e04f7864fc',1,'sf::InputStream::seek()'],['../classsf_1_1MemoryInputStream.html#aa2ac8fda2bdb4c95248ae90c71633034',1,'sf::MemoryInputStream::seek()']]], + ['send_5',['send',['../classsf_1_1TcpSocket.html#affce26ab3bcc4f5b9269dad79db544c0',1,'sf::TcpSocket::send(const void *data, std::size_t size)'],['../classsf_1_1TcpSocket.html#a31f5b280126a96c6f3ad430f4cbcb54d',1,'sf::TcpSocket::send(const void *data, std::size_t size, std::size_t &sent)'],['../classsf_1_1TcpSocket.html#a0f8276e2b1c75aac4a7b0a707b250f44',1,'sf::TcpSocket::send(Packet &packet)'],['../classsf_1_1UdpSocket.html#a664ab8f26f37c21cc4de1b847c2efcca',1,'sf::UdpSocket::send(const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort)'],['../classsf_1_1UdpSocket.html#a48969a62c80d40fd74293a740798e435',1,'sf::UdpSocket::send(Packet &packet, const IpAddress &remoteAddress, unsigned short remotePort)']]], + ['sendcommand_6',['sendCommand',['../classsf_1_1Ftp.html#a44e095103ecbce175a33eaf0820440ff',1,'sf::Ftp']]], + ['sendrequest_7',['sendRequest',['../classsf_1_1Http.html#aaf09ebfb5e00dcc82e0d494d5c6a9e2a',1,'sf::Http']]], + ['setactive_8',['setActive',['../classsf_1_1RenderTarget.html#adc225ead22a70843ffa9b7eebefa0ce1',1,'sf::RenderTarget::setActive()'],['../classsf_1_1RenderTexture.html#a5da95ecdbce615a80bb78399012508cf',1,'sf::RenderTexture::setActive()'],['../classsf_1_1RenderWindow.html#aee6c53eced675e885931eb3e91f11155',1,'sf::RenderWindow::setActive()'],['../classsf_1_1Context.html#a0806f915ea81ae1f4e8135a7a3696562',1,'sf::Context::setActive()'],['../classsf_1_1Window.html#aaab549da64cedf74fa6f1ae7a3cc79e0',1,'sf::Window::setActive()']]], + ['setattenuation_9',['setAttenuation',['../classsf_1_1SoundSource.html#aa2adff44cd2f8b4e3c7315d7c2a45626',1,'sf::SoundSource']]], + ['setblocking_10',['setBlocking',['../classsf_1_1Socket.html#a165fc1423e281ea2714c70303d3a9782',1,'sf::Socket']]], + ['setbody_11',['setBody',['../classsf_1_1Http_1_1Request.html#ae9f61ec3fa1639c70e9b5780cb35578e',1,'sf::Http::Request']]], + ['setbuffer_12',['setBuffer',['../classsf_1_1Sound.html#a8b395e9713d0efa48a18628c8ec1972e',1,'sf::Sound']]], + ['setcenter_13',['setCenter',['../classsf_1_1View.html#aa8e3fedb008306ff9811163545fb75f2',1,'sf::View::setCenter(float x, float y)'],['../classsf_1_1View.html#ab0296b03793e0873e6ae9e15311f3e78',1,'sf::View::setCenter(const Vector2f &center)']]], + ['setchannelcount_14',['setChannelCount',['../classsf_1_1SoundRecorder.html#ae4e22ba67d12a74966eb05fad55a317c',1,'sf::SoundRecorder']]], + ['setcharactersize_15',['setCharacterSize',['../classsf_1_1Text.html#ae96f835fc1bff858f8a23c5b01eaaf7e',1,'sf::Text']]], + ['setcolor_16',['setColor',['../classsf_1_1Sprite.html#a14def44da6437bfea20c4df5e71aba4c',1,'sf::Sprite::setColor()'],['../classsf_1_1Text.html#afd1742fca1adb6b0ea98357250ffb634',1,'sf::Text::setColor()']]], + ['setdevice_17',['setDevice',['../classsf_1_1SoundRecorder.html#a8eb3e473292c16e874322815836d3cd3',1,'sf::SoundRecorder']]], + ['setdirection_18',['setDirection',['../classsf_1_1Listener.html#ae479dc15513c6557984d26e32d06d06e',1,'sf::Listener::setDirection(float x, float y, float z)'],['../classsf_1_1Listener.html#a1d99d9457c6ddad93449ecb4f504c2bf',1,'sf::Listener::setDirection(const Vector3f &direction)']]], + ['setenabled_19',['setEnabled',['../classsf_1_1Sensor.html#afb31c5697d2e0a5fec70d702ec1d6cd9',1,'sf::Sensor']]], + ['setfield_20',['setField',['../classsf_1_1Http_1_1Request.html#aea672fae5dd089f4b6b3745ed46210d2',1,'sf::Http::Request']]], + ['setfillcolor_21',['setFillColor',['../classsf_1_1Shape.html#a3506f9b5d916fec14d583d16f23c2485',1,'sf::Shape::setFillColor()'],['../classsf_1_1Text.html#ab7bb3babac5a6da1802b2c3e1a3e6dcc',1,'sf::Text::setFillColor(const Color &color)']]], + ['setfont_22',['setFont',['../classsf_1_1Text.html#a2927805d1ae92d57f15034ea34756b81',1,'sf::Text']]], + ['setframeratelimit_23',['setFramerateLimit',['../classsf_1_1Window.html#af4322d315baf93405bf0d5087ad5e784',1,'sf::Window']]], + ['setglobalvolume_24',['setGlobalVolume',['../classsf_1_1Listener.html#a803a24a1fc04620cacc9f88c6fbc0e3a',1,'sf::Listener']]], + ['sethost_25',['setHost',['../classsf_1_1Http.html#a55121d543b61c41cf20b885a97b04e65',1,'sf::Http']]], + ['sethttpversion_26',['setHttpVersion',['../classsf_1_1Http_1_1Request.html#aa683b607b737a6224a91387b4108d3c7',1,'sf::Http::Request']]], + ['seticon_27',['setIcon',['../classsf_1_1WindowBase.html#add42ae12c13012e6aab74d9e34591719',1,'sf::WindowBase']]], + ['setjoystickthreshold_28',['setJoystickThreshold',['../classsf_1_1WindowBase.html#ad37f939b492c7ea046d4f7b45ac46df1',1,'sf::WindowBase']]], + ['setkeyrepeatenabled_29',['setKeyRepeatEnabled',['../classsf_1_1WindowBase.html#afd1199a64d459ba531deb65f093050a6',1,'sf::WindowBase']]], + ['setletterspacing_30',['setLetterSpacing',['../classsf_1_1Text.html#ab516110605edb0191a7873138ac42af2',1,'sf::Text']]], + ['setlinespacing_31',['setLineSpacing',['../classsf_1_1Text.html#af6505688f79e2e2d90bd68f4d767e965',1,'sf::Text']]], + ['setloop_32',['setLoop',['../classsf_1_1Sound.html#af23ab4f78f975bbabac031102321612b',1,'sf::Sound::setLoop()'],['../classsf_1_1SoundStream.html#a43fade018ffba7e4f847a9f00b353f3d',1,'sf::SoundStream::setLoop()']]], + ['setlooppoints_33',['setLoopPoints',['../classsf_1_1Music.html#ae7b339f0a957dfad045f3f28083a015e',1,'sf::Music']]], + ['setmethod_34',['setMethod',['../classsf_1_1Http_1_1Request.html#abab148554e873e80d2e41376fde1cb62',1,'sf::Http::Request']]], + ['setmindistance_35',['setMinDistance',['../classsf_1_1SoundSource.html#a75bbc2c34addc8b25a14edb908508afe',1,'sf::SoundSource']]], + ['setmousecursor_36',['setMouseCursor',['../classsf_1_1WindowBase.html#a07487a3c7e04472b19e96d3a602213ec',1,'sf::WindowBase']]], + ['setmousecursorgrabbed_37',['setMouseCursorGrabbed',['../classsf_1_1WindowBase.html#a0023344922a1e854175c8ca22b072020',1,'sf::WindowBase']]], + ['setmousecursorvisible_38',['setMouseCursorVisible',['../classsf_1_1WindowBase.html#afa4a3372b2870294d1579d8621fe3c1a',1,'sf::WindowBase']]], + ['setorigin_39',['setOrigin',['../classsf_1_1Transformable.html#a56c67bd80aae8418d13fb96c034d25ec',1,'sf::Transformable::setOrigin(float x, float y)'],['../classsf_1_1Transformable.html#aa93a835ffbf3bee2098dfbbc695a7f05',1,'sf::Transformable::setOrigin(const Vector2f &origin)']]], + ['setoutlinecolor_40',['setOutlineColor',['../classsf_1_1Shape.html#a5978f41ee349ac3c52942996dcb184f7',1,'sf::Shape::setOutlineColor()'],['../classsf_1_1Text.html#aa19ec69c3b894e963602a6804ca68fe4',1,'sf::Text::setOutlineColor()']]], + ['setoutlinethickness_41',['setOutlineThickness',['../classsf_1_1Shape.html#a5ad336ad74fc1f567fce3b7e44cf87dc',1,'sf::Shape::setOutlineThickness()'],['../classsf_1_1Text.html#ab0e6be3b40124557bf53737fe6a6ce77',1,'sf::Text::setOutlineThickness()']]], + ['setparameter_42',['setParameter',['../classsf_1_1Shader.html#a47e4dd78f0752ae08664b4ee616db1cf',1,'sf::Shader::setParameter(const std::string &name, float x)'],['../classsf_1_1Shader.html#ab8d379f40810b8e3eadebee81aedd231',1,'sf::Shader::setParameter(const std::string &name, float x, float y)'],['../classsf_1_1Shader.html#a7e36e044d6b8adca8339f40c5a4b1801',1,'sf::Shader::setParameter(const std::string &name, float x, float y, float z)'],['../classsf_1_1Shader.html#aeb468f1bc2d26750b96b74f1e19027fb',1,'sf::Shader::setParameter(const std::string &name, float x, float y, float z, float w)'],['../classsf_1_1Shader.html#a3ac473ece2c6fa26dc5032c07fd7288e',1,'sf::Shader::setParameter(const std::string &name, const Vector2f &vector)'],['../classsf_1_1Shader.html#a87d4a0c6dc70ae68aecc0dda3f343c07',1,'sf::Shader::setParameter(const std::string &name, const Vector3f &vector)'],['../classsf_1_1Shader.html#aa8618119ed4399df3fd33e78ee96b4fc',1,'sf::Shader::setParameter(const std::string &name, const Color &color)'],['../classsf_1_1Shader.html#a8599ee1348407025039b89ddf3f7cb62',1,'sf::Shader::setParameter(const std::string &name, const Transform &transform)'],['../classsf_1_1Shader.html#a7f58ab5c0a1084f238dfcec86602daa1',1,'sf::Shader::setParameter(const std::string &name, const Texture &texture)'],['../classsf_1_1Shader.html#af06b4cba0bab915fa01032b063909044',1,'sf::Shader::setParameter(const std::string &name, CurrentTextureType)']]], + ['setpitch_43',['setPitch',['../classsf_1_1SoundSource.html#a72a13695ed48b7f7b55e7cd4431f4bb6',1,'sf::SoundSource']]], + ['setpixel_44',['setPixel',['../classsf_1_1Image.html#a9fd329b8cd7d4439e07fb5d3bb2d9744',1,'sf::Image']]], + ['setplayingoffset_45',['setPlayingOffset',['../classsf_1_1Sound.html#ab905677846558042022dd6ab15cddff0',1,'sf::Sound::setPlayingOffset()'],['../classsf_1_1SoundStream.html#af416a5f84c8750d2acb9821d78bc8646',1,'sf::SoundStream::setPlayingOffset()']]], + ['setpoint_46',['setPoint',['../classsf_1_1ConvexShape.html#a5929e0ab0ba5ca1f102b40c234a8e92d',1,'sf::ConvexShape']]], + ['setpointcount_47',['setPointCount',['../classsf_1_1CircleShape.html#a16590ee7bdf5c9f752275468a4997bed',1,'sf::CircleShape::setPointCount()'],['../classsf_1_1ConvexShape.html#a56e6e79ade6dd651cc1a0e39cb68deae',1,'sf::ConvexShape::setPointCount()']]], + ['setposition_48',['setPosition',['../classsf_1_1Listener.html#a5bc2d8d18ea2d8f339d23cbf17678564',1,'sf::Listener::setPosition(float x, float y, float z)'],['../classsf_1_1Listener.html#a28a27d85cfbf8065c535c39176898fcb',1,'sf::Listener::setPosition(const Vector3f &position)'],['../classsf_1_1SoundSource.html#a0480257ea25d986eba6cc3c1a6f8d7c2',1,'sf::SoundSource::setPosition(float x, float y, float z)'],['../classsf_1_1SoundSource.html#a17ba9ed01925395652181a7b2a7d3aef',1,'sf::SoundSource::setPosition(const Vector3f &position)'],['../classsf_1_1Transformable.html#a4dbfb1a7c80688b0b4c477d706550208',1,'sf::Transformable::setPosition(float x, float y)'],['../classsf_1_1Transformable.html#af1a42209ce2b5d3f07b00f917bcd8015',1,'sf::Transformable::setPosition(const Vector2f &position)'],['../classsf_1_1Mouse.html#a1222e16c583be9e3d176d86e0b7817d7',1,'sf::Mouse::setPosition(const Vector2i &position)'],['../classsf_1_1Mouse.html#a698c41e9bce6f30ceb4063c21f869fc5',1,'sf::Mouse::setPosition(const Vector2i &position, const WindowBase &relativeTo)'],['../classsf_1_1WindowBase.html#ab5b8d500fa5acd3ac2908c9221fe2019',1,'sf::WindowBase::setPosition()']]], + ['setprimitivetype_49',['setPrimitiveType',['../classsf_1_1VertexArray.html#aa38c10707c28a97f4627ae8b2f3ad969',1,'sf::VertexArray::setPrimitiveType()'],['../classsf_1_1VertexBuffer.html#a7c429dbef94224a86d605cf4c68aa02d',1,'sf::VertexBuffer::setPrimitiveType()']]], + ['setprocessinginterval_50',['setProcessingInterval',['../classsf_1_1SoundRecorder.html#a85b7fb8a86c08b5084f8f142767bccf6',1,'sf::SoundRecorder::setProcessingInterval()'],['../classsf_1_1SoundStream.html#a3a38d317279163f3766da2e538fbde93',1,'sf::SoundStream::setProcessingInterval()']]], + ['setradius_51',['setRadius',['../classsf_1_1CircleShape.html#a21cdf85fc2f201e10222a241af864be0',1,'sf::CircleShape']]], + ['setrelativetolistener_52',['setRelativeToListener',['../classsf_1_1SoundSource.html#ac478a8b813faf7dd575635b102081d0d',1,'sf::SoundSource']]], + ['setrepeated_53',['setRepeated',['../classsf_1_1RenderTexture.html#af8f97b33512bf7d5b6be3da6f65f7365',1,'sf::RenderTexture::setRepeated()'],['../classsf_1_1Texture.html#aaa87d1eff053b9d4d34a24c784a28658',1,'sf::Texture::setRepeated()']]], + ['setrotation_54',['setRotation',['../classsf_1_1Transformable.html#a32baf2bf1a74699b03bf8c95030a38ed',1,'sf::Transformable::setRotation()'],['../classsf_1_1View.html#a24d0503c9c51f5ef5918612786d325c1',1,'sf::View::setRotation()']]], + ['setscale_55',['setScale',['../classsf_1_1Transformable.html#aaec50b46b3f41b054763304d1e727471',1,'sf::Transformable::setScale(float factorX, float factorY)'],['../classsf_1_1Transformable.html#a4c48a87f1626047e448f9c1a68ff167e',1,'sf::Transformable::setScale(const Vector2f &factors)']]], + ['setsize_56',['setSize',['../classsf_1_1RectangleShape.html#a5c65d374d4a259dfdc24efdd24a5dbec',1,'sf::RectangleShape::setSize()'],['../classsf_1_1View.html#a9525b73fe9fbaceb9568faf56b399dab',1,'sf::View::setSize(float width, float height)'],['../classsf_1_1View.html#a9e08d471ce21aa0e69ce55ff9de66d29',1,'sf::View::setSize(const Vector2f &size)'],['../classsf_1_1WindowBase.html#a7edca32bca3000d2e241dba720034bd6',1,'sf::WindowBase::setSize()']]], + ['setsmooth_57',['setSmooth',['../classsf_1_1Font.html#a77b66551a75fbaf2e831571535b774aa',1,'sf::Font::setSmooth()'],['../classsf_1_1RenderTexture.html#af08991e63c6020865dd07b20e27305b6',1,'sf::RenderTexture::setSmooth()'],['../classsf_1_1Texture.html#a0c3bd6825b9a99714f10d44179d74324',1,'sf::Texture::setSmooth(bool smooth)']]], + ['setsrgb_58',['setSrgb',['../classsf_1_1Texture.html#af8a38872c50a33ff074bd0865db19dd4',1,'sf::Texture']]], + ['setstring_59',['setString',['../classsf_1_1Text.html#a7d3b3359f286fd9503d1ced25b7b6c33',1,'sf::Text::setString()'],['../classsf_1_1Clipboard.html#a29c597c2165d3ca3a89c17f31ff7413d',1,'sf::Clipboard::setString()']]], + ['setstyle_60',['setStyle',['../classsf_1_1Text.html#ad791702bc2d1b6590a1719aa60635edf',1,'sf::Text']]], + ['settexture_61',['setTexture',['../classsf_1_1Shape.html#af8fb22bab1956325be5d62282711e3b6',1,'sf::Shape::setTexture()'],['../classsf_1_1Sprite.html#a3729c88d88ac38c19317c18e87242560',1,'sf::Sprite::setTexture()']]], + ['settexturerect_62',['setTextureRect',['../classsf_1_1Shape.html#a2029cc820d1740d14ac794b82525e157',1,'sf::Shape::setTextureRect()'],['../classsf_1_1Sprite.html#a3fefec419a4e6a90c0fd54c793d82ec2',1,'sf::Sprite::setTextureRect()']]], + ['settitle_63',['setTitle',['../classsf_1_1WindowBase.html#accd36ae6244ae1e6d643f6c109e983f8',1,'sf::WindowBase']]], + ['setuniform_64',['setUniform',['../classsf_1_1Shader.html#abf78e3bea1e9b0bab850b6b0a0de29c7',1,'sf::Shader::setUniform(const std::string &name, float x)'],['../classsf_1_1Shader.html#a4a2c673c41e37b17d67e4af1298b679f',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Vec2 &vector)'],['../classsf_1_1Shader.html#aad654ad8de6f0c56191fa7b8cea21db2',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Vec3 &vector)'],['../classsf_1_1Shader.html#abc1aee8343800680fd62e1f3d43c24bf',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Vec4 &vector)'],['../classsf_1_1Shader.html#ae4fc8b4c18e6b653952bce5c8c81e4a0',1,'sf::Shader::setUniform(const std::string &name, int x)'],['../classsf_1_1Shader.html#a2ccb5bae59cedc7d6a9b533c97f7d1ed',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Ivec2 &vector)'],['../classsf_1_1Shader.html#a9e328e3e97cd753fdc7b842f4b0f202e',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Ivec3 &vector)'],['../classsf_1_1Shader.html#a380e7a5a2896162c5fd08966c4523790',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Ivec4 &vector)'],['../classsf_1_1Shader.html#af417027ac72c06e6cfbf30975cd678e9',1,'sf::Shader::setUniform(const std::string &name, bool x)'],['../classsf_1_1Shader.html#ab2518b8dd0762e682b452a5d5005f2bf',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Bvec2 &vector)'],['../classsf_1_1Shader.html#ab06830875c82476fbb9c975cdeb78a11',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Bvec3 &vector)'],['../classsf_1_1Shader.html#ac8db3e0adf1129abf24f0a51a7ec36f4',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Bvec4 &vector)'],['../classsf_1_1Shader.html#ac1198ae0152d439bc05781046883e281',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Mat3 &matrix)'],['../classsf_1_1Shader.html#aca5c55c4a3b23d21e33dbdaab7990755',1,'sf::Shader::setUniform(const std::string &name, const Glsl::Mat4 &matrix)'],['../classsf_1_1Shader.html#a7806a29ffbd0ee9251256a9e7265d479',1,'sf::Shader::setUniform(const std::string &name, const Texture &texture)'],['../classsf_1_1Shader.html#ab18f531e1f726b88fec1cf5a1e6af26d',1,'sf::Shader::setUniform(const std::string &name, CurrentTextureType)']]], + ['setuniformarray_65',['setUniformArray',['../classsf_1_1Shader.html#a731d3b9953c50fe7d3fb03340b97deff',1,'sf::Shader::setUniformArray(const std::string &name, const float *scalarArray, std::size_t length)'],['../classsf_1_1Shader.html#ab2e2eab45d9a091f3720c0879a5bb026',1,'sf::Shader::setUniformArray(const std::string &name, const Glsl::Vec2 *vectorArray, std::size_t length)'],['../classsf_1_1Shader.html#aeae884292fed977bbea5039818f208e7',1,'sf::Shader::setUniformArray(const std::string &name, const Glsl::Vec3 *vectorArray, std::size_t length)'],['../classsf_1_1Shader.html#aa89ac1ea7918c9b1c2232df59affb7fa',1,'sf::Shader::setUniformArray(const std::string &name, const Glsl::Vec4 *vectorArray, std::size_t length)'],['../classsf_1_1Shader.html#a69587701d347ba21d506197d0fb9f842',1,'sf::Shader::setUniformArray(const std::string &name, const Glsl::Mat3 *matrixArray, std::size_t length)'],['../classsf_1_1Shader.html#a066b0ba02e1c1bddc9e2571eca1156ab',1,'sf::Shader::setUniformArray(const std::string &name, const Glsl::Mat4 *matrixArray, std::size_t length)']]], + ['setupvector_66',['setUpVector',['../classsf_1_1Listener.html#a0ea9b3083a994b2b90253543bc4e3ad6',1,'sf::Listener::setUpVector(float x, float y, float z)'],['../classsf_1_1Listener.html#a281e8cd44d3411d891b5e83b0cb6b9d4',1,'sf::Listener::setUpVector(const Vector3f &upVector)']]], + ['seturi_67',['setUri',['../classsf_1_1Http_1_1Request.html#a3723de4b4f1a14b744477841c4ac22e6',1,'sf::Http::Request']]], + ['setusage_68',['setUsage',['../classsf_1_1VertexBuffer.html#ace40070db1fccf12a025383b23e81cad',1,'sf::VertexBuffer']]], + ['setvalue_69',['setValue',['../classsf_1_1ThreadLocal.html#ab7e334c83d77644a8e67ee31c3230007',1,'sf::ThreadLocal']]], + ['setverticalsyncenabled_70',['setVerticalSyncEnabled',['../classsf_1_1Window.html#a59041c4556e0351048f8aff366034f61',1,'sf::Window']]], + ['setview_71',['setView',['../classsf_1_1RenderTarget.html#a063db6dd0a14913504af30e50cb6d946',1,'sf::RenderTarget']]], + ['setviewport_72',['setViewport',['../classsf_1_1View.html#a8eaec46b7d332fe834f016d0187d4b4a',1,'sf::View']]], + ['setvirtualkeyboardvisible_73',['setVirtualKeyboardVisible',['../classsf_1_1Keyboard.html#ad61fee7e793242d444a8c5acd662fe5b',1,'sf::Keyboard']]], + ['setvisible_74',['setVisible',['../classsf_1_1WindowBase.html#a576488ad202cb2cd4359af94eaba4dd8',1,'sf::WindowBase']]], + ['setvolume_75',['setVolume',['../classsf_1_1SoundSource.html#a2f192f2b49fb8e2b82f3498d3663fcc2',1,'sf::SoundSource']]], + ['shader_76',['Shader',['../classsf_1_1Shader.html#a1d7f28f26b4122959fcafec871c2c3c5',1,'sf::Shader']]], + ['shape_77',['Shape',['../classsf_1_1Shape.html#a413a457f720835b9f5d8e97ca8b80960',1,'sf::Shape']]], + ['sleep_78',['sleep',['../group__system.html#gab8c0d1f966b4e5110fd370b662d8c11b',1,'sf']]], + ['socket_79',['Socket',['../classsf_1_1Socket.html#a80ffb47ec0bafc83af019055d3e6a303',1,'sf::Socket']]], + ['socketselector_80',['SocketSelector',['../classsf_1_1SocketSelector.html#a741959c5158aeb1e4457cad47d90f76b',1,'sf::SocketSelector::SocketSelector()'],['../classsf_1_1SocketSelector.html#a50b1b955eb7ecb2e7c2764f3f4722fbf',1,'sf::SocketSelector::SocketSelector(const SocketSelector &copy)']]], + ['sound_81',['Sound',['../classsf_1_1Sound.html#a36ab74beaaa953d9879c933ddd246282',1,'sf::Sound::Sound()'],['../classsf_1_1Sound.html#a3b1cfc19a856d4ff8c079ee41bb78e69',1,'sf::Sound::Sound(const SoundBuffer &buffer)'],['../classsf_1_1Sound.html#ae05eeed6377932694d86b3011be366c0',1,'sf::Sound::Sound(const Sound &copy)']]], + ['soundbuffer_82',['SoundBuffer',['../classsf_1_1SoundBuffer.html#a0cabfbfe19b831bf7d5c9592d92ef233',1,'sf::SoundBuffer::SoundBuffer()'],['../classsf_1_1SoundBuffer.html#aaf000fc741ff27015907e8588263f4a6',1,'sf::SoundBuffer::SoundBuffer(const SoundBuffer &copy)']]], + ['soundrecorder_83',['SoundRecorder',['../classsf_1_1SoundRecorder.html#a50ebad413c4f157408a0fa49f23212a9',1,'sf::SoundRecorder']]], + ['soundsource_84',['SoundSource',['../classsf_1_1SoundSource.html#ae0c7728c1449fdebe65749ab6fcb3170',1,'sf::SoundSource::SoundSource(const SoundSource &copy)'],['../classsf_1_1SoundSource.html#aefa4bd4460f387d81a0637d293979436',1,'sf::SoundSource::SoundSource()']]], + ['soundstream_85',['SoundStream',['../classsf_1_1SoundStream.html#a769d08f4c3c6b4340ef3a838329d2e5c',1,'sf::SoundStream']]], + ['span_86',['Span',['../structsf_1_1Music_1_1Span.html#a935db12207fa3da4c2461cd5e1f9fa0d',1,'sf::Music::Span::Span(T off, T len)'],['../structsf_1_1Music_1_1Span.html#a71e6200a586f650ce002e7e99929ae85',1,'sf::Music::Span::Span()']]], + ['sprite_87',['Sprite',['../classsf_1_1Sprite.html#a2a9fca374d7abf084bb1c143a879ff4a',1,'sf::Sprite::Sprite(const Texture &texture)'],['../classsf_1_1Sprite.html#a01cfe1402372d243dbaa2ffa96020206',1,'sf::Sprite::Sprite(const Texture &texture, const IntRect &rectangle)'],['../classsf_1_1Sprite.html#a92559fbca895a96758abf5eabab96984',1,'sf::Sprite::Sprite()']]], + ['start_88',['start',['../classsf_1_1SoundRecorder.html#a715f0fd2f228c83d79aaedca562ae51f',1,'sf::SoundRecorder']]], + ['stop_89',['stop',['../classsf_1_1Sound.html#aa9c91c34f7c6d344d5ee9b997511f754',1,'sf::Sound::stop()'],['../classsf_1_1SoundRecorder.html#a8d9c8346aa9aa409cfed4a1101159c4c',1,'sf::SoundRecorder::stop()'],['../classsf_1_1SoundSource.html#a06501a25b12376befcc7ee1ed4865fda',1,'sf::SoundSource::stop()'],['../classsf_1_1SoundStream.html#a16cc6a0404b32e42c4dce184bb94d0f4',1,'sf::SoundStream::stop()']]], + ['string_90',['String',['../classsf_1_1String.html#a9563a4e93f692e0c8e8702b374ef8692',1,'sf::String::String()'],['../classsf_1_1String.html#ac9df7f7696cff164794e338f3c89ccc5',1,'sf::String::String(char ansiChar, const std::locale &locale=std::locale())'],['../classsf_1_1String.html#a8e1a5027416d121187908e2ed77079ff',1,'sf::String::String(Uint32 utf32Char)'],['../classsf_1_1String.html#a57d2b8c289f9894f859564cad034bfc7',1,'sf::String::String(const char *ansiString, const std::locale &locale=std::locale())'],['../classsf_1_1String.html#a0aa41dcbd17b0c36c74d03d3b0147f1e',1,'sf::String::String(const std::string &ansiString, const std::locale &locale=std::locale())'],['../classsf_1_1String.html#a5742d0a9b0c754f711820c2b5c40fa55',1,'sf::String::String(const wchar_t *wideString)'],['../classsf_1_1String.html#a5e38151340af4f9a5f74ad24c0664074',1,'sf::String::String(const std::wstring &wideString)'],['../classsf_1_1String.html#aea3629adf19f9fe713d4946f6c75b214',1,'sf::String::String(const Uint32 *utf32String)'],['../classsf_1_1String.html#a6eee86dbe75d16bbcc26e97416c2e1ca',1,'sf::String::String(const std::basic_string< Uint32 > &utf32String)'],['../classsf_1_1String.html#af862594d3c4070d8ddbf08cf8dce4f59',1,'sf::String::String(const String &copy)'],['../classsf_1_1String.html#aefaa202d2aa5ff85b4f75a5983367e86',1,'sf::String::String(wchar_t wideChar)']]], + ['substring_91',['substring',['../classsf_1_1String.html#a492645e00032455e6d92ff0e992654ce',1,'sf::String']]], + ['swap_92',['swap',['../classsf_1_1Texture.html#a9243470c64b7ff0d231e00663e495798',1,'sf::Texture::swap()'],['../classsf_1_1VertexBuffer.html#a3954d696848dc4c921c15a6b4459c8e6',1,'sf::VertexBuffer::swap()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_11.js b/Space-Invaders/sfml/doc/html/search/functions_11.js new file mode 100644 index 000000000..36019eb01 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_11.js @@ -0,0 +1,29 @@ +var searchData= +[ + ['tcplistener_0',['TcpListener',['../classsf_1_1TcpListener.html#a59a1db5b6f4711a3e57390da2f8d9630',1,'sf::TcpListener']]], + ['tcpsocket_1',['TcpSocket',['../classsf_1_1TcpSocket.html#a62a9bf81fd7f15fedb29fd1348483236',1,'sf::TcpSocket']]], + ['tell_2',['tell',['../classsf_1_1FileInputStream.html#a768c5fdb3be79e2d71d1bce911f8741c',1,'sf::FileInputStream::tell()'],['../classsf_1_1InputStream.html#a599515b9ccdbddb6fef5a98424fd559c',1,'sf::InputStream::tell()'],['../classsf_1_1MemoryInputStream.html#a7ad4bdf721f29de8f66421ff29e23ee4',1,'sf::MemoryInputStream::tell()']]], + ['terminate_3',['terminate',['../classsf_1_1Thread.html#ad6b205d4f1ce38b8d44bba0f5501477c',1,'sf::Thread']]], + ['text_4',['Text',['../classsf_1_1Text.html#aff7cab6a92e5948c9d1481cb2d87eb84',1,'sf::Text::Text()'],['../classsf_1_1Text.html#a614019e0b5c0ed39a99d32483a51f2c5',1,'sf::Text::Text(const String &string, const Font &font, unsigned int characterSize=30)']]], + ['texture_5',['Texture',['../classsf_1_1Texture.html#a3e04674853b8533bf981db3173e3a4a7',1,'sf::Texture::Texture()'],['../classsf_1_1Texture.html#a524855cbf89de3b74be84d385fd229de',1,'sf::Texture::Texture(const Texture &copy)']]], + ['thread_6',['Thread',['../classsf_1_1Thread.html#a4cc65399bbb111cf8132537783b8e96c',1,'sf::Thread::Thread(F function)'],['../classsf_1_1Thread.html#a719b2cc067d92d52c35064a49d850a53',1,'sf::Thread::Thread(F function, A argument)'],['../classsf_1_1Thread.html#aa9f473c8cbb078900c62b1fd14a83a34',1,'sf::Thread::Thread(void(C::*function)(), C *object)']]], + ['threadlocal_7',['ThreadLocal',['../classsf_1_1ThreadLocal.html#a44ea3c4be4eef118080275cbf4cf04cd',1,'sf::ThreadLocal']]], + ['threadlocalptr_8',['ThreadLocalPtr',['../classsf_1_1ThreadLocalPtr.html#a8c678211d7828d2a8c41cb534422d649',1,'sf::ThreadLocalPtr']]], + ['time_9',['Time',['../classsf_1_1Time.html#acba0cfbc49e3a09a22a8e079eb67a05c',1,'sf::Time']]], + ['toansi_10',['toAnsi',['../classsf_1_1Utf_3_018_01_4.html#a3d8b02f29021bd48831e7706d826f0c5',1,'sf::Utf< 8 >::toAnsi()'],['../classsf_1_1Utf_3_0116_01_4.html#a6d2bfbdfe46364bd49bca28a410b18f7',1,'sf::Utf< 16 >::toAnsi()'],['../classsf_1_1Utf_3_0132_01_4.html#a768cb205f7f1d20cd900e34fb48f9316',1,'sf::Utf< 32 >::toAnsi()']]], + ['toansistring_11',['toAnsiString',['../classsf_1_1String.html#ada5d5bba4528aceb0a1e298553e6c30a',1,'sf::String']]], + ['tointeger_12',['toInteger',['../classsf_1_1Color.html#abb46e6942c4fe0d221574a46e642caa9',1,'sf::Color::toInteger()'],['../classsf_1_1IpAddress.html#ae7911c5ea9562f9602c3e29cd54b15e9',1,'sf::IpAddress::toInteger()']]], + ['tolatin1_13',['toLatin1',['../classsf_1_1Utf_3_018_01_4.html#adf6f6e0a8ee0527c8ab390ce5c0b6b13',1,'sf::Utf< 8 >::toLatin1()'],['../classsf_1_1Utf_3_0116_01_4.html#ad0cc57ebf48fac584f4d5f3d30a20010',1,'sf::Utf< 16 >::toLatin1()'],['../classsf_1_1Utf_3_0132_01_4.html#a064ce0ad81768d0d99b6b3e2e980e3ce',1,'sf::Utf< 32 >::toLatin1()']]], + ['tostring_14',['toString',['../classsf_1_1IpAddress.html#a88507954142d7fc2176cce7f36422340',1,'sf::IpAddress']]], + ['toutf16_15',['toUtf16',['../classsf_1_1String.html#ab805f230a0b2e972f9f32ac4cf11d912',1,'sf::String::toUtf16()'],['../classsf_1_1Utf_3_018_01_4.html#a925ac9e141dcb6f9b07c7b95f7cfbda2',1,'sf::Utf< 8 >::toUtf16()'],['../classsf_1_1Utf_3_0116_01_4.html#a0c9744c8f142360a8afebb24da134b34',1,'sf::Utf< 16 >::toUtf16()'],['../classsf_1_1Utf_3_0132_01_4.html#a3f97efb599ad237af06f076f3fcfa354',1,'sf::Utf< 32 >::toUtf16()']]], + ['toutf32_16',['toUtf32',['../classsf_1_1String.html#aef4f51ebe43465c665c78692d0262e43',1,'sf::String::toUtf32()'],['../classsf_1_1Utf_3_018_01_4.html#a79395429baba13dd04a8c1fba745ce65',1,'sf::Utf< 8 >::toUtf32()'],['../classsf_1_1Utf_3_0116_01_4.html#a781174f776a3effb96c1ccd9a4513ab1',1,'sf::Utf< 16 >::toUtf32()'],['../classsf_1_1Utf_3_0132_01_4.html#abd7c1e80791c80c4d78257440de96140',1,'sf::Utf< 32 >::toUtf32()']]], + ['toutf8_17',['toUtf8',['../classsf_1_1String.html#a2a4f366d5db833ae818881507b46e13a',1,'sf::String::toUtf8()'],['../classsf_1_1Utf_3_018_01_4.html#aef68054cab6a592c0b04de94e93bb520',1,'sf::Utf< 8 >::toUtf8()'],['../classsf_1_1Utf_3_0116_01_4.html#afdd2f31536ce3fba4dfb632dfdd6e4b7',1,'sf::Utf< 16 >::toUtf8()'],['../classsf_1_1Utf_3_0132_01_4.html#a193e155964b073c8ba838434f41d5e97',1,'sf::Utf< 32 >::toUtf8()']]], + ['towide_18',['toWide',['../classsf_1_1Utf_3_018_01_4.html#ac6633c64ff1fad6bd1bfe72c37b3a468',1,'sf::Utf< 8 >::toWide()'],['../classsf_1_1Utf_3_0116_01_4.html#a42bace5988f7f20497cfdd6025c2d7f2',1,'sf::Utf< 16 >::toWide()'],['../classsf_1_1Utf_3_0132_01_4.html#a0d5bf45a9732beb935592da6bed1242c',1,'sf::Utf< 32 >::toWide()']]], + ['towidestring_19',['toWideString',['../classsf_1_1String.html#a9d81aa3103e7e2062bd85d912a5aecf1',1,'sf::String']]], + ['transform_20',['Transform',['../classsf_1_1Transform.html#ac32de51bd0b9f3d52fbe0838225ee83b',1,'sf::Transform::Transform()'],['../classsf_1_1Transform.html#a78c48677712fcf41122d02f1301d71a3',1,'sf::Transform::Transform(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22)']]], + ['transformable_21',['Transformable',['../classsf_1_1Transformable.html#ae71710de0fef423121bab1c684954a2e',1,'sf::Transformable']]], + ['transformpoint_22',['transformPoint',['../classsf_1_1Transform.html#af2e38c3c077d28898686662558b41135',1,'sf::Transform::transformPoint(float x, float y) const'],['../classsf_1_1Transform.html#ab42a0bb7a252c6d221004f6372ce5fdc',1,'sf::Transform::transformPoint(const Vector2f &point) const']]], + ['transformrect_23',['transformRect',['../classsf_1_1Transform.html#a3824a20505d81a94bc22be1ffee57d3d',1,'sf::Transform']]], + ['transientcontextlock_24',['TransientContextLock',['../classsf_1_1GlResource_1_1TransientContextLock.html#a6434ee8f0380c300b361be038f37123a',1,'sf::GlResource::TransientContextLock']]], + ['translate_25',['translate',['../classsf_1_1Transform.html#a053cd024e320ae719837386d126d0f51',1,'sf::Transform::translate(float x, float y)'],['../classsf_1_1Transform.html#a2426209f1fd3cc02129dec373a3c6f69',1,'sf::Transform::translate(const Vector2f &offset)']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_12.js b/Space-Invaders/sfml/doc/html/search/functions_12.js new file mode 100644 index 000000000..c60b6ce70 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_12.js @@ -0,0 +1,10 @@ +var searchData= +[ + ['udpsocket_0',['UdpSocket',['../classsf_1_1UdpSocket.html#abb10725e26dee9d3a8165fe87ffb71bb',1,'sf::UdpSocket']]], + ['unbind_1',['unbind',['../classsf_1_1UdpSocket.html#a2c4abb8102a1bd31f51fcfe7f15427a3',1,'sf::UdpSocket']]], + ['unlock_2',['unlock',['../classsf_1_1Mutex.html#ade71268ffc5e80756652058b01c23c33',1,'sf::Mutex']]], + ['unregisterreader_3',['unregisterReader',['../classsf_1_1SoundFileFactory.html#ac42f01faf678d1f410e1ce8a18e4cebb',1,'sf::SoundFileFactory']]], + ['unregisterwriter_4',['unregisterWriter',['../classsf_1_1SoundFileFactory.html#a1bd8ebd264a5ec33962a9f7a8ca21a60',1,'sf::SoundFileFactory']]], + ['update_5',['update',['../classsf_1_1Shape.html#adfb2bd966c8edbc5d6c92ebc375e4ac1',1,'sf::Shape::update()'],['../classsf_1_1Texture.html#ae4eab5c6781316840b0c50ad08370963',1,'sf::Texture::update(const Uint8 *pixels)'],['../classsf_1_1Texture.html#a1352d8e16c2aeb4df586ed65dd2c36b9',1,'sf::Texture::update(const Uint8 *pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y)'],['../classsf_1_1Texture.html#af9885ca00b74950d60feea28132d9691',1,'sf::Texture::update(const Texture &texture)'],['../classsf_1_1Texture.html#a89beb474da1da84b5e38c9fc0b441fe4',1,'sf::Texture::update(const Texture &texture, unsigned int x, unsigned int y)'],['../classsf_1_1Texture.html#a037cdf171af0fb392d07626a44a4ea17',1,'sf::Texture::update(const Image &image)'],['../classsf_1_1Texture.html#a87f916490b757fe900798eedf3abf3ba',1,'sf::Texture::update(const Image &image, unsigned int x, unsigned int y)'],['../classsf_1_1Texture.html#ad3cceef238f7d5d2108a98dd38c17fc5',1,'sf::Texture::update(const Window &window)'],['../classsf_1_1Texture.html#a154f246eb8059b602076009ab1cfd175',1,'sf::Texture::update(const Window &window, unsigned int x, unsigned int y)'],['../classsf_1_1VertexBuffer.html#ad100a5f578a91c49a9009e3c6956c82d',1,'sf::VertexBuffer::update(const Vertex *vertices)'],['../classsf_1_1VertexBuffer.html#ae6c8649a64861507010d21e77fbd53fa',1,'sf::VertexBuffer::update(const Vertex *vertices, std::size_t vertexCount, unsigned int offset)'],['../classsf_1_1VertexBuffer.html#a41f8bbcf07f403e7fe29b1b905dc7544',1,'sf::VertexBuffer::update(const VertexBuffer &vertexBuffer)'],['../classsf_1_1Joystick.html#ab85fa9175b4edd3e5a07ee3cde0b0f48',1,'sf::Joystick::update()']]], + ['upload_6',['upload',['../classsf_1_1Ftp.html#a0402d2cec27a197ffba34c88ffaddeac',1,'sf::Ftp']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_13.js b/Space-Invaders/sfml/doc/html/search/functions_13.js new file mode 100644 index 000000000..e9ceba2c8 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_13.js @@ -0,0 +1,10 @@ +var searchData= +[ + ['vector2_0',['Vector2',['../classsf_1_1Vector2.html#a58c32383b5291380db4b43a289f75988',1,'sf::Vector2::Vector2()'],['../classsf_1_1Vector2.html#aed26a72164e59e8a4a0aeee2049568f1',1,'sf::Vector2::Vector2(T X, T Y)'],['../classsf_1_1Vector2.html#a3da455e0ae3f8ff6d2fe36d10b332d10',1,'sf::Vector2::Vector2(const Vector2< U > &vector)']]], + ['vector3_1',['Vector3',['../classsf_1_1Vector3.html#aee8be1985c6e45e381ad4071265636f9',1,'sf::Vector3::Vector3()'],['../classsf_1_1Vector3.html#a99ed75b68f58adfa3e9fa0561b424bf6',1,'sf::Vector3::Vector3(T X, T Y, T Z)'],['../classsf_1_1Vector3.html#adb2b2e150025e97ccfa96219bbed59d1',1,'sf::Vector3::Vector3(const Vector3< U > &vector)']]], + ['vertex_2',['Vertex',['../classsf_1_1Vertex.html#a6b4c79cd69f7ec1296fede536f39e9c8',1,'sf::Vertex::Vertex()'],['../classsf_1_1Vertex.html#a4dccc5c351b73b6fac169fe442535b40',1,'sf::Vertex::Vertex(const Vector2f &thePosition)'],['../classsf_1_1Vertex.html#a70b0679b4ec531d5bd1a7d0225c7321a',1,'sf::Vertex::Vertex(const Vector2f &thePosition, const Color &theColor)'],['../classsf_1_1Vertex.html#ab9bf849c4c0d82d09bf5bece23d2456a',1,'sf::Vertex::Vertex(const Vector2f &thePosition, const Vector2f &theTexCoords)'],['../classsf_1_1Vertex.html#ad5943f2b3cbc64b6e714bb37ccaf4960',1,'sf::Vertex::Vertex(const Vector2f &thePosition, const Color &theColor, const Vector2f &theTexCoords)']]], + ['vertexarray_3',['VertexArray',['../classsf_1_1VertexArray.html#a15729e01df8fc0021f9774dfb56295c1',1,'sf::VertexArray::VertexArray()'],['../classsf_1_1VertexArray.html#a4bb1c29a0e3354a035075899d84f02f9',1,'sf::VertexArray::VertexArray(PrimitiveType type, std::size_t vertexCount=0)']]], + ['vertexbuffer_4',['VertexBuffer',['../classsf_1_1VertexBuffer.html#aba8836c571cef25a0f80e478add1560a',1,'sf::VertexBuffer::VertexBuffer()'],['../classsf_1_1VertexBuffer.html#a3f51dcd61dac52be54ba7b22ebdea7c8',1,'sf::VertexBuffer::VertexBuffer(PrimitiveType type)'],['../classsf_1_1VertexBuffer.html#af2dce0a43e061e5f91b97cf7267427e3',1,'sf::VertexBuffer::VertexBuffer(Usage usage)'],['../classsf_1_1VertexBuffer.html#a326a5c89f1ba01b51b323535494434e8',1,'sf::VertexBuffer::VertexBuffer(PrimitiveType type, Usage usage)'],['../classsf_1_1VertexBuffer.html#a2f2ff1e218cfc749b87f8873e23c016b',1,'sf::VertexBuffer::VertexBuffer(const VertexBuffer &copy)']]], + ['videomode_5',['VideoMode',['../classsf_1_1VideoMode.html#a04c9417e5c304510bef5f6aeb03f6ce1',1,'sf::VideoMode::VideoMode()'],['../classsf_1_1VideoMode.html#a46c35ed41de9e115661dcd529d64e9d3',1,'sf::VideoMode::VideoMode(unsigned int modeWidth, unsigned int modeHeight, unsigned int modeBitsPerPixel=32)']]], + ['view_6',['View',['../classsf_1_1View.html#a28c38308ff089ae5bdacd001d12286d3',1,'sf::View::View()'],['../classsf_1_1View.html#a1d63bc49e041b3b1ff992bb6430e1326',1,'sf::View::View(const FloatRect &rectangle)'],['../classsf_1_1View.html#afdaf84cfc910ef160450d63603457ea4',1,'sf::View::View(const Vector2f &center, const Vector2f &size)']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_14.js b/Space-Invaders/sfml/doc/html/search/functions_14.js new file mode 100644 index 000000000..6148d190f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_14.js @@ -0,0 +1,8 @@ +var searchData= +[ + ['wait_0',['wait',['../classsf_1_1SocketSelector.html#a9cfda5475f17925e65889394d70af702',1,'sf::SocketSelector::wait()'],['../classsf_1_1Thread.html#a724b1f94c2d54f84280f2f78bde95fa0',1,'sf::Thread::wait()']]], + ['waitevent_1',['waitEvent',['../classsf_1_1WindowBase.html#aa1c100a69b5bc0c84e23a4652d51ac41',1,'sf::WindowBase']]], + ['window_2',['Window',['../classsf_1_1Window.html#a5359122166b4dc492c3d25caf08ccfc4',1,'sf::Window::Window()'],['../classsf_1_1Window.html#a1bee771baecbae6d357871929dc042a2',1,'sf::Window::Window(VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())'],['../classsf_1_1Window.html#a6d60912633bff9d33cf3ade4e0201de4',1,'sf::Window::Window(WindowHandle handle, const ContextSettings &settings=ContextSettings())']]], + ['windowbase_3',['WindowBase',['../classsf_1_1WindowBase.html#a0cfe9d015cc95b89ef862c8d8050a964',1,'sf::WindowBase::WindowBase()'],['../classsf_1_1WindowBase.html#ab150dbdb19eead86bcecb42cf3609e63',1,'sf::WindowBase::WindowBase(VideoMode mode, const String &title, Uint32 style=Style::Default)'],['../classsf_1_1WindowBase.html#ab4e3667dddddfeda57d124de24f93ac1',1,'sf::WindowBase::WindowBase(WindowHandle handle)']]], + ['write_4',['write',['../classsf_1_1OutputSoundFile.html#adfcf525fced71121f336fa89faac3d67',1,'sf::OutputSoundFile::write()'],['../classsf_1_1SoundFileWriter.html#a4ce597e7682d22c5b2c98d77e931a1da',1,'sf::SoundFileWriter::write()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_15.js b/Space-Invaders/sfml/doc/html/search/functions_15.js new file mode 100644 index 000000000..dfeb92b33 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_15.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['zoom_0',['zoom',['../classsf_1_1View.html#a4a72a360a5792fbe4e99cd6feaf7726e',1,'sf::View']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_16.js b/Space-Invaders/sfml/doc/html/search/functions_16.js new file mode 100644 index 000000000..09913740f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_16.js @@ -0,0 +1,43 @@ +var searchData= +[ + ['_7ealresource_0',['~AlResource',['../classsf_1_1AlResource.html#a74ad78198cddcb6e5d847177364049db',1,'sf::AlResource']]], + ['_7econtext_1',['~Context',['../classsf_1_1Context.html#a805b1bbdb3e52b1fda7c9bf2cd6ca86b',1,'sf::Context']]], + ['_7ecursor_2',['~Cursor',['../classsf_1_1Cursor.html#a777ba6a1d0d68f8eb9dc85976a5b9727',1,'sf::Cursor']]], + ['_7edrawable_3',['~Drawable',['../classsf_1_1Drawable.html#a906002f2df7beb5edbddf5bbef96f120',1,'sf::Drawable']]], + ['_7efileinputstream_4',['~FileInputStream',['../classsf_1_1FileInputStream.html#ad49ae2025ff2183f80067943a7d0276d',1,'sf::FileInputStream']]], + ['_7efont_5',['~Font',['../classsf_1_1Font.html#aa18a3c62e6e01e9a21c531b5cad4b7f2',1,'sf::Font']]], + ['_7eftp_6',['~Ftp',['../classsf_1_1Ftp.html#a2edfa8e9009caf27bce74459ae76dc52',1,'sf::Ftp']]], + ['_7eglresource_7',['~GlResource',['../classsf_1_1GlResource.html#ab99035b67052331d1e8cf67abd93de98',1,'sf::GlResource']]], + ['_7eimage_8',['~Image',['../classsf_1_1Image.html#a0ba22a38e6c96e3b37dd88198046de83',1,'sf::Image']]], + ['_7einputsoundfile_9',['~InputSoundFile',['../classsf_1_1InputSoundFile.html#a326a1a486587038123de0c187bf5c635',1,'sf::InputSoundFile']]], + ['_7einputstream_10',['~InputStream',['../classsf_1_1InputStream.html#a4b2eb0f92323e630bd0542bc6191682e',1,'sf::InputStream']]], + ['_7elock_11',['~Lock',['../classsf_1_1Lock.html#a8168b36323a18ccf5b6bc531d964aec5',1,'sf::Lock']]], + ['_7emusic_12',['~Music',['../classsf_1_1Music.html#a4c65860fed2f01d0eaa6c4199870414b',1,'sf::Music']]], + ['_7emutex_13',['~Mutex',['../classsf_1_1Mutex.html#a9f76a67b7b6d3918131a692179b4e3f2',1,'sf::Mutex']]], + ['_7enoncopyable_14',['~NonCopyable',['../classsf_1_1NonCopyable.html#a8274ffbf46014f5f7f364befb52c7728',1,'sf::NonCopyable']]], + ['_7eoutputsoundfile_15',['~OutputSoundFile',['../classsf_1_1OutputSoundFile.html#a1492adbfef1f391d720afb56f068182e',1,'sf::OutputSoundFile']]], + ['_7epacket_16',['~Packet',['../classsf_1_1Packet.html#adc0490ca3c7c3d1e321bd742e5213913',1,'sf::Packet']]], + ['_7erendertarget_17',['~RenderTarget',['../classsf_1_1RenderTarget.html#a9abd1654a99fba46f6887b9c625b9b06',1,'sf::RenderTarget']]], + ['_7erendertexture_18',['~RenderTexture',['../classsf_1_1RenderTexture.html#a94b84ab9335be84d2a014c964d973304',1,'sf::RenderTexture']]], + ['_7erenderwindow_19',['~RenderWindow',['../classsf_1_1RenderWindow.html#a3407e36bfc1752d723140438a825365c',1,'sf::RenderWindow']]], + ['_7eshader_20',['~Shader',['../classsf_1_1Shader.html#a4bac6cc8b046ecd8fb967c145a2380e6',1,'sf::Shader']]], + ['_7eshape_21',['~Shape',['../classsf_1_1Shape.html#a2262aceb9df52d4275c19633592f19bf',1,'sf::Shape']]], + ['_7esocket_22',['~Socket',['../classsf_1_1Socket.html#a79a4b5918f0b34a2f8db449089694788',1,'sf::Socket']]], + ['_7esocketselector_23',['~SocketSelector',['../classsf_1_1SocketSelector.html#a9069cd61208260b8ed9cf233afa1f73d',1,'sf::SocketSelector']]], + ['_7esound_24',['~Sound',['../classsf_1_1Sound.html#ad0792c35310eba2dffd8489c80fad076',1,'sf::Sound']]], + ['_7esoundbuffer_25',['~SoundBuffer',['../classsf_1_1SoundBuffer.html#aea240161724ffba74a0d6a9e277d3cd5',1,'sf::SoundBuffer']]], + ['_7esoundbufferrecorder_26',['~SoundBufferRecorder',['../classsf_1_1SoundBufferRecorder.html#a350f7f885ccfd12b4c6c120c23695637',1,'sf::SoundBufferRecorder']]], + ['_7esoundfilereader_27',['~SoundFileReader',['../classsf_1_1SoundFileReader.html#a34163297f302d15818c76b54f815acc8',1,'sf::SoundFileReader']]], + ['_7esoundfilewriter_28',['~SoundFileWriter',['../classsf_1_1SoundFileWriter.html#a76944fc158688f35050bd5b592c90270',1,'sf::SoundFileWriter']]], + ['_7esoundrecorder_29',['~SoundRecorder',['../classsf_1_1SoundRecorder.html#acc599e61aaa47edaae88cf43f0a43549',1,'sf::SoundRecorder']]], + ['_7esoundsource_30',['~SoundSource',['../classsf_1_1SoundSource.html#a77c7c1524f8cb81df2de9375b0f87c5c',1,'sf::SoundSource']]], + ['_7esoundstream_31',['~SoundStream',['../classsf_1_1SoundStream.html#a1fafb9f1ca572d23d7d6a17921860d85',1,'sf::SoundStream']]], + ['_7etexture_32',['~Texture',['../classsf_1_1Texture.html#a9c5354ad40eb1c5aeeeb21f57ccd7e6c',1,'sf::Texture']]], + ['_7ethread_33',['~Thread',['../classsf_1_1Thread.html#af77942fc1730af7c31bc4c3a913a9c1d',1,'sf::Thread']]], + ['_7ethreadlocal_34',['~ThreadLocal',['../classsf_1_1ThreadLocal.html#acc612bddfd0f0507b1c5da8b3b8c75c2',1,'sf::ThreadLocal']]], + ['_7etransformable_35',['~Transformable',['../classsf_1_1Transformable.html#a43253abcb863195a673c2a347a7425cc',1,'sf::Transformable']]], + ['_7etransientcontextlock_36',['~TransientContextLock',['../classsf_1_1GlResource_1_1TransientContextLock.html#a169285281b252ac8d54523b0fcc4b814',1,'sf::GlResource::TransientContextLock']]], + ['_7evertexbuffer_37',['~VertexBuffer',['../classsf_1_1VertexBuffer.html#acfbb3b16221bfb9406fcaa18cfcac3e7',1,'sf::VertexBuffer']]], + ['_7ewindow_38',['~Window',['../classsf_1_1Window.html#ac30eb6ea5f5594204944d09d4bd69a97',1,'sf::Window']]], + ['_7ewindowbase_39',['~WindowBase',['../classsf_1_1WindowBase.html#a7aac2a828b6bbd39b7195bb0545a2c47',1,'sf::WindowBase']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_2.js b/Space-Invaders/sfml/doc/html/search/functions_2.js new file mode 100644 index 000000000..cee911cce --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_2.js @@ -0,0 +1,28 @@ +var searchData= +[ + ['capture_0',['capture',['../classsf_1_1RenderWindow.html#a5a784b8a09bf4a8bc97ef9e0a8957c35',1,'sf::RenderWindow']]], + ['changedirectory_1',['changeDirectory',['../classsf_1_1Ftp.html#a7e93488ea6330dd4dd76e428da9bb6d3',1,'sf::Ftp']]], + ['circleshape_2',['CircleShape',['../classsf_1_1CircleShape.html#aaebe705e7180cd55588eb19488af3af1',1,'sf::CircleShape']]], + ['clear_3',['clear',['../classsf_1_1RenderTarget.html#a6bb6f0ba348f2b1e2f46114aeaf60f26',1,'sf::RenderTarget::clear()'],['../classsf_1_1VertexArray.html#a3654c424aca1f9e468f369bc777c839c',1,'sf::VertexArray::clear()'],['../classsf_1_1Packet.html#a133ea8b8fe6e93c230f0d79f19a3bf0d',1,'sf::Packet::clear()'],['../classsf_1_1SocketSelector.html#a76e650acb0199d4be91e90a493fbc91a',1,'sf::SocketSelector::clear()'],['../classsf_1_1String.html#a391c1b4950cbf3d3f8040cea73af2969',1,'sf::String::clear()']]], + ['clock_4',['Clock',['../classsf_1_1Clock.html#abbc959c7830ca7c3a4da133cb506d3fd',1,'sf::Clock']]], + ['close_5',['close',['../classsf_1_1InputSoundFile.html#ad28182aea9dc9f7d0dfc7f78691825b4',1,'sf::InputSoundFile::close()'],['../classsf_1_1OutputSoundFile.html#ad20c867d7e565d533da029f31ea5a337',1,'sf::OutputSoundFile::close()'],['../classsf_1_1Socket.html#a71f2f5c2aa99e01cafe824fee4c573be',1,'sf::Socket::close()'],['../classsf_1_1TcpListener.html#a3a00a850506bd0f9f48867a0fe59556b',1,'sf::TcpListener::close()'],['../classsf_1_1Window.html#a7355b916852af56cfe3cc00feed9f419',1,'sf::Window::close()'],['../classsf_1_1WindowBase.html#a9a5ea0ba0ab584dbd11bbfea233b457f',1,'sf::WindowBase::close()']]], + ['color_6',['Color',['../classsf_1_1Color.html#ac2eb4393fb11ad3fa3ccf34e92fe08e4',1,'sf::Color::Color()'],['../classsf_1_1Color.html#ac791dc61be4c60baac50fe700f1c9850',1,'sf::Color::Color(Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha=255)'],['../classsf_1_1Color.html#a5449f4b2b9a78230d40ce2c223c9ab2e',1,'sf::Color::Color(Uint32 color)']]], + ['combine_7',['combine',['../classsf_1_1Transform.html#ad8403f888799b5c9f781cb9f3757f2a4',1,'sf::Transform']]], + ['connect_8',['connect',['../classsf_1_1Ftp.html#af02fb3de3f450a50a27981961c69c860',1,'sf::Ftp::connect()'],['../classsf_1_1TcpSocket.html#a68cd42d5ab70ab54b16787f555951c40',1,'sf::TcpSocket::connect()']]], + ['contains_9',['contains',['../classsf_1_1Rect.html#a910b998c92756157e1407e1363f93212',1,'sf::Rect::contains(T x, T y) const'],['../classsf_1_1Rect.html#a45c77c073a7a4d9232218ab2838f41bb',1,'sf::Rect::contains(const Vector2< T > &point) const']]], + ['context_10',['Context',['../classsf_1_1Context.html#aba22797a790706ca2c5c04ee39f2b555',1,'sf::Context::Context()'],['../classsf_1_1Context.html#a2a9e3529e48919120e6b6fc10bad296c',1,'sf::Context::Context(const ContextSettings &settings, unsigned int width, unsigned int height)']]], + ['contextsettings_11',['ContextSettings',['../structsf_1_1ContextSettings.html#ac56869ccbb6bf0df48b88880754e12b7',1,'sf::ContextSettings']]], + ['convexshape_12',['ConvexShape',['../classsf_1_1ConvexShape.html#af9981b8909569b381b3fccf32fc69856',1,'sf::ConvexShape']]], + ['copy_13',['copy',['../classsf_1_1Image.html#ab2fa337c956f85f93377dcb52153a45a',1,'sf::Image']]], + ['copytoimage_14',['copyToImage',['../classsf_1_1Texture.html#a77e18a70de2e525ac5e4a7cd95f614b9',1,'sf::Texture']]], + ['count_15',['count',['../classsf_1_1Utf_3_018_01_4.html#af1f15d9a772ee887be39e97431e15d32',1,'sf::Utf< 8 >::count()'],['../classsf_1_1Utf_3_0116_01_4.html#a6df8d9be8211ffe1095b3b82eac83f6f',1,'sf::Utf< 16 >::count()'],['../classsf_1_1Utf_3_0132_01_4.html#a9b18c32b9e6d4b3126e9b4af45988b55',1,'sf::Utf< 32 >::count()']]], + ['create_16',['create',['../classsf_1_1Image.html#a2a67930e2fd9ad97cf004e918cf5832b',1,'sf::Image::create(unsigned int width, unsigned int height, const Color &color=Color(0, 0, 0))'],['../classsf_1_1Image.html#a1c2b960ea12bdbb29e80934ce5268ebf',1,'sf::Image::create(unsigned int width, unsigned int height, const Uint8 *pixels)'],['../classsf_1_1RenderTexture.html#a0e945c4ce7703591c7f240b169744603',1,'sf::RenderTexture::create(unsigned int width, unsigned int height, bool depthBuffer)'],['../classsf_1_1RenderTexture.html#a49b7b723a80f89bc409a942364351dc3',1,'sf::RenderTexture::create(unsigned int width, unsigned int height, const ContextSettings &settings=ContextSettings())'],['../classsf_1_1Texture.html#a89b4c7d204acf1033c3a1b6e0a3ad0a3',1,'sf::Texture::create()'],['../classsf_1_1VertexBuffer.html#aa68e128d59c7f7d5eb0d4d94125439a5',1,'sf::VertexBuffer::create()'],['../classsf_1_1Socket.html#aafbe140f4b1921e0d19e88cf7a61dcbc',1,'sf::Socket::create()'],['../classsf_1_1Socket.html#af1dd898f7aa3ead7ff7b2d1c20e97781',1,'sf::Socket::create(SocketHandle handle)'],['../classsf_1_1Window.html#ac6a58d9c26a18f0e70888d0f53e154c1',1,'sf::Window::create(VideoMode mode, const String &title, Uint32 style=Style::Default)'],['../classsf_1_1Window.html#a6518b989614750e90d9784f4d05ce02c',1,'sf::Window::create(VideoMode mode, const String &title, Uint32 style, const ContextSettings &settings)'],['../classsf_1_1Window.html#a5ee0c5262df6cc4e1a8031ae6848437f',1,'sf::Window::create(WindowHandle handle)'],['../classsf_1_1Window.html#a064dd5dd7bb337fb9f5635f580081a1e',1,'sf::Window::create(WindowHandle handle, const ContextSettings &settings)'],['../classsf_1_1WindowBase.html#a3b888387b7bd4be38d6db1234c8d7ad4',1,'sf::WindowBase::create(VideoMode mode, const String &title, Uint32 style=Style::Default)'],['../classsf_1_1WindowBase.html#a4e4968e15e33fd70629983f635bcc21c',1,'sf::WindowBase::create(WindowHandle handle)']]], + ['createdirectory_17',['createDirectory',['../classsf_1_1Ftp.html#a247b84c4b25da37804218c2b748c4787',1,'sf::Ftp']]], + ['createmaskfromcolor_18',['createMaskFromColor',['../classsf_1_1Image.html#a22f13f8c242a6b38eb73cc176b37ae34',1,'sf::Image']]], + ['createreaderfromfilename_19',['createReaderFromFilename',['../classsf_1_1SoundFileFactory.html#ae68185540db5e2a451d626be45036fe0',1,'sf::SoundFileFactory']]], + ['createreaderfrommemory_20',['createReaderFromMemory',['../classsf_1_1SoundFileFactory.html#a2384ed647b08c5b2bbf43566d5d7b5fd',1,'sf::SoundFileFactory']]], + ['createreaderfromstream_21',['createReaderFromStream',['../classsf_1_1SoundFileFactory.html#af64ce454cde415ebd3ca5442801d87d8',1,'sf::SoundFileFactory']]], + ['createvulkansurface_22',['createVulkanSurface',['../classsf_1_1WindowBase.html#a4bcb435cdb954f991f493976263a2fc1',1,'sf::WindowBase']]], + ['createwriterfromfilename_23',['createWriterFromFilename',['../classsf_1_1SoundFileFactory.html#a2bc9da55d78be2c41a273bbbea4c0978',1,'sf::SoundFileFactory']]], + ['cursor_24',['Cursor',['../classsf_1_1Cursor.html#a6a36a0a5943b22b77b00cac839dd715c',1,'sf::Cursor']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_3.js b/Space-Invaders/sfml/doc/html/search/functions_3.js new file mode 100644 index 000000000..01bf35e19 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_3.js @@ -0,0 +1,14 @@ +var searchData= +[ + ['decode_0',['decode',['../classsf_1_1Utf_3_018_01_4.html#a59d4e8d5832961e62b263d308b72bf4b',1,'sf::Utf< 8 >::decode()'],['../classsf_1_1Utf_3_0116_01_4.html#a17be6fc08e51182e7ac8bf9269dfae37',1,'sf::Utf< 16 >::decode()'],['../classsf_1_1Utf_3_0132_01_4.html#ad754ce8476f7b80563890dec12cefd46',1,'sf::Utf< 32 >::decode(In begin, In end, Uint32 &output, Uint32 replacement=0)']]], + ['decodeansi_1',['decodeAnsi',['../classsf_1_1Utf_3_0132_01_4.html#a68346ea833f88267a7c739d4d96fb86f',1,'sf::Utf< 32 >']]], + ['decodewide_2',['decodeWide',['../classsf_1_1Utf_3_0132_01_4.html#a043fe25f5f4dbc205e78e6f1d99840dc',1,'sf::Utf< 32 >']]], + ['deletedirectory_3',['deleteDirectory',['../classsf_1_1Ftp.html#a2a8a7ef9144204b5b319c9a4be8806c2',1,'sf::Ftp']]], + ['deletefile_4',['deleteFile',['../classsf_1_1Ftp.html#a8aa272b0eb7769a850006e70fcad370f',1,'sf::Ftp']]], + ['delocalize_5',['delocalize',['../classsf_1_1Keyboard.html#af9fd530c73b8a2cd6094d373e879eb00',1,'sf::Keyboard']]], + ['directoryresponse_6',['DirectoryResponse',['../classsf_1_1Ftp_1_1DirectoryResponse.html#a36b6d2728fa53c4ad37b7a6307f4d388',1,'sf::Ftp::DirectoryResponse']]], + ['disconnect_7',['disconnect',['../classsf_1_1Ftp.html#acf7459926f3391cd06bf84337ed6a0f4',1,'sf::Ftp::disconnect()'],['../classsf_1_1TcpSocket.html#ac18f518a9be3d6be5e74b9404c253c1e',1,'sf::TcpSocket::disconnect()']]], + ['display_8',['display',['../classsf_1_1RenderTexture.html#af92886d5faef3916caff9fa9ab32c555',1,'sf::RenderTexture::display()'],['../classsf_1_1Window.html#adabf839cb103ac96cfc82f781638772a',1,'sf::Window::display()']]], + ['download_9',['download',['../classsf_1_1Ftp.html#a20c1600ec5fd6f5a2ad1429ab8aa5df4',1,'sf::Ftp']]], + ['draw_10',['draw',['../classsf_1_1Drawable.html#a90d2c88bba9b035a0844eccb380ef631',1,'sf::Drawable::draw()'],['../classsf_1_1RenderTarget.html#a12417a3bcc245c41d957b29583556f39',1,'sf::RenderTarget::draw(const Drawable &drawable, const RenderStates &states=RenderStates::Default)'],['../classsf_1_1RenderTarget.html#a976bc94057799eb9f8a18ac5fdfd9b73',1,'sf::RenderTarget::draw(const Vertex *vertices, std::size_t vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default)'],['../classsf_1_1RenderTarget.html#a3dc4d06f081d36ca1e8f1a1298d49abc',1,'sf::RenderTarget::draw(const VertexBuffer &vertexBuffer, const RenderStates &states=RenderStates::Default)'],['../classsf_1_1RenderTarget.html#a07cb25d4557a30146b24b25b242310ea',1,'sf::RenderTarget::draw(const VertexBuffer &vertexBuffer, std::size_t firstVertex, std::size_t vertexCount, const RenderStates &states=RenderStates::Default)']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_4.js b/Space-Invaders/sfml/doc/html/search/functions_4.js new file mode 100644 index 000000000..38e005cb7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_4.js @@ -0,0 +1,10 @@ +var searchData= +[ + ['encode_0',['encode',['../classsf_1_1Utf_3_018_01_4.html#a5fbc6b5a996f52e9e4a14633d0d71847',1,'sf::Utf< 8 >::encode()'],['../classsf_1_1Utf_3_0116_01_4.html#a516090c84ceec2cfde0a13b6148363bb',1,'sf::Utf< 16 >::encode()'],['../classsf_1_1Utf_3_0132_01_4.html#a27b9d3f3fc49a8c88d91966889fcfca1',1,'sf::Utf< 32 >::encode(Uint32 input, Out output, Uint32 replacement=0)']]], + ['encodeansi_1',['encodeAnsi',['../classsf_1_1Utf_3_0132_01_4.html#af6590226a071076ca22d818573a16ded',1,'sf::Utf< 32 >']]], + ['encodewide_2',['encodeWide',['../classsf_1_1Utf_3_0132_01_4.html#a52e511e74ddc5df1bbf18f910193bc47',1,'sf::Utf< 32 >']]], + ['end_3',['end',['../classsf_1_1String.html#ac823012f39cb6f61100418876e99d53b',1,'sf::String::end()'],['../classsf_1_1String.html#af1ab4c82ff2bdfb6903b4b1bb78a8e5c',1,'sf::String::end() const']]], + ['endofpacket_4',['endOfPacket',['../classsf_1_1Packet.html#a61e354fa670da053907c14b738839560',1,'sf::Packet']]], + ['erase_5',['erase',['../classsf_1_1String.html#aaa78a0a46b3fbe200a4ccdedc326eb93',1,'sf::String']]], + ['err_6',['err',['../group__system.html#ga7fe7f475639e26334606b5142c29551f',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_5.js b/Space-Invaders/sfml/doc/html/search/functions_5.js new file mode 100644 index 000000000..36efd6fc9 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_5.js @@ -0,0 +1,15 @@ +var searchData= +[ + ['fileinputstream_0',['FileInputStream',['../classsf_1_1FileInputStream.html#a9a321e273f41ff7f187899061fcae9be',1,'sf::FileInputStream']]], + ['find_1',['find',['../classsf_1_1String.html#aa189ec8656854106ab8d2e935fd9cbcc',1,'sf::String']]], + ['findcharacterpos_2',['findCharacterPos',['../classsf_1_1Text.html#a2e252d8dcae3eb61c6c962c0bc674b12',1,'sf::Text']]], + ['fliphorizontally_3',['flipHorizontally',['../classsf_1_1Image.html#a57168e7bc29190e08bbd6c9c19f4bb2c',1,'sf::Image']]], + ['flipvertically_4',['flipVertically',['../classsf_1_1Image.html#a78a702a7e49d1de2dec9894da99d279c',1,'sf::Image']]], + ['font_5',['Font',['../classsf_1_1Font.html#a506404655b8869ed60d1e7709812f583',1,'sf::Font::Font()'],['../classsf_1_1Font.html#a72d7322b355ee2f1be4500f530e98081',1,'sf::Font::Font(const Font &copy)']]], + ['fromansi_6',['fromAnsi',['../classsf_1_1Utf_3_018_01_4.html#a1b62ba85ad3c8ce68746e16192b3eef0',1,'sf::Utf< 8 >::fromAnsi()'],['../classsf_1_1Utf_3_0116_01_4.html#a8a595dc1ea57ecf7aad944964913f0ff',1,'sf::Utf< 16 >::fromAnsi()'],['../classsf_1_1Utf_3_0132_01_4.html#a384a4169287af15876783ad477cac4e3',1,'sf::Utf< 32 >::fromAnsi()']]], + ['fromlatin1_7',['fromLatin1',['../classsf_1_1Utf_3_018_01_4.html#a85dd3643b7109a1a2f802747e55e28e8',1,'sf::Utf< 8 >::fromLatin1()'],['../classsf_1_1Utf_3_0116_01_4.html#a52293df75893733fe6cf84b8a017cbf7',1,'sf::Utf< 16 >::fromLatin1()'],['../classsf_1_1Utf_3_0132_01_4.html#a05741b76b5a26267a72735e40ca61c55',1,'sf::Utf< 32 >::fromLatin1()']]], + ['fromutf16_8',['fromUtf16',['../classsf_1_1String.html#a81f70eecad0000a4f2e4d66f97b80300',1,'sf::String']]], + ['fromutf32_9',['fromUtf32',['../classsf_1_1String.html#ab023a4900dce37ee71ab9e29b30a23cb',1,'sf::String']]], + ['fromutf8_10',['fromUtf8',['../classsf_1_1String.html#aa7beb7ae5b26e63dcbbfa390e27a9e4b',1,'sf::String']]], + ['fromwide_11',['fromWide',['../classsf_1_1Utf_3_018_01_4.html#aa99e636a7addc157b425dfc11b008f42',1,'sf::Utf< 8 >::fromWide()'],['../classsf_1_1Utf_3_0116_01_4.html#a263423929b6f8e4d3ad09b45ac5cb0a1',1,'sf::Utf< 16 >::fromWide()'],['../classsf_1_1Utf_3_0132_01_4.html#abdf0d41e0c8814a68326688e3b8d187f',1,'sf::Utf< 32 >::fromWide()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_6.js b/Space-Invaders/sfml/doc/html/search/functions_6.js new file mode 100644 index 000000000..98aad54c7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_6.js @@ -0,0 +1,105 @@ +var searchData= +[ + ['generatemipmap_0',['generateMipmap',['../classsf_1_1RenderTexture.html#a8ca34c8b7e00793c1d3ef4f9a834f8cc',1,'sf::RenderTexture::generateMipmap()'],['../classsf_1_1Texture.html#a7779a75c0324b5faff77602f871710a9',1,'sf::Texture::generateMipmap()']]], + ['getactivecontext_1',['getActiveContext',['../classsf_1_1Context.html#a31bc6509779067b21d13208ffe85d5ca',1,'sf::Context']]], + ['getactivecontextid_2',['getActiveContextId',['../classsf_1_1Context.html#a61b1cb0a99b8e3ce56579d70aa41fb70',1,'sf::Context']]], + ['getattenuation_3',['getAttenuation',['../classsf_1_1SoundSource.html#a8ad7dafb4f1b4afbc638cebe24f48cc9',1,'sf::SoundSource']]], + ['getavailabledevices_4',['getAvailableDevices',['../classsf_1_1SoundRecorder.html#a2a0a831148dcf3d979de42029ec0c280',1,'sf::SoundRecorder']]], + ['getaxisposition_5',['getAxisPosition',['../classsf_1_1Joystick.html#aea4930193331df1851b709f3060ba58b',1,'sf::Joystick']]], + ['getbody_6',['getBody',['../classsf_1_1Http_1_1Response.html#ac59e2b11cae4b6232c737547a3ca9850',1,'sf::Http::Response']]], + ['getbounds_7',['getBounds',['../classsf_1_1VertexArray.html#abd57744c732abfc7d4c98d8e1d4ccca1',1,'sf::VertexArray']]], + ['getbuffer_8',['getBuffer',['../classsf_1_1Sound.html#a7c0f6033856909eeefa2e6696db96ef2',1,'sf::Sound::getBuffer()'],['../classsf_1_1SoundBufferRecorder.html#a1befea2bfa3959ff6fabbf7e33cbc864',1,'sf::SoundBufferRecorder::getBuffer()']]], + ['getbuttoncount_9',['getButtonCount',['../classsf_1_1Joystick.html#a4de9f445c6582bfe9f0873f695682885',1,'sf::Joystick']]], + ['getcenter_10',['getCenter',['../classsf_1_1View.html#a8bd01cd2bcad03e547232b190c215b09',1,'sf::View']]], + ['getchannelcount_11',['getChannelCount',['../classsf_1_1InputSoundFile.html#a54307c308ba05dea63aba54a29c804a4',1,'sf::InputSoundFile::getChannelCount()'],['../classsf_1_1SoundBuffer.html#a127707b831d875ed790eef1aa2b9fcc3',1,'sf::SoundBuffer::getChannelCount()'],['../classsf_1_1SoundRecorder.html#a610e98e7a73b316ce26b7c55234f86e9',1,'sf::SoundRecorder::getChannelCount()'],['../classsf_1_1SoundStream.html#a1f70933912dd9498f4dc99feefed27f3',1,'sf::SoundStream::getChannelCount()']]], + ['getcharactersize_12',['getCharacterSize',['../classsf_1_1Text.html#a46d1d7f1d513bb8d434e985a93ea5224',1,'sf::Text']]], + ['getcolor_13',['getColor',['../classsf_1_1Sprite.html#af4a3ee8177fdd6e472a360a0a837d7cf',1,'sf::Sprite::getColor()'],['../classsf_1_1Text.html#ab367e86c9e9e6cd3806c362ab8e79101',1,'sf::Text::getColor()']]], + ['getdata_14',['getData',['../classsf_1_1Packet.html#a998b70df024bee4792e2ecdc915ae46e',1,'sf::Packet::getData()'],['../classsf_1_1String.html#a3ed7f3ad41659a2b31a8d8e99a7b8199',1,'sf::String::getData()']]], + ['getdatasize_15',['getDataSize',['../classsf_1_1Packet.html#a0fae6eccf2ca704fc5099cd90a9f56f7',1,'sf::Packet']]], + ['getdefaultdevice_16',['getDefaultDevice',['../classsf_1_1SoundRecorder.html#ad1d450a80642dab4b632999d72a1bf23',1,'sf::SoundRecorder']]], + ['getdefaultview_17',['getDefaultView',['../classsf_1_1RenderTarget.html#a7741129e3ef7ab4f0a40024fca13480c',1,'sf::RenderTarget']]], + ['getdescription_18',['getDescription',['../classsf_1_1Keyboard.html#aab9652b25d81d6526b72bdc876d92d41',1,'sf::Keyboard']]], + ['getdesktopmode_19',['getDesktopMode',['../classsf_1_1VideoMode.html#ac1be160a4342e6eafb2cb0e8c9b18d44',1,'sf::VideoMode']]], + ['getdevice_20',['getDevice',['../classsf_1_1SoundRecorder.html#a13d7d97b3ca67efa18f5ee0aa5884f1f',1,'sf::SoundRecorder']]], + ['getdirection_21',['getDirection',['../classsf_1_1Listener.html#a54e91baba51d4431474f53ff7f9309f9',1,'sf::Listener']]], + ['getdirectory_22',['getDirectory',['../classsf_1_1Ftp_1_1DirectoryResponse.html#a983b0ce3d99c687e0862212040158d67',1,'sf::Ftp::DirectoryResponse']]], + ['getdirectorylisting_23',['getDirectoryListing',['../classsf_1_1Ftp.html#a8f37258e461fcb9e2a0655e9df0be4a0',1,'sf::Ftp']]], + ['getduration_24',['getDuration',['../classsf_1_1InputSoundFile.html#aa081bd4d9732408d10b48227a360778e',1,'sf::InputSoundFile::getDuration()'],['../classsf_1_1Music.html#a288ef6f552a136b0e56952dcada3d672',1,'sf::Music::getDuration()'],['../classsf_1_1SoundBuffer.html#a280a581d9b360fd16121714c51fc8261',1,'sf::SoundBuffer::getDuration()']]], + ['getelapsedtime_25',['getElapsedTime',['../classsf_1_1Clock.html#abe889b42a65bcd8eefc16419645d08a7',1,'sf::Clock']]], + ['getfield_26',['getField',['../classsf_1_1Http_1_1Response.html#ae16458c4e969206381b78587aa47c8dc',1,'sf::Http::Response']]], + ['getfillcolor_27',['getFillColor',['../classsf_1_1Shape.html#aa5da23e522d2dd11e3e7661c26164c78',1,'sf::Shape::getFillColor()'],['../classsf_1_1Text.html#a10400757492ec7fa97454488314ca39b',1,'sf::Text::getFillColor() const']]], + ['getfont_28',['getFont',['../classsf_1_1Text.html#ad947a43bddaddf54d008df600699599b',1,'sf::Text']]], + ['getfullscreenmodes_29',['getFullscreenModes',['../classsf_1_1VideoMode.html#a0f99e67ef2b51fbdc335d9991232609e',1,'sf::VideoMode']]], + ['getfunction_30',['getFunction',['../classsf_1_1Context.html#a998980d311effdf6223ce40d934c23c3',1,'sf::Context::getFunction()'],['../classsf_1_1Vulkan.html#af5b575941e5976af33c6447046e7fefe',1,'sf::Vulkan::getFunction()']]], + ['getglobalbounds_31',['getGlobalBounds',['../classsf_1_1Shape.html#ac0e29425d908d5442060cc44790fe4da',1,'sf::Shape::getGlobalBounds()'],['../classsf_1_1Sprite.html#aa795483096b90745b2e799532963e271',1,'sf::Sprite::getGlobalBounds()'],['../classsf_1_1Text.html#ad33ed96ce9fbe99610f7f8b6874a16b4',1,'sf::Text::getGlobalBounds()']]], + ['getglobalvolume_32',['getGlobalVolume',['../classsf_1_1Listener.html#a137ea535799bdf70be6ec969673d4d33',1,'sf::Listener']]], + ['getglyph_33',['getGlyph',['../classsf_1_1Font.html#a4fa68953025b5357b5683297a3104070',1,'sf::Font']]], + ['getgraphicsrequiredinstanceextensions_34',['getGraphicsRequiredInstanceExtensions',['../classsf_1_1Vulkan.html#a295895b452031cf58fadbf3205db6149',1,'sf::Vulkan']]], + ['gethandle_35',['getHandle',['../classsf_1_1Socket.html#a675457784284ae2f5640bbbe16729393',1,'sf::Socket']]], + ['getidentification_36',['getIdentification',['../classsf_1_1Joystick.html#aa917c9435330e6e0368d3893672d1b74',1,'sf::Joystick']]], + ['getinfo_37',['getInfo',['../classsf_1_1Font.html#a86f7a72943c428cac8fa6adaaa69c722',1,'sf::Font']]], + ['getinverse_38',['getInverse',['../classsf_1_1Transform.html#a14f49e81af44aabcff7611f6703a1e4a',1,'sf::Transform']]], + ['getinversetransform_39',['getInverseTransform',['../classsf_1_1Transformable.html#ac5e75d724436069d2268791c6b486916',1,'sf::Transformable::getInverseTransform()'],['../classsf_1_1View.html#aa685c17a56aae7c7df4c90ea6285fd46',1,'sf::View::getInverseTransform()']]], + ['getkerning_40',['getKerning',['../classsf_1_1Font.html#ab357e3e0e158f1dfc454a78e111cb5d6',1,'sf::Font']]], + ['getletterspacing_41',['getLetterSpacing',['../classsf_1_1Text.html#a028fc6e561bd9a0671254419b498b889',1,'sf::Text']]], + ['getlinespacing_42',['getLineSpacing',['../classsf_1_1Font.html#a4538cc8af337393208a87675fe1c3e59',1,'sf::Font::getLineSpacing()'],['../classsf_1_1Text.html#a670622e1c299dfd6518afe289c7cd248',1,'sf::Text::getLineSpacing()']]], + ['getlisting_43',['getListing',['../classsf_1_1Ftp_1_1ListingResponse.html#a0d0579db7e0531761992dbbae1174bf2',1,'sf::Ftp::ListingResponse']]], + ['getlocaladdress_44',['getLocalAddress',['../classsf_1_1IpAddress.html#a4c31622ad87edca48adbb8e8ed00ee4a',1,'sf::IpAddress']]], + ['getlocalbounds_45',['getLocalBounds',['../classsf_1_1Shape.html#ae3294bcdf8713d33a862242ecf706443',1,'sf::Shape::getLocalBounds()'],['../classsf_1_1Sprite.html#ab2f4c781464da6f8a52b1df6058a48b8',1,'sf::Sprite::getLocalBounds()'],['../classsf_1_1Text.html#a3e6b3b298827f853b41165eee2cbbc66',1,'sf::Text::getLocalBounds()']]], + ['getlocalport_46',['getLocalPort',['../classsf_1_1TcpListener.html#a784b9a9c59d4cdbae1795e90b8015780',1,'sf::TcpListener::getLocalPort()'],['../classsf_1_1TcpSocket.html#a98e45f0f49af1fd99216b9195e86d86b',1,'sf::TcpSocket::getLocalPort()'],['../classsf_1_1UdpSocket.html#a5c03644b3da34bb763bce93e758c938e',1,'sf::UdpSocket::getLocalPort()']]], + ['getloop_47',['getLoop',['../classsf_1_1Sound.html#a054da07266ce8f39229495146e3041eb',1,'sf::Sound::getLoop()'],['../classsf_1_1SoundStream.html#a49d263f9bbaefec4b019bd05fda59b25',1,'sf::SoundStream::getLoop()']]], + ['getlooppoints_48',['getLoopPoints',['../classsf_1_1Music.html#aae3451cad5c16ee6a6e124e62ed61361',1,'sf::Music']]], + ['getmajorhttpversion_49',['getMajorHttpVersion',['../classsf_1_1Http_1_1Response.html#ab1c6948f6444fad34d0537e206e398b8',1,'sf::Http::Response']]], + ['getmatrix_50',['getMatrix',['../classsf_1_1Transform.html#ab85cb4194f42a965d337a8f02783c534',1,'sf::Transform']]], + ['getmaximumantialiasinglevel_51',['getMaximumAntialiasingLevel',['../classsf_1_1RenderTexture.html#ab0849fc3e064b744ffae1ab1d85ee12b',1,'sf::RenderTexture']]], + ['getmaximumsize_52',['getMaximumSize',['../classsf_1_1Texture.html#a0bf905d487b104b758549c2e9e20a3fb',1,'sf::Texture']]], + ['getmessage_53',['getMessage',['../classsf_1_1Ftp_1_1Response.html#adc2890c93c9f8ee997b828fcbef82c97',1,'sf::Ftp::Response']]], + ['getmindistance_54',['getMinDistance',['../classsf_1_1SoundSource.html#a605ca7f359ec1c36fcccdcd4696562ac',1,'sf::SoundSource']]], + ['getminorhttpversion_55',['getMinorHttpVersion',['../classsf_1_1Http_1_1Response.html#af3c649568d2e291e71c3a7da546bb392',1,'sf::Http::Response']]], + ['getnativeactivity_56',['getNativeActivity',['../group__system.html#ga666414341ce8396227f5a125ee5b7053',1,'sf']]], + ['getnativehandle_57',['getNativeHandle',['../classsf_1_1Texture.html#a674b632608747bfc27b53a4935c835b0',1,'sf::Texture::getNativeHandle()'],['../classsf_1_1VertexBuffer.html#a343fa0a240c91bc4203a6727fcd9b920',1,'sf::VertexBuffer::getNativeHandle()'],['../classsf_1_1Shader.html#ac14d0bf7afe7b6bb415d309f9c707188',1,'sf::Shader::getNativeHandle()']]], + ['getorigin_58',['getOrigin',['../classsf_1_1Transformable.html#a898b33eb6513161eb5c747a072364f15',1,'sf::Transformable']]], + ['getoutlinecolor_59',['getOutlineColor',['../classsf_1_1Shape.html#a4aa05b59851468e948ac9682b9c71abb',1,'sf::Shape::getOutlineColor()'],['../classsf_1_1Text.html#ade9256ff9d43c9481fcf5f4003fe0141',1,'sf::Text::getOutlineColor()']]], + ['getoutlinethickness_60',['getOutlineThickness',['../classsf_1_1Shape.html#a1d4d5299c573a905e5833fc4dce783a7',1,'sf::Shape::getOutlineThickness()'],['../classsf_1_1Text.html#af6bf01c23189edf52c8b38708db6f3f6',1,'sf::Text::getOutlineThickness()']]], + ['getpitch_61',['getPitch',['../classsf_1_1SoundSource.html#a4736acc2c802f927544c9ce52a44a9e4',1,'sf::SoundSource']]], + ['getpixel_62',['getPixel',['../classsf_1_1Image.html#acf278760458433b2c3626a6980388a95',1,'sf::Image']]], + ['getpixelsptr_63',['getPixelsPtr',['../classsf_1_1Image.html#a2f49e69b6c6257b19b4d911993075c40',1,'sf::Image']]], + ['getplayingoffset_64',['getPlayingOffset',['../classsf_1_1SoundStream.html#ae288f3c72edbad9cc7ee938ce5b907c1',1,'sf::SoundStream::getPlayingOffset()'],['../classsf_1_1Sound.html#a559bc3aea581107bcb380fdbe523aa08',1,'sf::Sound::getPlayingOffset()']]], + ['getpoint_65',['getPoint',['../classsf_1_1CircleShape.html#a2d7f9715502b960b92387102fddb8736',1,'sf::CircleShape::getPoint()'],['../classsf_1_1ConvexShape.html#a72a97bc426d8daf4d682a20fcb7f3fe7',1,'sf::ConvexShape::getPoint()'],['../classsf_1_1RectangleShape.html#a3909f1a1946930ff5ae17c26206c0f81',1,'sf::RectangleShape::getPoint()'],['../classsf_1_1Shape.html#a40e5d83713eb9f0c999944cf96458085',1,'sf::Shape::getPoint()']]], + ['getpointcount_66',['getPointCount',['../classsf_1_1CircleShape.html#a014d29ec11e8afa4dce50e7047d99601',1,'sf::CircleShape::getPointCount()'],['../classsf_1_1ConvexShape.html#a0c54b8d48fe4e13414f6e667dbfc22a3',1,'sf::ConvexShape::getPointCount()'],['../classsf_1_1RectangleShape.html#adfb2f429e5720c9ccdb26d5996c3ae33',1,'sf::RectangleShape::getPointCount()'],['../classsf_1_1Shape.html#af988dd61a29803fc04d02198e44b5643',1,'sf::Shape::getPointCount()']]], + ['getposition_67',['getPosition',['../classsf_1_1Listener.html#acd7ee65bc948ca38e1c669aa12340c54',1,'sf::Listener::getPosition()'],['../classsf_1_1SoundSource.html#a8d199521f55550c7a3b2b0f6950dffa1',1,'sf::SoundSource::getPosition()'],['../classsf_1_1Rect.html#a846489bc985f7d1655150cad65961bbd',1,'sf::Rect::getPosition()'],['../classsf_1_1Transformable.html#aea8b18e91a7bf7be589851bb9dd11241',1,'sf::Transformable::getPosition()'],['../classsf_1_1Mouse.html#ac368680f797b7f6e4f50b5b7928c1387',1,'sf::Mouse::getPosition()'],['../classsf_1_1Mouse.html#ac9934f761e377da97993de5aab75006b',1,'sf::Mouse::getPosition(const WindowBase &relativeTo)'],['../classsf_1_1Touch.html#af1b7035be709091c7475075e43e2bc23',1,'sf::Touch::getPosition(unsigned int finger)'],['../classsf_1_1Touch.html#a8a1456574d2825d4249fcf72f11d4398',1,'sf::Touch::getPosition(unsigned int finger, const WindowBase &relativeTo)'],['../classsf_1_1WindowBase.html#a5ddaa5943f547645079f081422e45c81',1,'sf::WindowBase::getPosition()']]], + ['getprimitivetype_68',['getPrimitiveType',['../classsf_1_1VertexArray.html#aa1a60d84543aa6e220683349b645f130',1,'sf::VertexArray::getPrimitiveType()'],['../classsf_1_1VertexBuffer.html#a02061d85472ff69e7ad14dc72f8fcaa4',1,'sf::VertexBuffer::getPrimitiveType()']]], + ['getpublicaddress_69',['getPublicAddress',['../classsf_1_1IpAddress.html#a5c5cbf67e4aacf23c24f2ad991df4c55',1,'sf::IpAddress']]], + ['getradius_70',['getRadius',['../classsf_1_1CircleShape.html#aa3dd5a1b5031486ce5b6f09d43674aa3',1,'sf::CircleShape']]], + ['getreadposition_71',['getReadPosition',['../classsf_1_1Packet.html#a5c2dc9878afaf30e88d922776201f6c3',1,'sf::Packet']]], + ['getremoteaddress_72',['getRemoteAddress',['../classsf_1_1TcpSocket.html#aa8579c203b1fd21beb74d7f76444a94c',1,'sf::TcpSocket']]], + ['getremoteport_73',['getRemotePort',['../classsf_1_1TcpSocket.html#a93bced0afd4b1c60797a85725be04951',1,'sf::TcpSocket']]], + ['getrotation_74',['getRotation',['../classsf_1_1Transformable.html#aa00b5c5d4a06ac24a94dd72c56931d3a',1,'sf::Transformable::getRotation()'],['../classsf_1_1View.html#a324d8885f4ab17f1f7b0313580c9b84e',1,'sf::View::getRotation()']]], + ['getsamplecount_75',['getSampleCount',['../classsf_1_1InputSoundFile.html#a665b7fed6cdca3e0c622909e5a6655e4',1,'sf::InputSoundFile::getSampleCount()'],['../classsf_1_1SoundBuffer.html#aebe2a4bdbfbd9249353748da3f6a4fa1',1,'sf::SoundBuffer::getSampleCount()']]], + ['getsampleoffset_76',['getSampleOffset',['../classsf_1_1InputSoundFile.html#a73a99f159e8aca6e39478f6cf686d7ad',1,'sf::InputSoundFile']]], + ['getsamplerate_77',['getSampleRate',['../classsf_1_1InputSoundFile.html#a6b8177e40dd8020752f6d52f96b774c3',1,'sf::InputSoundFile::getSampleRate()'],['../classsf_1_1SoundBuffer.html#a2c2cf0078ce0549246ecc4a1646212b4',1,'sf::SoundBuffer::getSampleRate()'],['../classsf_1_1SoundStream.html#a7da448dc40d81a33b8dc555fbf0d3fbf',1,'sf::SoundStream::getSampleRate()'],['../classsf_1_1SoundRecorder.html#aed292c297a3e0d627db4eb5c18f58c44',1,'sf::SoundRecorder::getSampleRate()']]], + ['getsamples_78',['getSamples',['../classsf_1_1SoundBuffer.html#a3d5571a5231d3aea0d2cea933c38cc9e',1,'sf::SoundBuffer']]], + ['getscale_79',['getScale',['../classsf_1_1Transformable.html#a7bcae0e924213f2e89edd8926f2453af',1,'sf::Transformable']]], + ['getsettings_80',['getSettings',['../classsf_1_1Context.html#a5aace0ecfcf9552e97eed9ae88d01f71',1,'sf::Context::getSettings()'],['../classsf_1_1Window.html#a0605afbaceb02b098f9d731b7ab4203d',1,'sf::Window::getSettings()']]], + ['getsize_81',['getSize',['../classsf_1_1Image.html#a85409951b05369813069ed64393391ce',1,'sf::Image::getSize()'],['../classsf_1_1Rect.html#ab1fd0936386404646ebe708652a66d09',1,'sf::Rect::getSize()'],['../classsf_1_1RectangleShape.html#af6819a7b842b83863f21e7a9c63097e7',1,'sf::RectangleShape::getSize()'],['../classsf_1_1RenderTarget.html#a2e5ade2457d9fb4c4907ae5b3d9e94a5',1,'sf::RenderTarget::getSize()'],['../classsf_1_1RenderWindow.html#ae3eacf93661c8068fca7a78d57dc7e14',1,'sf::RenderWindow::getSize()'],['../classsf_1_1Texture.html#a9f86b8cc670c6399c539d4ce07ae5c8a',1,'sf::Texture::getSize()'],['../classsf_1_1View.html#a57e4a87cf0d724678675d22a0093719a',1,'sf::View::getSize()'],['../classsf_1_1FileInputStream.html#aabdcaa315e088e008eeb9711ecc796e8',1,'sf::FileInputStream::getSize()'],['../classsf_1_1InputStream.html#a311eaaaa65d636728e5153b574b72d5d',1,'sf::InputStream::getSize()'],['../classsf_1_1MemoryInputStream.html#a6ade3ca45de361ffa0a718595f0b6763',1,'sf::MemoryInputStream::getSize()'],['../classsf_1_1String.html#ae7aff54e178f5d3e399953adff5cad20',1,'sf::String::getSize()'],['../classsf_1_1WindowBase.html#a188a482d916a972d59d6b0700132e379',1,'sf::WindowBase::getSize()'],['../classsf_1_1RenderTexture.html#a6685315b5c4c25a5dcb75b4280b381ba',1,'sf::RenderTexture::getSize()']]], + ['getstatus_82',['getStatus',['../classsf_1_1Sound.html#a406fc363594a7718a53ebef49a870f51',1,'sf::Sound::getStatus()'],['../classsf_1_1SoundSource.html#aa8d313c31b968159582a999aa66e5ed7',1,'sf::SoundSource::getStatus()'],['../classsf_1_1SoundStream.html#a64a8193ed728da37c115c65de015849f',1,'sf::SoundStream::getStatus()'],['../classsf_1_1Ftp_1_1Response.html#a52bbca9fbf5451157bc055e3d8430c25',1,'sf::Ftp::Response::getStatus()'],['../classsf_1_1Http_1_1Response.html#a4271651703764fd9a7d2c0315aff20de',1,'sf::Http::Response::getStatus()']]], + ['getstring_83',['getString',['../classsf_1_1Text.html#ab334881845307db46ccf344191aa819c',1,'sf::Text::getString()'],['../classsf_1_1Clipboard.html#a3c385cc2b6d78a3d0cfa29928a7d6eb8',1,'sf::Clipboard::getString()']]], + ['getstyle_84',['getStyle',['../classsf_1_1Text.html#a0da79b0c057f4bb51592465a205c35d7',1,'sf::Text']]], + ['getsystemhandle_85',['getSystemHandle',['../classsf_1_1WindowBase.html#af9e56181556545bf6e6d7ed969edae21',1,'sf::WindowBase']]], + ['gettexture_86',['getTexture',['../classsf_1_1RenderTexture.html#a61a6eba45d5c9e5c913aebeccb7b7eda',1,'sf::RenderTexture::getTexture()'],['../classsf_1_1Shape.html#af4c345931cd651ffb8f7a177446e28f7',1,'sf::Shape::getTexture()'],['../classsf_1_1Font.html#a649982b4d0928d76a6f45b21719a6601',1,'sf::Font::getTexture()'],['../classsf_1_1Sprite.html#a6d0f107b5dd5976be50bc5b163ba21aa',1,'sf::Sprite::getTexture() const']]], + ['gettexturerect_87',['getTextureRect',['../classsf_1_1Sprite.html#afb19e5b4f39d17cf4d95752b3a79bcb6',1,'sf::Sprite::getTextureRect()'],['../classsf_1_1Shape.html#ad8adbb54823c8eff1830a938e164daa4',1,'sf::Shape::getTextureRect()']]], + ['gettimeoffset_88',['getTimeOffset',['../classsf_1_1InputSoundFile.html#ad1a2238acb734d8b1144ecd75cccc2e7',1,'sf::InputSoundFile']]], + ['gettransform_89',['getTransform',['../classsf_1_1Transformable.html#a3e1b4772a451ec66ac7e6af655726154',1,'sf::Transformable::getTransform()'],['../classsf_1_1View.html#ac9c1dab0cb8c1ac143b031035d821ce5',1,'sf::View::getTransform()']]], + ['getunderlineposition_90',['getUnderlinePosition',['../classsf_1_1Font.html#a726a55f40c19ac108e348b103190caad',1,'sf::Font']]], + ['getunderlinethickness_91',['getUnderlineThickness',['../classsf_1_1Font.html#ad6d0a5bc6c026fe85c239f1f822b54e6',1,'sf::Font']]], + ['getupvector_92',['getUpVector',['../classsf_1_1Listener.html#ae1427dd7e9b425b0c23b7b766bd6c6e6',1,'sf::Listener']]], + ['getusage_93',['getUsage',['../classsf_1_1VertexBuffer.html#a5e36f2b3955bb35648c17550a9c096e1',1,'sf::VertexBuffer']]], + ['getvalue_94',['getValue',['../classsf_1_1ThreadLocal.html#a3273f1976f96a838e386937eae33fc21',1,'sf::ThreadLocal::getValue()'],['../classsf_1_1Sensor.html#ab9a2710f55ead2f7b4e1b0bead34457e',1,'sf::Sensor::getValue()']]], + ['getvertexcount_95',['getVertexCount',['../classsf_1_1VertexArray.html#abda90e8d841a273d93164f0c0032bd8d',1,'sf::VertexArray::getVertexCount()'],['../classsf_1_1VertexBuffer.html#a6c534536ed186a2ad65e75484c8abafe',1,'sf::VertexBuffer::getVertexCount()']]], + ['getview_96',['getView',['../classsf_1_1RenderTarget.html#adbf8dc5a1f4abbe15a3fbb915844c7ea',1,'sf::RenderTarget']]], + ['getviewport_97',['getViewport',['../classsf_1_1View.html#aa2006fa4269078be4fd5ca999dcb6244',1,'sf::View::getViewport()'],['../classsf_1_1RenderTarget.html#a865d462915dc2a1fae2ebfb3300382ac',1,'sf::RenderTarget::getViewport()']]], + ['getvolume_98',['getVolume',['../classsf_1_1SoundSource.html#a04243fb5edf64561689b1d58953fc4ce',1,'sf::SoundSource']]], + ['getworkingdirectory_99',['getWorkingDirectory',['../classsf_1_1Ftp.html#a79c654fcdd0c81e68c4fa29af3b45e0c',1,'sf::Ftp']]], + ['glresource_100',['GlResource',['../classsf_1_1GlResource.html#ad8fb7a0674f0f77e530dacc2a3b0dc6a',1,'sf::GlResource']]], + ['glyph_101',['Glyph',['../classsf_1_1Glyph.html#ab15cfc37eb7b40a94b3b3aedf934010b',1,'sf::Glyph']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_7.js b/Space-Invaders/sfml/doc/html/search/functions_7.js new file mode 100644 index 000000000..abba6b22b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_7.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['hasaxis_0',['hasAxis',['../classsf_1_1Joystick.html#a268e8f2a11ae6af4a47c727cb4ab4d95',1,'sf::Joystick']]], + ['hasfocus_1',['hasFocus',['../classsf_1_1WindowBase.html#ad87bd19e979c426cb819ccde8c95232e',1,'sf::WindowBase']]], + ['hasglyph_2',['hasGlyph',['../classsf_1_1Font.html#ae577efa14d9f538208c98ded59a3f68e',1,'sf::Font']]], + ['http_3',['Http',['../classsf_1_1Http.html#abe2360194f99bdde402c9f97a85cf067',1,'sf::Http::Http()'],['../classsf_1_1Http.html#a79efd844a735f083fcce0edbf1092385',1,'sf::Http::Http(const std::string &host, unsigned short port=0)']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_8.js b/Space-Invaders/sfml/doc/html/search/functions_8.js new file mode 100644 index 000000000..18e071946 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_8.js @@ -0,0 +1,26 @@ +var searchData= +[ + ['image_0',['Image',['../classsf_1_1Image.html#abb4caf3cb167b613345ebe36fc883f12',1,'sf::Image']]], + ['initialize_1',['initialize',['../classsf_1_1SoundStream.html#a9c351711198ee1aa77c2fefd3ced4d2c',1,'sf::SoundStream::initialize()'],['../classsf_1_1RenderTarget.html#af530274b34159d644e509b4b4dc43eb7',1,'sf::RenderTarget::initialize()']]], + ['inputsoundfile_2',['InputSoundFile',['../classsf_1_1InputSoundFile.html#a3b95347de25d1d93a3230287cf47a077',1,'sf::InputSoundFile']]], + ['insert_3',['insert',['../classsf_1_1String.html#ad0b1455deabf07af13ee79812e05fa02',1,'sf::String']]], + ['intersects_4',['intersects',['../classsf_1_1Rect.html#ac77531698f39203e4bbe023097bb6a13',1,'sf::Rect::intersects(const Rect< T > &rectangle) const'],['../classsf_1_1Rect.html#ad512c4a1127279e2d7464d0ace62500d',1,'sf::Rect::intersects(const Rect< T > &rectangle, Rect< T > &intersection) const']]], + ['ipaddress_5',['IpAddress',['../classsf_1_1IpAddress.html#af32a0574baa0f46e48deb2d83ca7658b',1,'sf::IpAddress::IpAddress()'],['../classsf_1_1IpAddress.html#a656b7445ab04cabaa7398685bc09c3f7',1,'sf::IpAddress::IpAddress(const std::string &address)'],['../classsf_1_1IpAddress.html#a92f2a9be74334a61b96c2fc79fe6eb78',1,'sf::IpAddress::IpAddress(const char *address)'],['../classsf_1_1IpAddress.html#a1d289dcb9ce7a64c600c6f84cba88cc6',1,'sf::IpAddress::IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3)'],['../classsf_1_1IpAddress.html#a8ed34ba3a40d70eb9f09ac5ae779a162',1,'sf::IpAddress::IpAddress(Uint32 address)']]], + ['isavailable_6',['isAvailable',['../classsf_1_1SoundRecorder.html#aab2bd0fee9e48d6cfd449b1cb078ce5a',1,'sf::SoundRecorder::isAvailable()'],['../classsf_1_1Shader.html#ad22474690bafe4a305c1b9826b1bd86a',1,'sf::Shader::isAvailable()'],['../classsf_1_1VertexBuffer.html#a6304bc4134dc0164dc94eff887b08847',1,'sf::VertexBuffer::isAvailable()'],['../classsf_1_1Sensor.html#a7b7a2570218221781233bd495323abf0',1,'sf::Sensor::isAvailable()'],['../classsf_1_1Vulkan.html#a88ddd65cc8732316e3066541084c32a0',1,'sf::Vulkan::isAvailable()']]], + ['isblocking_7',['isBlocking',['../classsf_1_1Socket.html#ab1ceca9ac114b8baeeda3b34a0aca468',1,'sf::Socket']]], + ['isbuttonpressed_8',['isButtonPressed',['../classsf_1_1Joystick.html#ae0d97a4b84268cbe6a7078e1b2717835',1,'sf::Joystick::isButtonPressed()'],['../classsf_1_1Mouse.html#ab647159eb88e369a0332a9c5a7ba6687',1,'sf::Mouse::isButtonPressed()']]], + ['isconnected_9',['isConnected',['../classsf_1_1Joystick.html#ac7d4e1923e9f9420174f26703ea63d6c',1,'sf::Joystick']]], + ['isdown_10',['isDown',['../classsf_1_1Touch.html#a2f85297123ea4e401d02c346e50d48a3',1,'sf::Touch']]], + ['isempty_11',['isEmpty',['../classsf_1_1String.html#a2ba26cb6945d2bbb210b822f222aa7f6',1,'sf::String']]], + ['isextensionavailable_12',['isExtensionAvailable',['../classsf_1_1Context.html#a163c7f72c0c20133606657d895faa147',1,'sf::Context']]], + ['isgeometryavailable_13',['isGeometryAvailable',['../classsf_1_1Shader.html#a45db14baf1bbc688577f81813b1fce96',1,'sf::Shader']]], + ['iskeypressed_14',['isKeyPressed',['../classsf_1_1Keyboard.html#a80a04b2f53005886957f49eee3531599',1,'sf::Keyboard::isKeyPressed(Key key)'],['../classsf_1_1Keyboard.html#a8364065ca899275ce3e9314cce98ed3e',1,'sf::Keyboard::isKeyPressed(Scancode code)']]], + ['isok_15',['isOk',['../classsf_1_1Ftp_1_1Response.html#a5102552955a2652c1a39e9046e617b36',1,'sf::Ftp::Response']]], + ['isopen_16',['isOpen',['../classsf_1_1WindowBase.html#aa43559822564ef958dc664a90c57cba0',1,'sf::WindowBase']]], + ['isready_17',['isReady',['../classsf_1_1SocketSelector.html#a917a4bac708290a6782e6686fd3bf889',1,'sf::SocketSelector']]], + ['isrelativetolistener_18',['isRelativeToListener',['../classsf_1_1SoundSource.html#adcdb4ef32c2f4481d34aff0b5c31534b',1,'sf::SoundSource']]], + ['isrepeated_19',['isRepeated',['../classsf_1_1RenderTexture.html#a81c5a453a21c7e78299b062b97dc8c87',1,'sf::RenderTexture::isRepeated()'],['../classsf_1_1Texture.html#af1a1a32ca5c799204b2bea4040df7647',1,'sf::Texture::isRepeated()']]], + ['issmooth_20',['isSmooth',['../classsf_1_1Font.html#ae5b59162507d5dd35f3ea0ee91e322ca',1,'sf::Font::isSmooth()'],['../classsf_1_1RenderTexture.html#a5b43c007ab6643accc5dae84b5bc8f61',1,'sf::RenderTexture::isSmooth()'],['../classsf_1_1Texture.html#a3ebb050b5a71e1d40ba66eb1a060e103',1,'sf::Texture::isSmooth()']]], + ['issrgb_21',['isSrgb',['../classsf_1_1RenderTarget.html#aea6b58e5b2423c917e2664ecd4952687',1,'sf::RenderTarget::isSrgb()'],['../classsf_1_1RenderTexture.html#a994f2fa5a4235cbbdb60d9d9a5eed07b',1,'sf::RenderTexture::isSrgb()'],['../classsf_1_1RenderWindow.html#ad943b4797fe6e1d609f12ce413b6a093',1,'sf::RenderWindow::isSrgb()'],['../classsf_1_1Texture.html#a9d77ce4f8124abfda96900a6bd53bfe9',1,'sf::Texture::isSrgb()']]], + ['isvalid_22',['isValid',['../classsf_1_1VideoMode.html#ad5e04c044b0925523c75ecb173d2129a',1,'sf::VideoMode']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_9.js b/Space-Invaders/sfml/doc/html/search/functions_9.js new file mode 100644 index 000000000..6e9265398 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_9.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['keepalive_0',['keepAlive',['../classsf_1_1Ftp.html#aa1127d442b4acb2105aa8060a39d04fc',1,'sf::Ftp']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_a.js b/Space-Invaders/sfml/doc/html/search/functions_a.js new file mode 100644 index 000000000..53e762ca7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_a.js @@ -0,0 +1,17 @@ +var searchData= +[ + ['launch_0',['launch',['../classsf_1_1Thread.html#a74f75a9e86e1eb47479496314048b5f6',1,'sf::Thread']]], + ['listen_1',['listen',['../classsf_1_1TcpListener.html#a9504758ea3570e62cb20b209c11776a1',1,'sf::TcpListener']]], + ['listingresponse_2',['ListingResponse',['../classsf_1_1Ftp_1_1ListingResponse.html#a7e98d0aed70105c71adb52e5b6ce0bb8',1,'sf::Ftp::ListingResponse']]], + ['loadfromfile_3',['loadFromFile',['../classsf_1_1SoundBuffer.html#a2be6a8025c97eb622a7dff6cf2594394',1,'sf::SoundBuffer::loadFromFile()'],['../classsf_1_1Font.html#ab020052ef4e01f6c749a85571c0f3fd1',1,'sf::Font::loadFromFile()'],['../classsf_1_1Image.html#a9e4f2aa8e36d0cabde5ed5a4ef80290b',1,'sf::Image::loadFromFile()'],['../classsf_1_1Shader.html#a053a5632848ebaca2fcd8ba29abe9e6e',1,'sf::Shader::loadFromFile(const std::string &filename, Type type)'],['../classsf_1_1Shader.html#ac9d7289966fcef562eeb92271c03e3dc',1,'sf::Shader::loadFromFile(const std::string &vertexShaderFilename, const std::string &fragmentShaderFilename)'],['../classsf_1_1Shader.html#a295d8468811ca15bf9c5401a7a7d4f54',1,'sf::Shader::loadFromFile(const std::string &vertexShaderFilename, const std::string &geometryShaderFilename, const std::string &fragmentShaderFilename)'],['../classsf_1_1Texture.html#a8e1b56eabfe33e2e0e1cb03712c7fcc7',1,'sf::Texture::loadFromFile(const std::string &filename, const IntRect &area=IntRect())']]], + ['loadfromimage_4',['loadFromImage',['../classsf_1_1Texture.html#abec4567ad9856a3596dc74803f26fba2',1,'sf::Texture']]], + ['loadfrommemory_5',['loadFromMemory',['../classsf_1_1SoundBuffer.html#af8cfa5599739a7edae69c5cba273d33f',1,'sf::SoundBuffer::loadFromMemory()'],['../classsf_1_1Font.html#abf2f8d6de31eb4e1db02e061c323e346',1,'sf::Font::loadFromMemory()'],['../classsf_1_1Image.html#aaa6c7afa5851a51cec6ab438faa7354c',1,'sf::Image::loadFromMemory()'],['../classsf_1_1Shader.html#ac92d46bf71dff2d791117e4e472148aa',1,'sf::Shader::loadFromMemory(const std::string &shader, Type type)'],['../classsf_1_1Shader.html#ae34e94070d7547a890166b7993658a9b',1,'sf::Shader::loadFromMemory(const std::string &vertexShader, const std::string &fragmentShader)'],['../classsf_1_1Shader.html#ab8c8b715b02aba2cf7c0a0e0c0984250',1,'sf::Shader::loadFromMemory(const std::string &vertexShader, const std::string &geometryShader, const std::string &fragmentShader)'],['../classsf_1_1Texture.html#a2c4adb19dd4cbee0a588eeb85e52a249',1,'sf::Texture::loadFromMemory()']]], + ['loadfrompixels_6',['loadFromPixels',['../classsf_1_1Cursor.html#ac24ecf82ac7d9ba6703389397f948b3a',1,'sf::Cursor']]], + ['loadfromsamples_7',['loadFromSamples',['../classsf_1_1SoundBuffer.html#a42d51ce4bb3b60c7ea06f63c273fd063',1,'sf::SoundBuffer']]], + ['loadfromstream_8',['loadFromStream',['../classsf_1_1SoundBuffer.html#ad292156b1e01f6dabd4c0c277d5e079e',1,'sf::SoundBuffer::loadFromStream()'],['../classsf_1_1Font.html#abc3f37a354ce8b9a21f8eb93bd9fdafb',1,'sf::Font::loadFromStream()'],['../classsf_1_1Image.html#a21122ded0e8368bb06ed3b9acfbfb501',1,'sf::Image::loadFromStream()'],['../classsf_1_1Shader.html#a2ee1b130c0606e4f8bcdf65c1efc2a53',1,'sf::Shader::loadFromStream(InputStream &stream, Type type)'],['../classsf_1_1Shader.html#a3b7958159ffb5596c4babc3052e35465',1,'sf::Shader::loadFromStream(InputStream &vertexShaderStream, InputStream &fragmentShaderStream)'],['../classsf_1_1Shader.html#aa08f1c091806205e6654db9d83197fcd',1,'sf::Shader::loadFromStream(InputStream &vertexShaderStream, InputStream &geometryShaderStream, InputStream &fragmentShaderStream)'],['../classsf_1_1Texture.html#a786b486a46b1c6d1c16ff4af61ecc601',1,'sf::Texture::loadFromStream()']]], + ['loadfromsystem_9',['loadFromSystem',['../classsf_1_1Cursor.html#ad41999c8633c2fbaa2364e379c1ab25b',1,'sf::Cursor']]], + ['localize_10',['localize',['../classsf_1_1Keyboard.html#a4f77c97de21fbb14b9df79e320b12d9a',1,'sf::Keyboard']]], + ['lock_11',['lock',['../classsf_1_1Mutex.html#a1a16956a6bbea764480c1b80f2e45763',1,'sf::Mutex']]], + ['lock_12',['Lock',['../classsf_1_1Lock.html#a1a4c5d7a15da61103d85c9aa7f118920',1,'sf::Lock']]], + ['login_13',['login',['../classsf_1_1Ftp.html#a686262bc377584cd50e52e1576aa3a9b',1,'sf::Ftp::login()'],['../classsf_1_1Ftp.html#a99d8114793c1659e9d51d45cecdcd965',1,'sf::Ftp::login(const std::string &name, const std::string &password)']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_b.js b/Space-Invaders/sfml/doc/html/search/functions_b.js new file mode 100644 index 000000000..dbf37442c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_b.js @@ -0,0 +1,11 @@ +var searchData= +[ + ['mapcoordstopixel_0',['mapCoordsToPixel',['../classsf_1_1RenderTarget.html#ad92a9f0283aa5f3f67e473c1105b68cf',1,'sf::RenderTarget::mapCoordsToPixel(const Vector2f &point) const'],['../classsf_1_1RenderTarget.html#a848eee44b72ac3f16fa9182df26e83bc',1,'sf::RenderTarget::mapCoordsToPixel(const Vector2f &point, const View &view) const']]], + ['mappixeltocoords_1',['mapPixelToCoords',['../classsf_1_1RenderTarget.html#a0103ebebafa43a97e6e6414f8560d5e3',1,'sf::RenderTarget::mapPixelToCoords(const Vector2i &point) const'],['../classsf_1_1RenderTarget.html#a2d3e9d7c4a1f5ea7e52b06f53e3011f9',1,'sf::RenderTarget::mapPixelToCoords(const Vector2i &point, const View &view) const']]], + ['memoryinputstream_2',['MemoryInputStream',['../classsf_1_1MemoryInputStream.html#a2d78851a69a8956a79872be41bcdfe0e',1,'sf::MemoryInputStream']]], + ['microseconds_3',['microseconds',['../classsf_1_1Time.html#a8a6ae28a1962198a69b92355649c6aa0',1,'sf::Time']]], + ['milliseconds_4',['milliseconds',['../classsf_1_1Time.html#a9231f886d925a24d181c8dcfa6448d87',1,'sf::Time']]], + ['move_5',['move',['../classsf_1_1Transformable.html#a86b461d6a941ad390c2ad8b6a4a20391',1,'sf::Transformable::move(float offsetX, float offsetY)'],['../classsf_1_1Transformable.html#ab9ca691522f6ddc1a40406849b87c469',1,'sf::Transformable::move(const Vector2f &offset)'],['../classsf_1_1View.html#a0c82144b837caf812f7cb25a43d80c41',1,'sf::View::move(float offsetX, float offsetY)'],['../classsf_1_1View.html#a4c98a6e04fed756dfaff8f629de50862',1,'sf::View::move(const Vector2f &offset)']]], + ['music_6',['Music',['../classsf_1_1Music.html#a0bc787d8e022b3a9b89cf2c28befd42e',1,'sf::Music']]], + ['mutex_7',['Mutex',['../classsf_1_1Mutex.html#a9bd52a48320fd7b6db8a78037aad276e',1,'sf::Mutex']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_c.js b/Space-Invaders/sfml/doc/html/search/functions_c.js new file mode 100644 index 000000000..03425f975 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_c.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['next_0',['next',['../classsf_1_1Utf_3_018_01_4.html#a0365a0b38700baa161843563d083edf6',1,'sf::Utf< 8 >::next()'],['../classsf_1_1Utf_3_0116_01_4.html#ab899108d77ce088eb001588e84d91525',1,'sf::Utf< 16 >::next()'],['../classsf_1_1Utf_3_0132_01_4.html#a788b4ebc728dde2aaba38f3605d4867c',1,'sf::Utf< 32 >::next()']]], + ['noncopyable_1',['NonCopyable',['../classsf_1_1NonCopyable.html#a2110add170580fdb946f887719da6860',1,'sf::NonCopyable']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_d.js b/Space-Invaders/sfml/doc/html/search/functions_d.js new file mode 100644 index 000000000..900fd6c48 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_d.js @@ -0,0 +1,43 @@ +var searchData= +[ + ['oncreate_0',['onCreate',['../classsf_1_1RenderWindow.html#a5bef0040b0fa87bed9fbd459c980d53a',1,'sf::RenderWindow::onCreate()'],['../classsf_1_1WindowBase.html#a3397a7265f654be7ce9ccde3a53a39df',1,'sf::WindowBase::onCreate()']]], + ['ongetdata_1',['onGetData',['../classsf_1_1Music.html#aca1bcb4e5d56a854133e74bd86374463',1,'sf::Music::onGetData()'],['../classsf_1_1SoundStream.html#a968ec024a6e45490962c8a1121cb7c5f',1,'sf::SoundStream::onGetData()']]], + ['onloop_2',['onLoop',['../classsf_1_1Music.html#aa68a64bdaf5d16e9ed64f202f5c45e03',1,'sf::Music::onLoop()'],['../classsf_1_1SoundStream.html#a3f717d18846f261fc375d71d6c7e41da',1,'sf::SoundStream::onLoop()']]], + ['onprocesssamples_3',['onProcessSamples',['../classsf_1_1SoundBufferRecorder.html#a9ceb94de14632ae8c1b78faf603b4767',1,'sf::SoundBufferRecorder::onProcessSamples()'],['../classsf_1_1SoundRecorder.html#a2670124cbe7a87c7e46b4840807f4fd7',1,'sf::SoundRecorder::onProcessSamples()']]], + ['onreceive_4',['onReceive',['../classsf_1_1Packet.html#ab71a31ef0f1d5d856de6f9fc75434128',1,'sf::Packet']]], + ['onresize_5',['onResize',['../classsf_1_1RenderWindow.html#a5c85fe482313562d33ffd24a194b6fef',1,'sf::RenderWindow::onResize()'],['../classsf_1_1WindowBase.html#a8be41815cbeb89bc49e8752b62283192',1,'sf::WindowBase::onResize()']]], + ['onseek_6',['onSeek',['../classsf_1_1Music.html#a15119cc0419c16bb334fa0698699c02e',1,'sf::Music::onSeek()'],['../classsf_1_1SoundStream.html#a907036dd2ca7d3af5ead316e54b75997',1,'sf::SoundStream::onSeek()']]], + ['onsend_7',['onSend',['../classsf_1_1Packet.html#af0003506bcb290407dcf5fe7f13a887d',1,'sf::Packet']]], + ['onstart_8',['onStart',['../classsf_1_1SoundBufferRecorder.html#a531a7445fc8a48eaf9fc039c83f17c6f',1,'sf::SoundBufferRecorder::onStart()'],['../classsf_1_1SoundRecorder.html#a7af418fb036201d3f85745bef78ce77f',1,'sf::SoundRecorder::onStart()']]], + ['onstop_9',['onStop',['../classsf_1_1SoundBufferRecorder.html#ab8e53849312413431873a5869d509f1e',1,'sf::SoundBufferRecorder::onStop()'],['../classsf_1_1SoundRecorder.html#aefc36138ca1e96c658301280e4a31b64',1,'sf::SoundRecorder::onStop()']]], + ['open_10',['open',['../classsf_1_1SoundFileReader.html#aa1d2fee2ba8f359c833ab74590d55935',1,'sf::SoundFileReader::open()'],['../classsf_1_1SoundFileWriter.html#a5c92bcaaa880ef4d3eaab18dae1d3d07',1,'sf::SoundFileWriter::open()'],['../classsf_1_1FileInputStream.html#a87a95dc3a71746097a99c86ee58bb353',1,'sf::FileInputStream::open()'],['../classsf_1_1MemoryInputStream.html#ad3cfb4f4f915f7803d6a0784e394ac19',1,'sf::MemoryInputStream::open()']]], + ['openfromfile_11',['openFromFile',['../classsf_1_1InputSoundFile.html#af68e54bc9bfac19554c84601156fe93f',1,'sf::InputSoundFile::openFromFile()'],['../classsf_1_1Music.html#a3edc66e5f5b3f11e84b90eaec9c7d7c0',1,'sf::Music::openFromFile()'],['../classsf_1_1OutputSoundFile.html#ae5e55f01c53c1422c44eaed2eed67fce',1,'sf::OutputSoundFile::openFromFile()']]], + ['openfrommemory_12',['openFromMemory',['../classsf_1_1InputSoundFile.html#a4e034a8e9e69ca3c33a3f11180250400',1,'sf::InputSoundFile::openFromMemory()'],['../classsf_1_1Music.html#ae93b21bcf28ff0b5fec458039111386e',1,'sf::Music::openFromMemory()']]], + ['openfromstream_13',['openFromStream',['../classsf_1_1InputSoundFile.html#a32b76497aeb088a2b46dc6efd819b909',1,'sf::InputSoundFile::openFromStream()'],['../classsf_1_1Music.html#a4e55d1910a26858b44778c26b237d673',1,'sf::Music::openFromStream()']]], + ['operator_20booltype_14',['operator BoolType',['../classsf_1_1Packet.html#a8ab20be4a63921b7cb1a4d8ca5c30f75',1,'sf::Packet']]], + ['operator_20t_2a_15',['operator T*',['../classsf_1_1ThreadLocalPtr.html#a81ca089ae5cda72c7470ca93041c3cb2',1,'sf::ThreadLocalPtr']]], + ['operator_21_3d_16',['operator!=',['../classsf_1_1Vector3.html#a608500d1ad3b78082cb5bb4356742bd4',1,'sf::Vector3::operator!=()'],['../classsf_1_1VideoMode.html#a34b5c266a7b9cd5bc95de62f8beafc5a',1,'sf::VideoMode::operator!=()'],['../structsf_1_1BlendMode.html#aee6169f8983f5e92298c4ad6829563ba',1,'sf::BlendMode::operator!=()'],['../classsf_1_1Color.html#a394c3495753c4b17f9cd45556ef00b8c',1,'sf::Color::operator!=()'],['../classsf_1_1Rect.html#a03fc4c105687b7d0f07b6b4ed4b45581',1,'sf::Rect::operator!=()'],['../classsf_1_1Transform.html#a5eee840ff0b2db9e5f57a87281cc2b01',1,'sf::Transform::operator!=()'],['../classsf_1_1String.html#a3bfb9217788a9978499b8d5696bb0ef2',1,'sf::String::operator!=()'],['../classsf_1_1Time.html#a3a142729f295af8b1baf2d8762bc39ac',1,'sf::Time::operator!=()'],['../classsf_1_1Vector2.html#a01673da35ef9c52d0e54b8263549a956',1,'sf::Vector2::operator!=()']]], + ['operator_25_17',['operator%',['../classsf_1_1Time.html#abe7206e15c2bf7ce8695f82219d466d2',1,'sf::Time']]], + ['operator_25_3d_18',['operator%=',['../classsf_1_1Time.html#a880fb0137cd426bd4457fd9e4a2f9d83',1,'sf::Time']]], + ['operator_2a_19',['operator*',['../classsf_1_1ThreadLocalPtr.html#adcbb45ae077df714bf9c61e936d97770',1,'sf::ThreadLocalPtr::operator*()'],['../classsf_1_1Color.html#a1bae779fb49bb92dbf820a65e45a6602',1,'sf::Color::operator*()'],['../classsf_1_1Transform.html#a85ea4e5539795f9b2ceb7d4b06736c8f',1,'sf::Transform::operator*(const Transform &left, const Transform &right)'],['../classsf_1_1Transform.html#a4eeee49125c3c72c250062eef35ceb75',1,'sf::Transform::operator*(const Transform &left, const Vector2f &right)'],['../classsf_1_1Time.html#ab891d4f3dbb454f6c1c484a7844bb581',1,'sf::Time::operator*(Time left, float right)'],['../classsf_1_1Time.html#a667d1568893f4e2520a223fa4e2b6ee2',1,'sf::Time::operator*(Time left, Int64 right)'],['../classsf_1_1Time.html#a61e3255c79b3d98a1a04ed8968a87863',1,'sf::Time::operator*(float left, Time right)'],['../classsf_1_1Time.html#a998a2ae6bd79e753bf9f4dea5b06370c',1,'sf::Time::operator*(Int64 left, Time right)'],['../classsf_1_1Vector2.html#a5f48ca928995b41c89f155afe8d16b02',1,'sf::Vector2::operator*(const Vector2< T > &left, T right)'],['../classsf_1_1Vector2.html#ad8b3e1cf7b156a984bc1427539ca8605',1,'sf::Vector2::operator*(T left, const Vector2< T > &right)'],['../classsf_1_1Vector3.html#a44ec312b31c1a85dcff4863795f98329',1,'sf::Vector3::operator*(const Vector3< T > &left, T right)'],['../classsf_1_1Vector3.html#aa6f2b0d9f79c1b9774759b7087affbb1',1,'sf::Vector3::operator*(T left, const Vector3< T > &right)']]], + ['operator_2a_3d_20',['operator*=',['../classsf_1_1Time.html#a3f7baa961b8961fc5e6a37dea7de10e3',1,'sf::Time::operator*=()'],['../classsf_1_1Transform.html#a189899674616490f6250953ac581ac30',1,'sf::Transform::operator*=()'],['../classsf_1_1Color.html#a7d1ea2b9bd5dbe29bb2e54feba9b4b38',1,'sf::Color::operator*=()'],['../classsf_1_1Time.html#ac883749b4e0a72c32e166ad802220539',1,'sf::Time::operator*=()'],['../classsf_1_1Vector2.html#abea24cb28c0d6e2957e259ba4e65d70e',1,'sf::Vector2::operator*=()'],['../classsf_1_1Vector3.html#ad5fb972775ce8ab58cd9670789e806a7',1,'sf::Vector3::operator*=()']]], + ['operator_2b_21',['operator+',['../classsf_1_1Color.html#a0355ba6bfd2f83ffd8f8fafdca26cdd0',1,'sf::Color::operator+()'],['../classsf_1_1String.html#af140f992b7698cf1448677c2c8e11bf1',1,'sf::String::operator+()'],['../classsf_1_1Time.html#a8249d3a28c8062c7c46cc426186f76c8',1,'sf::Time::operator+()'],['../classsf_1_1Vector2.html#a72421239823c38a6b780c86a710ead07',1,'sf::Vector2::operator+()'],['../classsf_1_1Vector3.html#a6500a0cb00e07801e9e9d7e96852ddd3',1,'sf::Vector3::operator+()']]], + ['operator_2b_3d_22',['operator+=',['../classsf_1_1String.html#afdae61e813b2951a6e39015e34a143f7',1,'sf::String::operator+=()'],['../classsf_1_1Color.html#af39790b2e677c9ab418787f5ff4583ef',1,'sf::Color::operator+=()'],['../classsf_1_1Time.html#a34b983deefecaf2725131771d54631e0',1,'sf::Time::operator+=()'],['../classsf_1_1Vector2.html#ad4b7a9d355d57790bfc7df0ade8bb628',1,'sf::Vector2::operator+=()'],['../classsf_1_1Vector3.html#abc28859af163c63318ea2723b81c5ad9',1,'sf::Vector3::operator+=(Vector3< T > &left, const Vector3< T > &right)']]], + ['operator_2d_23',['operator-',['../classsf_1_1Vector3.html#a9b75d2fb9b0f2fd9fe33f8f06f9dda75',1,'sf::Vector3::operator-(const Vector3< T > &left)'],['../classsf_1_1Vector3.html#abe0b9411c00cf807bf8a5f835874bd2a',1,'sf::Vector3::operator-(const Vector3< T > &left, const Vector3< T > &right)'],['../classsf_1_1Color.html#a4586e31d668f183fc46576511169bf2c',1,'sf::Color::operator-()'],['../classsf_1_1Time.html#acaead0aa2de9f82a548fcd8208a40f70',1,'sf::Time::operator-(Time right)'],['../classsf_1_1Time.html#aebd95ec0cd0b2dc5d858e70149ccd136',1,'sf::Time::operator-(Time left, Time right)'],['../classsf_1_1Vector2.html#a3885c2e66dc427cec7eaa178d59d8e8b',1,'sf::Vector2::operator-(const Vector2< T > &right)'],['../classsf_1_1Vector2.html#ad027adae53ec547a86c20deeb05c9e85',1,'sf::Vector2::operator-(const Vector2< T > &left, const Vector2< T > &right)']]], + ['operator_2d_3d_24',['operator-=',['../classsf_1_1Vector2.html#a30a5a12ad03c9a3a982a0a313bf84e6f',1,'sf::Vector2::operator-=()'],['../classsf_1_1Vector3.html#aa465672d2a4ee5fd354e585cf08d2ab9',1,'sf::Vector3::operator-=()'],['../classsf_1_1Color.html#a6927a7dba8b0d330f912fefb43b0c148',1,'sf::Color::operator-=()'],['../classsf_1_1Time.html#ae0a16136d024a44bbaa4ca49ac172c8f',1,'sf::Time::operator-=()']]], + ['operator_2d_3e_25',['operator->',['../classsf_1_1ThreadLocalPtr.html#a25646e1014a933d1a45b9ce17bab7703',1,'sf::ThreadLocalPtr']]], + ['operator_2f_26',['operator/',['../classsf_1_1Time.html#a67510d018fd010819ee075db2cbd004f',1,'sf::Time::operator/(Time left, float right)'],['../classsf_1_1Time.html#a5f7b24dd13c0068d5cba678e1d5db9a6',1,'sf::Time::operator/(Time left, Int64 right)'],['../classsf_1_1Time.html#a097cf1326d2d50e0043ff4e865c1bbac',1,'sf::Time::operator/(Time left, Time right)'],['../classsf_1_1Vector2.html#a7409dd89cb3aad6c3bc6622311107311',1,'sf::Vector2::operator/()'],['../classsf_1_1Vector3.html#ad4ba4a83de236ddeb92a7b759187e90d',1,'sf::Vector3::operator/()']]], + ['operator_2f_3d_27',['operator/=',['../classsf_1_1Vector2.html#ac4d293c9dc7954ccfd5e373972f38b03',1,'sf::Vector2::operator/=()'],['../classsf_1_1Time.html#ad513a413be41bc66feb0ff2b29d5f947',1,'sf::Time::operator/=(Time &left, float right)'],['../classsf_1_1Time.html#ac4b8df6ef282ee71808fd185f91490aa',1,'sf::Time::operator/=(Time &left, Int64 right)'],['../classsf_1_1Vector3.html#a8995a700f9dffccc6dddb3696ae17b64',1,'sf::Vector3::operator/=()']]], + ['operator_3c_28',['operator<',['../classsf_1_1String.html#a5158a142e0966685ec7fb4e147b24ef0',1,'sf::String::operator<()'],['../classsf_1_1Time.html#a3bad89721b8c026e80082a7aa539f244',1,'sf::Time::operator<()'],['../classsf_1_1VideoMode.html#a54cc77c0b6c4b133e0147a43d6829b13',1,'sf::VideoMode::operator<()']]], + ['operator_3c_3c_29',['operator<<',['../classsf_1_1Packet.html#af7f5c31c2d2749d3088783525f9fc974',1,'sf::Packet::operator<<(Int32 data)'],['../classsf_1_1Packet.html#ae02c874e0aac18a0497fca982a8f9083',1,'sf::Packet::operator<<(bool data)'],['../classsf_1_1Packet.html#a97aa4ecba66b8f528438fc41ed020825',1,'sf::Packet::operator<<(Int8 data)'],['../classsf_1_1Packet.html#ad5cc1857ed14878ab7a8509db8d99335',1,'sf::Packet::operator<<(Uint8 data)'],['../classsf_1_1Packet.html#a9d9c5a1bef415046aa46d51e7d2a9f1c',1,'sf::Packet::operator<<(Int16 data)'],['../classsf_1_1Packet.html#afb6b2958f8a55923297da432c2a4f3e9',1,'sf::Packet::operator<<(Uint16 data)'],['../classsf_1_1Packet.html#ad1837e0990f71e3727e0e118ab9fd20e',1,'sf::Packet::operator<<(Uint32 data)'],['../classsf_1_1Packet.html#a6dc89edcfcf19daf781b776439aba94a',1,'sf::Packet::operator<<(Int64 data)'],['../classsf_1_1Packet.html#af3802406ed3430e20259e8551fa6554b',1,'sf::Packet::operator<<(Uint64 data)'],['../classsf_1_1Packet.html#acf1a231e48452a1cd55af2c027a1c1ee',1,'sf::Packet::operator<<(float data)'],['../classsf_1_1Packet.html#abee2df335bdc3ab40521248cdb187c02',1,'sf::Packet::operator<<(double data)'],['../classsf_1_1Packet.html#a94522071d95189ddff1ae7ca832695ff',1,'sf::Packet::operator<<(const char *data)'],['../classsf_1_1Packet.html#ac45aab054ddee7de9599bc3b2d8e025f',1,'sf::Packet::operator<<(const std::string &data)'],['../classsf_1_1Packet.html#ac5a13e3280cac77799f7fdadfe3e37b6',1,'sf::Packet::operator<<(const wchar_t *data)'],['../classsf_1_1Packet.html#a97acaefaee7d3ffb36f4e8a00d4c3970',1,'sf::Packet::operator<<(const std::wstring &data)'],['../classsf_1_1Packet.html#a5ef2e3308b93b80214b42a7d4683704a',1,'sf::Packet::operator<<(const String &data)']]], + ['operator_3c_3d_30',['operator<=',['../classsf_1_1Time.html#aafb9de87ed6047956cd9487ab807371f',1,'sf::Time::operator<=()'],['../classsf_1_1VideoMode.html#aa094b7b9ae4c0194892ebda7b4b9bb37',1,'sf::VideoMode::operator<=()'],['../classsf_1_1String.html#ac1c1bb5dcf02aad3b2c0a1bf74a11cc9',1,'sf::String::operator<=()']]], + ['operator_3d_31',['operator=',['../classsf_1_1ThreadLocalPtr.html#a14dcf1cdf5f6b3bcdd633014b2b671f5',1,'sf::ThreadLocalPtr::operator=(T *value)'],['../classsf_1_1ThreadLocalPtr.html#a6792a6a808af06f0d13e3ceecf2fc947',1,'sf::ThreadLocalPtr::operator=(const ThreadLocalPtr< T > &right)'],['../classsf_1_1Sound.html#a8eee9197359bfdf20d399544a894af8b',1,'sf::Sound::operator=()'],['../classsf_1_1SoundBuffer.html#ad0b6f45d3008cd7d29d340195e68459a',1,'sf::SoundBuffer::operator=()'],['../classsf_1_1SoundSource.html#a4b494e4a0b819bae9cd99b43e2f3f59d',1,'sf::SoundSource::operator=()'],['../classsf_1_1Font.html#af9be4336df9121ec1b6f14fa9063e46e',1,'sf::Font::operator=()'],['../classsf_1_1Texture.html#a8d856e3b5865984d6ba0c25ac04fbedb',1,'sf::Texture::operator=()'],['../classsf_1_1VertexBuffer.html#ae9d19f938e30e1bb1788067e3c134653',1,'sf::VertexBuffer::operator=()'],['../classsf_1_1SocketSelector.html#af7247f1c8badd43932f3adcbc1fec7e8',1,'sf::SocketSelector::operator=()'],['../classsf_1_1String.html#af14c8e1bf351cf18486f0258c36260d7',1,'sf::String::operator=()']]], + ['operator_3d_3d_32',['operator==',['../structsf_1_1BlendMode.html#a20d1be06061109c3cef58e0cc38729ea',1,'sf::BlendMode::operator==()'],['../classsf_1_1Color.html#a2adc3f68860f7aa5e4d7c79dcbb31d30',1,'sf::Color::operator==()'],['../classsf_1_1Rect.html#ab3488b5dbd0e587c4d7cb80605affc46',1,'sf::Rect::operator==()'],['../classsf_1_1Transform.html#aa2de0a3ee2f8af05dbc94bf3b4633b4a',1,'sf::Transform::operator==()'],['../classsf_1_1String.html#a483931724196c580552b68751fb4d837',1,'sf::String::operator==()'],['../classsf_1_1Time.html#a9bbb2368cf012149f1001535a20c664a',1,'sf::Time::operator==()'],['../classsf_1_1Vector2.html#a9a7b2d36c3850828fdb651facfd25136',1,'sf::Vector2::operator==()'],['../classsf_1_1Vector3.html#a388d72db973306a35ba467016b3dee30',1,'sf::Vector3::operator==()'],['../classsf_1_1VideoMode.html#aca24086fd94d11014f3a0b5ca9a3acd6',1,'sf::VideoMode::operator==()']]], + ['operator_3e_33',['operator>',['../classsf_1_1String.html#ac96278a8cbe282632b11f0c8c007df0c',1,'sf::String::operator>()'],['../classsf_1_1Time.html#a9a472ce6d82aa0caf8e20af4a4b309f2',1,'sf::Time::operator>()'],['../classsf_1_1VideoMode.html#a5b894cab5f2a3a14597e4c6d200179a4',1,'sf::VideoMode::operator>()']]], + ['operator_3e_3d_34',['operator>=',['../classsf_1_1Time.html#a158c5f9a6abf575651b7b2f6af8aedaa',1,'sf::Time::operator>=()'],['../classsf_1_1VideoMode.html#a6e3d91683fcabb88c5b640e9884fe3df',1,'sf::VideoMode::operator>=()'],['../classsf_1_1String.html#a112689eec28e0ca9489e8c4ec6a34493',1,'sf::String::operator>=()']]], + ['operator_3e_3e_35',['operator>>',['../classsf_1_1Packet.html#a48df8986fc24551f1287144d3e990859',1,'sf::Packet::operator>>(Uint8 &data)'],['../classsf_1_1Packet.html#ae455be24bfd8dbaa4cd5097e0fb70ecd',1,'sf::Packet::operator>>(Int16 &data)'],['../classsf_1_1Packet.html#a8b6403506fec6b69f033278de33c8145',1,'sf::Packet::operator>>(bool &data)'],['../classsf_1_1Packet.html#a1c7814f9dbc637986ac498094add5ca5',1,'sf::Packet::operator>>(Int8 &data)'],['../classsf_1_1Packet.html#a6bc20f1be9a63407079e6d26171ac71f',1,'sf::Packet::operator>>(Uint16 &data)'],['../classsf_1_1Packet.html#a663e71b25a9352e3c4ddf4a3ce9db921',1,'sf::Packet::operator>>(Int32 &data)'],['../classsf_1_1Packet.html#aa3b0fabe6c14bcfa29bb04844b8bb987',1,'sf::Packet::operator>>(Uint32 &data)'],['../classsf_1_1Packet.html#ae76105996a6c2217bb3a4571603e92f6',1,'sf::Packet::operator>>(Int64 &data)'],['../classsf_1_1Packet.html#a79f7c144fd07a4036ffc7b0870a36613',1,'sf::Packet::operator>>(Uint64 &data)'],['../classsf_1_1Packet.html#a741849607d428e93c532e11eadcc39f1',1,'sf::Packet::operator>>(float &data)'],['../classsf_1_1Packet.html#a1854ca771105fb281edf349fc6507c73',1,'sf::Packet::operator>>(double &data)'],['../classsf_1_1Packet.html#aaed01fec1a3eae27a028506195607f82',1,'sf::Packet::operator>>(char *data)'],['../classsf_1_1Packet.html#a60484dff69997db11e2d4ab3704ab921',1,'sf::Packet::operator>>(std::string &data)'],['../classsf_1_1Packet.html#a8805e66013f9f84ec8a883e42ae259d4',1,'sf::Packet::operator>>(wchar_t *data)'],['../classsf_1_1Packet.html#a8621056995c32bcf59809e2aecf08635',1,'sf::Packet::operator>>(std::wstring &data)'],['../classsf_1_1Packet.html#a27d0ae92891dbf8a7914e5d5232940d0',1,'sf::Packet::operator>>(String &data)']]], + ['operator_5b_5d_36',['operator[]',['../classsf_1_1VertexArray.html#a913953848726c1c65f8617497e8fccd6',1,'sf::VertexArray::operator[](std::size_t index)'],['../classsf_1_1VertexArray.html#a8336081e73a14a5e4ad0aa9f926d82be',1,'sf::VertexArray::operator[](std::size_t index) const'],['../classsf_1_1String.html#a035c1b585a0ebed81e773ecafed57926',1,'sf::String::operator[](std::size_t index) const'],['../classsf_1_1String.html#a3e2041bd9ae84d223e6b12e46e5aa5d6',1,'sf::String::operator[](std::size_t index)']]], + ['outputsoundfile_37',['OutputSoundFile',['../classsf_1_1OutputSoundFile.html#a7ae9f2dbd0991fa9394726a3d58bb19e',1,'sf::OutputSoundFile']]], + ['string_38',['string',['../classsf_1_1String.html#a884816a0f688cfd48f9324c9741dc257',1,'sf::String']]], + ['wstring_39',['wstring',['../classsf_1_1String.html#a6bd1444bebaca9bbf01ba203061f5076',1,'sf::String']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_e.js b/Space-Invaders/sfml/doc/html/search/functions_e.js new file mode 100644 index 000000000..4311d1a89 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_e.js @@ -0,0 +1,10 @@ +var searchData= +[ + ['packet_0',['Packet',['../classsf_1_1Packet.html#a786e5d4ced83992ceefa1799963ea858',1,'sf::Packet']]], + ['parentdirectory_1',['parentDirectory',['../classsf_1_1Ftp.html#ad295cf77f30f9ad07b5c401fd9849189',1,'sf::Ftp']]], + ['pause_2',['pause',['../classsf_1_1Sound.html#a5eeb25815bfa8cdc4a6cc000b7b19ad5',1,'sf::Sound::pause()'],['../classsf_1_1SoundSource.html#a21553d4e8fcf136231dd8c7ad4630aba',1,'sf::SoundSource::pause()'],['../classsf_1_1SoundStream.html#a932ff181e661503cad288b4bb6fe45ca',1,'sf::SoundStream::pause()']]], + ['play_3',['play',['../classsf_1_1Sound.html#a2953ffe632536e72e696fd880ced2532',1,'sf::Sound::play()'],['../classsf_1_1SoundSource.html#a6e1bbb1f247ed8743faf3b1ed6f2bc21',1,'sf::SoundSource::play()'],['../classsf_1_1SoundStream.html#afdc08b69cab5f243d9324940a85a1144',1,'sf::SoundStream::play()']]], + ['pollevent_4',['pollEvent',['../classsf_1_1WindowBase.html#a6a143de089c8716bd42c38c781268f7f',1,'sf::WindowBase']]], + ['popglstates_5',['popGLStates',['../classsf_1_1RenderTarget.html#ad5a98401113df931ddcd54c080f7aa8e',1,'sf::RenderTarget']]], + ['pushglstates_6',['pushGLStates',['../classsf_1_1RenderTarget.html#a8d1998464ccc54e789aaf990242b47f7',1,'sf::RenderTarget']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/functions_f.js b/Space-Invaders/sfml/doc/html/search/functions_f.js new file mode 100644 index 000000000..85bf8a668 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/functions_f.js @@ -0,0 +1,26 @@ +var searchData= +[ + ['read_0',['read',['../classsf_1_1InputSoundFile.html#a83d6f64617456601edeb0daf9d14a17f',1,'sf::InputSoundFile::read()'],['../classsf_1_1SoundFileReader.html#a3b7d86769ea07e24e7b0f0486bed7591',1,'sf::SoundFileReader::read()'],['../classsf_1_1FileInputStream.html#ad1e94c4152429f485db224c44ee1eb50',1,'sf::FileInputStream::read()'],['../classsf_1_1InputStream.html#a8dd89c74c1acb693203f50e750c6ae53',1,'sf::InputStream::read()'],['../classsf_1_1MemoryInputStream.html#adff5270c521819639154d42d76fd4c34',1,'sf::MemoryInputStream::read()']]], + ['receive_1',['receive',['../classsf_1_1TcpSocket.html#a90ce50811ea61d4f00efc62bb99ae1af',1,'sf::TcpSocket::receive(void *data, std::size_t size, std::size_t &received)'],['../classsf_1_1TcpSocket.html#aa655352609bc9804f2baa020df3e7331',1,'sf::TcpSocket::receive(Packet &packet)'],['../classsf_1_1UdpSocket.html#ade9ca0f7ed7919136917b0b997a9833a',1,'sf::UdpSocket::receive(void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort)'],['../classsf_1_1UdpSocket.html#afdd5c655d00c96222d5b477fc057a22b',1,'sf::UdpSocket::receive(Packet &packet, IpAddress &remoteAddress, unsigned short &remotePort)']]], + ['rect_2',['Rect',['../classsf_1_1Rect.html#a0f87ebaef9722a6222fd2e04ce8efb37',1,'sf::Rect::Rect()'],['../classsf_1_1Rect.html#a15cdbc5a1aed3a8fc7be1bd5004f19f9',1,'sf::Rect::Rect(T rectLeft, T rectTop, T rectWidth, T rectHeight)'],['../classsf_1_1Rect.html#a27fdf85caa6d12caeeff78913cc59936',1,'sf::Rect::Rect(const Vector2< T > &position, const Vector2< T > &size)'],['../classsf_1_1Rect.html#a6fff2bb7e93677839461a66bc2957de0',1,'sf::Rect::Rect(const Rect< U > &rectangle)']]], + ['rectangleshape_3',['RectangleShape',['../classsf_1_1RectangleShape.html#a83a2be157ebee85c95ed491c3e78dd7c',1,'sf::RectangleShape']]], + ['registercontextdestroycallback_4',['registerContextDestroyCallback',['../classsf_1_1GlResource.html#ab171bdaf5eb36789da14b30a846db471',1,'sf::GlResource']]], + ['registerreader_5',['registerReader',['../classsf_1_1SoundFileFactory.html#aeee396bfdbb6ac24c57e5c73c30ec105',1,'sf::SoundFileFactory']]], + ['registerwriter_6',['registerWriter',['../classsf_1_1SoundFileFactory.html#abb6e082ea3fedf22c8648113d1be5755',1,'sf::SoundFileFactory']]], + ['remove_7',['remove',['../classsf_1_1SocketSelector.html#a98b6ab693a65b82caa375639232357c1',1,'sf::SocketSelector']]], + ['renamefile_8',['renameFile',['../classsf_1_1Ftp.html#a8f99251d7153e1dc26723e4006deb764',1,'sf::Ftp']]], + ['renderstates_9',['RenderStates',['../classsf_1_1RenderStates.html#a885bf14070d0d5391f062f62b270b7d0',1,'sf::RenderStates::RenderStates()'],['../classsf_1_1RenderStates.html#acac8830a593c8a4523ac2fdf3cac8a01',1,'sf::RenderStates::RenderStates(const BlendMode &theBlendMode)'],['../classsf_1_1RenderStates.html#a3e99cad6ab05971d40357949930ed890',1,'sf::RenderStates::RenderStates(const Transform &theTransform)'],['../classsf_1_1RenderStates.html#a8f4ca3be0e27dafea0c4ab8547439bb1',1,'sf::RenderStates::RenderStates(const Texture *theTexture)'],['../classsf_1_1RenderStates.html#a39f94233f464739d8d8522f3aefe97d0',1,'sf::RenderStates::RenderStates(const Shader *theShader)'],['../classsf_1_1RenderStates.html#ab5eda13cd8c79c74eba3b1b0df817d67',1,'sf::RenderStates::RenderStates(const BlendMode &theBlendMode, const Transform &theTransform, const Texture *theTexture, const Shader *theShader)']]], + ['rendertarget_10',['RenderTarget',['../classsf_1_1RenderTarget.html#a2997c96cbd93cb8ce0aba2ddae35b86f',1,'sf::RenderTarget']]], + ['rendertexture_11',['RenderTexture',['../classsf_1_1RenderTexture.html#a19ee6e5b4c40ad251803389b3953a9c6',1,'sf::RenderTexture']]], + ['renderwindow_12',['RenderWindow',['../classsf_1_1RenderWindow.html#a839bbf336bdcafb084dafc3076fc9021',1,'sf::RenderWindow::RenderWindow()'],['../classsf_1_1RenderWindow.html#aebef983e01f677bf5a66cefc4d547647',1,'sf::RenderWindow::RenderWindow(VideoMode mode, const String &title, Uint32 style=Style::Default, const ContextSettings &settings=ContextSettings())'],['../classsf_1_1RenderWindow.html#a25c0af7d515e710b6eebc9c6be952aa5',1,'sf::RenderWindow::RenderWindow(WindowHandle handle, const ContextSettings &settings=ContextSettings())']]], + ['replace_13',['replace',['../classsf_1_1String.html#ad460e628c287b0fa88deba2eb0b6744b',1,'sf::String::replace(std::size_t position, std::size_t length, const String &replaceWith)'],['../classsf_1_1String.html#a82bbfee2bf23c641e5361ad505c07921',1,'sf::String::replace(const String &searchFor, const String &replaceWith)']]], + ['request_14',['Request',['../classsf_1_1Http_1_1Request.html#a8e89d9e8ffcc1163259b35d79809a61c',1,'sf::Http::Request']]], + ['requestfocus_15',['requestFocus',['../classsf_1_1WindowBase.html#a448770d2372d8df0a1ad6b1c7cce3c89',1,'sf::WindowBase']]], + ['reset_16',['reset',['../classsf_1_1View.html#ac95b636eafab3922b7e8304fb6c00d7d',1,'sf::View']]], + ['resetbuffer_17',['resetBuffer',['../classsf_1_1Sound.html#acb7289d45e06fb76b8292ac84beb82a7',1,'sf::Sound']]], + ['resetglstates_18',['resetGLStates',['../classsf_1_1RenderTarget.html#aac7504990d27dada4bfe3c7866920765',1,'sf::RenderTarget']]], + ['resize_19',['resize',['../classsf_1_1VertexArray.html#a0c0fe239e8f9a54e64d3bbc96bf548c0',1,'sf::VertexArray']]], + ['response_20',['Response',['../classsf_1_1Ftp_1_1Response.html#af300fffd4862774102f978eb22f85d9b',1,'sf::Ftp::Response::Response()'],['../classsf_1_1Http_1_1Response.html#a2e51c89356fe6a007c448a841a9ec08c',1,'sf::Http::Response::Response()']]], + ['restart_21',['restart',['../classsf_1_1Clock.html#a123e2627f2943e5ecaa1db0c7df3231b',1,'sf::Clock']]], + ['rotate_22',['rotate',['../classsf_1_1Transform.html#ad09ce22a1fb08709f66f30befc7b2e7b',1,'sf::Transform::rotate(float angle)'],['../classsf_1_1Transform.html#ad78237e81d1de866d1b3c040ad003971',1,'sf::Transform::rotate(float angle, float centerX, float centerY)'],['../classsf_1_1Transform.html#a11aa9a4fbd9254e7d22b96f92f018d09',1,'sf::Transform::rotate(float angle, const Vector2f &center)'],['../classsf_1_1Transformable.html#af8a5ffddc0d93f238fee3bf8efe1ebda',1,'sf::Transformable::rotate()'],['../classsf_1_1View.html#a5fd3901aae1845586ca40add94faa378',1,'sf::View::rotate()']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/groups_0.js b/Space-Invaders/sfml/doc/html/search/groups_0.js new file mode 100644 index 000000000..e6c32a930 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/groups_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['audio_20module_0',['Audio module',['../group__audio.html',1,'']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/groups_1.js b/Space-Invaders/sfml/doc/html/search/groups_1.js new file mode 100644 index 000000000..93ff063ce --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/groups_1.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['graphics_20module_0',['Graphics module',['../group__graphics.html',1,'']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/groups_2.js b/Space-Invaders/sfml/doc/html/search/groups_2.js new file mode 100644 index 000000000..140e5007b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/groups_2.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['network_20module_0',['Network module',['../group__network.html',1,'']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/groups_3.js b/Space-Invaders/sfml/doc/html/search/groups_3.js new file mode 100644 index 000000000..bd4e7c03b --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/groups_3.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['system_20module_0',['System module',['../group__system.html',1,'']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/groups_4.js b/Space-Invaders/sfml/doc/html/search/groups_4.js new file mode 100644 index 000000000..03790ffd2 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/groups_4.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['window_20module_0',['Window module',['../group__window.html',1,'']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/mag.svg b/Space-Invaders/sfml/doc/html/search/mag.svg new file mode 100644 index 000000000..9f46b301e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/mag.svg @@ -0,0 +1,37 @@ + + + + + + image/svg+xml + + + + + + + + + diff --git a/Space-Invaders/sfml/doc/html/search/mag_d.svg b/Space-Invaders/sfml/doc/html/search/mag_d.svg new file mode 100644 index 000000000..b9a814c78 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/mag_d.svg @@ -0,0 +1,37 @@ + + + + + + image/svg+xml + + + + + + + + + diff --git a/Space-Invaders/sfml/doc/html/search/mag_sel.svg b/Space-Invaders/sfml/doc/html/search/mag_sel.svg new file mode 100644 index 000000000..03626f64a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/mag_sel.svg @@ -0,0 +1,74 @@ + + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/Space-Invaders/sfml/doc/html/search/mag_seld.svg b/Space-Invaders/sfml/doc/html/search/mag_seld.svg new file mode 100644 index 000000000..6e720dcc9 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/mag_seld.svg @@ -0,0 +1,74 @@ + + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/Space-Invaders/sfml/doc/html/search/namespaces_0.js b/Space-Invaders/sfml/doc/html/search/namespaces_0.js new file mode 100644 index 000000000..a8a783a6d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/namespaces_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['glsl_0',['Glsl',['../namespacesf_1_1Glsl.html',1,'sf']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/pages_0.js b/Space-Invaders/sfml/doc/html/search/pages_0.js new file mode 100644 index 000000000..4d858458c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/pages_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['deprecated_20list_0',['Deprecated List',['../deprecated.html',1,'']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/pages_1.js b/Space-Invaders/sfml/doc/html/search/pages_1.js new file mode 100644 index 000000000..6ed4e098c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/pages_1.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['sfml_20documentation_0',['SFML Documentation',['../index.html',1,'']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/related_0.js b/Space-Invaders/sfml/doc/html/search/related_0.js new file mode 100644 index 000000000..d45699f07 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/related_0.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['operator_3c_0',['operator<',['../classsf_1_1IpAddress.html#a4886da3f195b8c30d415a94a7009fdd7',1,'sf::IpAddress']]] +]; diff --git a/Space-Invaders/sfml/doc/html/search/search.css b/Space-Invaders/sfml/doc/html/search/search.css new file mode 100644 index 000000000..7b88a1597 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/search.css @@ -0,0 +1,292 @@ +/*---------------- Search Box positioning */ + +#navrow1 .tablist > li:last-child { + /* This
  • object is the parent of the search bar */ + display: flex; + justify-content: center; + align-items: center; + height: 36px; + margin-right: 1em; + float: right; +} + +/*---------------- Search box styling */ + +.SRPage * { + font-weight: normal; + line-height: normal; +} + +dark-mode-toggle { + margin-left: 5px; + display: flex; + float: right; +} + +#MSearchBox { + display: inline-block; + white-space : nowrap; + background: white; + border-radius: 0.65em; + box-shadow: inset 0.5px 0.5px 3px 0px #555; + z-index: 102; +} + +#MSearchBox .left { + display: inline-block; + vertical-align: middle; + height: 1.4em; +} + +#MSearchSelect { + display: inline-block; + vertical-align: middle; + width: 20px; + height: 19px; + background-image: url('mag_sel.svg'); + margin: 0 0 0 0.3em; + padding: 0; +} + +#MSearchSelectExt { + display: inline-block; + vertical-align: middle; + width: 10px; + height: 19px; + background-image: url('mag.svg'); + margin: 0 0 0 0.5em; + padding: 0; +} + + +#MSearchField { + display: inline-block; + vertical-align: middle; + width: 7.5em; + height: 19px; + margin: 0 0.15em; + padding: 0; + line-height: 1em; + border:none; + color: #909090; + outline: none; + font-family: Arial,Verdana,sans-serif; + -webkit-border-radius: 0px; + border-radius: 0px; + background: none; +} + +@media(hover: none) { + /* to avoid zooming on iOS */ + #MSearchField { + font-size: 16px; + } +} + +#MSearchBox .right { + display: inline-block; + vertical-align: middle; + width: 1.4em; + height: 1.4em; +} + +#MSearchClose { + display: none; + font-size: inherit; + background : none; + border: none; + margin: 0; + padding: 0; + outline: none; + +} + +#MSearchCloseImg { + padding: 0.3em; + margin: 0; +} + +.MSearchBoxActive #MSearchField { + color: black; +} + + + +/*---------------- Search filter selection */ + +#MSearchSelectWindow { + display: none; + position: absolute; + left: 0; top: 0; + border: 1px solid #90A5CE; + background-color: #F9FAFC; + z-index: 10001; + padding-top: 4px; + padding-bottom: 4px; + -moz-border-radius: 4px; + -webkit-border-top-left-radius: 4px; + -webkit-border-top-right-radius: 4px; + -webkit-border-bottom-left-radius: 4px; + -webkit-border-bottom-right-radius: 4px; + -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); +} + +.SelectItem { + font: 8pt Arial,Verdana,sans-serif; + padding-left: 2px; + padding-right: 12px; + border: 0px; +} + +span.SelectionMark { + margin-right: 4px; + font-family: monospace,fixed; + outline-style: none; + text-decoration: none; +} + +a.SelectItem { + display: block; + outline-style: none; + color: black; + text-decoration: none; + padding-left: 6px; + padding-right: 12px; +} + +a.SelectItem:focus, +a.SelectItem:active { + color: black; + outline-style: none; + text-decoration: none; +} + +a.SelectItem:hover { + color: white; + background-color: #3D578C; + outline-style: none; + text-decoration: none; + cursor: pointer; + display: block; +} + +/*---------------- Search results window */ + +iframe#MSearchResults { + /*width: 60ex;*/ + height: 15em; +} + +#MSearchResultsWindow { + display: none; + position: absolute; + left: 0; top: 0; + border: 1px solid black; + background-color: #EEF1F7; + z-index:10000; + width: 300px; + height: 400px; + overflow: auto; +} + +/* ----------------------------------- */ + + +#SRIndex { + clear:both; +} + +.SREntry { + font-size: 10pt; + padding-left: 1ex; +} + +.SRPage .SREntry { + font-size: 8pt; + padding: 1px 5px; +} + +div.SRPage { + margin: 5px 2px; + background-color: #EEF1F7; +} + +.SRChildren { + padding-left: 3ex; padding-bottom: .5em +} + +.SRPage .SRChildren { + display: none; +} + +.SRSymbol { + font-weight: bold; + color: #425E97; + font-family: Arial,Verdana,sans-serif; + text-decoration: none; + outline: none; +} + +a.SRScope { + display: block; + color: #425E97; + font-family: Arial,Verdana,sans-serif; + font-size: 8pt; + text-decoration: none; + outline: none; +} + +a.SRSymbol:focus, a.SRSymbol:active, +a.SRScope:focus, a.SRScope:active { + text-decoration: underline; +} + +span.SRScope { + padding-left: 4px; + font-family: Arial,Verdana,sans-serif; +} + +.SRPage .SRStatus { + padding: 2px 5px; + font-size: 8pt; + font-style: italic; + font-family: Arial,Verdana,sans-serif; +} + +.SRResult { + display: none; +} + +div.searchresults { + margin-left: 10px; + margin-right: 10px; +} + +/*---------------- External search page results */ + +.pages b { + color: white; + padding: 5px 5px 3px 5px; + background-image: url("../tab_a.png"); + background-repeat: repeat-x; + text-shadow: 0 1px 1px #000000; +} + +.pages { + line-height: 17px; + margin-left: 4px; + text-decoration: none; +} + +.hl { + font-weight: bold; +} + +#searchresults { + margin-bottom: 20px; +} + +.searchpages { + margin-top: 10px; +} + diff --git a/Space-Invaders/sfml/doc/html/search/search.js b/Space-Invaders/sfml/doc/html/search/search.js new file mode 100644 index 000000000..e103a2621 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/search/search.js @@ -0,0 +1,816 @@ +/* + @licstart The following is the entire license notice for the JavaScript code in this file. + + The MIT License (MIT) + + Copyright (C) 1997-2020 by Dimitri van Heesch + + Permission is hereby granted, free of charge, to any person obtaining a copy of this software + and associated documentation files (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, publish, distribute, + sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all copies or + substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + @licend The above is the entire license notice for the JavaScript code in this file + */ +function convertToId(search) +{ + var result = ''; + for (i=0;i do a search + { + this.Search(); + } + } + + this.OnSearchSelectKey = function(evt) + { + var e = (evt) ? evt : window.event; // for IE + if (e.keyCode==40 && this.searchIndex0) // Up + { + this.searchIndex--; + this.OnSelectItem(this.searchIndex); + } + else if (e.keyCode==13 || e.keyCode==27) + { + this.OnSelectItem(this.searchIndex); + this.CloseSelectionWindow(); + this.DOMSearchField().focus(); + } + return false; + } + + // --------- Actions + + // Closes the results window. + this.CloseResultsWindow = function() + { + this.DOMPopupSearchResultsWindow().style.display = 'none'; + this.DOMSearchClose().style.display = 'none'; + this.Activate(false); + } + + this.CloseSelectionWindow = function() + { + this.DOMSearchSelectWindow().style.display = 'none'; + } + + // Performs a search. + this.Search = function() + { + this.keyTimeout = 0; + + // strip leading whitespace + var searchValue = this.DOMSearchField().value.replace(/^ +/, ""); + + var code = searchValue.toLowerCase().charCodeAt(0); + var idxChar = searchValue.substr(0, 1).toLowerCase(); + if ( 0xD800 <= code && code <= 0xDBFF && searchValue > 1) // surrogate pair + { + idxChar = searchValue.substr(0, 2); + } + + var jsFile; + + var idx = indexSectionsWithContent[this.searchIndex].indexOf(idxChar); + if (idx!=-1) + { + var hexCode=idx.toString(16); + jsFile = this.resultsPath + indexSectionNames[this.searchIndex] + '_' + hexCode + '.js'; + } + + var loadJS = function(url, impl, loc){ + var scriptTag = document.createElement('script'); + scriptTag.src = url; + scriptTag.onload = impl; + scriptTag.onreadystatechange = impl; + loc.appendChild(scriptTag); + } + + var domPopupSearchResultsWindow = this.DOMPopupSearchResultsWindow(); + var domSearchBox = this.DOMSearchBox(); + var domPopupSearchResults = this.DOMPopupSearchResults(); + var domSearchClose = this.DOMSearchClose(); + var resultsPath = this.resultsPath; + + var handleResults = function() { + document.getElementById("Loading").style.display="none"; + if (typeof searchData !== 'undefined') { + createResults(resultsPath); + document.getElementById("NoMatches").style.display="none"; + } + + searchResults.Search(searchValue); + + if (domPopupSearchResultsWindow.style.display!='block') + { + domSearchClose.style.display = 'inline-block'; + var left = getXPos(domSearchBox) + 150; + var top = getYPos(domSearchBox) + 20; + domPopupSearchResultsWindow.style.display = 'block'; + left -= domPopupSearchResults.offsetWidth; + var maxWidth = document.body.clientWidth; + var maxHeight = document.body.clientHeight; + var width = 300; + if (left<10) left=10; + if (width+left+8>maxWidth) width=maxWidth-left-8; + var height = 400; + if (height+top+8>maxHeight) height=maxHeight-top-8; + domPopupSearchResultsWindow.style.top = top + 'px'; + domPopupSearchResultsWindow.style.left = left + 'px'; + domPopupSearchResultsWindow.style.width = width + 'px'; + domPopupSearchResultsWindow.style.height = height + 'px'; + } + } + + if (jsFile) { + loadJS(jsFile, handleResults, this.DOMPopupSearchResultsWindow()); + } else { + handleResults(); + } + + this.lastSearchValue = searchValue; + } + + // -------- Activation Functions + + // Activates or deactivates the search panel, resetting things to + // their default values if necessary. + this.Activate = function(isActive) + { + if (isActive || // open it + this.DOMPopupSearchResultsWindow().style.display == 'block' + ) + { + this.DOMSearchBox().className = 'MSearchBoxActive'; + this.searchActive = true; + } + else if (!isActive) // directly remove the panel + { + this.DOMSearchBox().className = 'MSearchBoxInactive'; + this.searchActive = false; + this.lastSearchValue = '' + this.lastResultsPage = ''; + this.DOMSearchField().value = ''; + } + } +} + +// ----------------------------------------------------------------------- + +// The class that handles everything on the search results page. +function SearchResults(name) +{ + // The number of matches from the last run of . + this.lastMatchCount = 0; + this.lastKey = 0; + this.repeatOn = false; + + // Toggles the visibility of the passed element ID. + this.FindChildElement = function(id) + { + var parentElement = document.getElementById(id); + var element = parentElement.firstChild; + + while (element && element!=parentElement) + { + if (element.nodeName.toLowerCase() == 'div' && element.className == 'SRChildren') + { + return element; + } + + if (element.nodeName.toLowerCase() == 'div' && element.hasChildNodes()) + { + element = element.firstChild; + } + else if (element.nextSibling) + { + element = element.nextSibling; + } + else + { + do + { + element = element.parentNode; + } + while (element && element!=parentElement && !element.nextSibling); + + if (element && element!=parentElement) + { + element = element.nextSibling; + } + } + } + } + + this.Toggle = function(id) + { + var element = this.FindChildElement(id); + if (element) + { + if (element.style.display == 'block') + { + element.style.display = 'none'; + } + else + { + element.style.display = 'block'; + } + } + } + + // Searches for the passed string. If there is no parameter, + // it takes it from the URL query. + // + // Always returns true, since other documents may try to call it + // and that may or may not be possible. + this.Search = function(search) + { + if (!search) // get search word from URL + { + search = window.location.search; + search = search.substring(1); // Remove the leading '?' + search = unescape(search); + } + + search = search.replace(/^ +/, ""); // strip leading spaces + search = search.replace(/ +$/, ""); // strip trailing spaces + search = search.toLowerCase(); + search = convertToId(search); + + var resultRows = document.getElementsByTagName("div"); + var matches = 0; + + var i = 0; + while (i < resultRows.length) + { + var row = resultRows.item(i); + if (row.className == "SRResult") + { + var rowMatchName = row.id.toLowerCase(); + rowMatchName = rowMatchName.replace(/^sr\d*_/, ''); // strip 'sr123_' + + if (search.length<=rowMatchName.length && + rowMatchName.substr(0, search.length)==search) + { + row.style.display = 'block'; + matches++; + } + else + { + row.style.display = 'none'; + } + } + i++; + } + document.getElementById("Searching").style.display='none'; + if (matches == 0) // no results + { + document.getElementById("NoMatches").style.display='block'; + } + else // at least one result + { + document.getElementById("NoMatches").style.display='none'; + } + this.lastMatchCount = matches; + return true; + } + + // return the first item with index index or higher that is visible + this.NavNext = function(index) + { + var focusItem; + while (1) + { + var focusName = 'Item'+index; + focusItem = document.getElementById(focusName); + if (focusItem && focusItem.parentNode.parentNode.style.display=='block') + { + break; + } + else if (!focusItem) // last element + { + break; + } + focusItem=null; + index++; + } + return focusItem; + } + + this.NavPrev = function(index) + { + var focusItem; + while (1) + { + var focusName = 'Item'+index; + focusItem = document.getElementById(focusName); + if (focusItem && focusItem.parentNode.parentNode.style.display=='block') + { + break; + } + else if (!focusItem) // last element + { + break; + } + focusItem=null; + index--; + } + return focusItem; + } + + this.ProcessKeys = function(e) + { + if (e.type == "keydown") + { + this.repeatOn = false; + this.lastKey = e.keyCode; + } + else if (e.type == "keypress") + { + if (!this.repeatOn) + { + if (this.lastKey) this.repeatOn = true; + return false; // ignore first keypress after keydown + } + } + else if (e.type == "keyup") + { + this.lastKey = 0; + this.repeatOn = false; + } + return this.lastKey!=0; + } + + this.Nav = function(evt,itemIndex) + { + var e = (evt) ? evt : window.event; // for IE + if (e.keyCode==13) return true; + if (!this.ProcessKeys(e)) return false; + + if (this.lastKey==38) // Up + { + var newIndex = itemIndex-1; + var focusItem = this.NavPrev(newIndex); + if (focusItem) + { + var child = this.FindChildElement(focusItem.parentNode.parentNode.id); + if (child && child.style.display == 'block') // children visible + { + var n=0; + var tmpElem; + while (1) // search for last child + { + tmpElem = document.getElementById('Item'+newIndex+'_c'+n); + if (tmpElem) + { + focusItem = tmpElem; + } + else // found it! + { + break; + } + n++; + } + } + } + if (focusItem) + { + focusItem.focus(); + } + else // return focus to search field + { + document.getElementById("MSearchField").focus(); + } + } + else if (this.lastKey==40) // Down + { + var newIndex = itemIndex+1; + var focusItem; + var item = document.getElementById('Item'+itemIndex); + var elem = this.FindChildElement(item.parentNode.parentNode.id); + if (elem && elem.style.display == 'block') // children visible + { + focusItem = document.getElementById('Item'+itemIndex+'_c0'); + } + if (!focusItem) focusItem = this.NavNext(newIndex); + if (focusItem) focusItem.focus(); + } + else if (this.lastKey==39) // Right + { + var item = document.getElementById('Item'+itemIndex); + var elem = this.FindChildElement(item.parentNode.parentNode.id); + if (elem) elem.style.display = 'block'; + } + else if (this.lastKey==37) // Left + { + var item = document.getElementById('Item'+itemIndex); + var elem = this.FindChildElement(item.parentNode.parentNode.id); + if (elem) elem.style.display = 'none'; + } + else if (this.lastKey==27) // Escape + { + searchBox.CloseResultsWindow(); + document.getElementById("MSearchField").focus(); + } + else if (this.lastKey==13) // Enter + { + return true; + } + return false; + } + + this.NavChild = function(evt,itemIndex,childIndex) + { + var e = (evt) ? evt : window.event; // for IE + if (e.keyCode==13) return true; + if (!this.ProcessKeys(e)) return false; + + if (this.lastKey==38) // Up + { + if (childIndex>0) + { + var newIndex = childIndex-1; + document.getElementById('Item'+itemIndex+'_c'+newIndex).focus(); + } + else // already at first child, jump to parent + { + document.getElementById('Item'+itemIndex).focus(); + } + } + else if (this.lastKey==40) // Down + { + var newIndex = childIndex+1; + var elem = document.getElementById('Item'+itemIndex+'_c'+newIndex); + if (!elem) // last child, jump to parent next parent + { + elem = this.NavNext(itemIndex+1); + } + if (elem) + { + elem.focus(); + } + } + else if (this.lastKey==27) // Escape + { + searchBox.CloseResultsWindow(); + document.getElementById("MSearchField").focus(); + } + else if (this.lastKey==13) // Enter + { + return true; + } + return false; + } +} + +function setKeyActions(elem,action) +{ + elem.setAttribute('onkeydown',action); + elem.setAttribute('onkeypress',action); + elem.setAttribute('onkeyup',action); +} + +function setClassAttr(elem,attr) +{ + elem.setAttribute('class',attr); + elem.setAttribute('className',attr); +} + +function createResults(resultsPath) +{ + var results = document.getElementById("SRResults"); + results.innerHTML = ''; + for (var e=0; e .SRPage { + background-color: #EAF5DB; +} +a.SRSymbol { + color: rgb(70, 100, 30); +} +a.SRSymbol:hover { + text-decoration: underline; +} +a.SRScope { + color: rgb(70, 100, 30); +} +a.SRScope:hover { + text-decoration: underline; +} +#MSearchSelectWindow { + background-color: #EAF5DB; +} +#MSearchSelectWindow > a.SelectItem { + color: #333; + text-decoration: none; +} +#MSearchSelectWindow > a.SelectItem:hover { + color: white; + background-color: #8CC841; + text-decoration: none; +} diff --git a/Space-Invaders/sfml/doc/html/splitbar.png b/Space-Invaders/sfml/doc/html/splitbar.png new file mode 100644 index 000000000..fe895f2c5 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/splitbar.png differ diff --git a/Space-Invaders/sfml/doc/html/splitbard.png b/Space-Invaders/sfml/doc/html/splitbard.png new file mode 100644 index 000000000..8367416d7 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/splitbard.png differ diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1BlendMode-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1BlendMode-members.html new file mode 100644 index 000000000..7d2933384 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1BlendMode-members.html @@ -0,0 +1,136 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::BlendMode Member List
    +
    +
    + +

    This is the complete list of members for sf::BlendMode, including all inherited members.

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Add enum valuesf::BlendMode
    alphaDstFactorsf::BlendMode
    alphaEquationsf::BlendMode
    alphaSrcFactorsf::BlendMode
    BlendMode()sf::BlendMode
    BlendMode(Factor sourceFactor, Factor destinationFactor, Equation blendEquation=Add)sf::BlendMode
    BlendMode(Factor colorSourceFactor, Factor colorDestinationFactor, Equation colorBlendEquation, Factor alphaSourceFactor, Factor alphaDestinationFactor, Equation alphaBlendEquation)sf::BlendMode
    colorDstFactorsf::BlendMode
    colorEquationsf::BlendMode
    colorSrcFactorsf::BlendMode
    DstAlpha enum valuesf::BlendMode
    DstColor enum valuesf::BlendMode
    Equation enum namesf::BlendMode
    Factor enum namesf::BlendMode
    Max enum valuesf::BlendMode
    Min enum valuesf::BlendMode
    One enum valuesf::BlendMode
    OneMinusDstAlpha enum valuesf::BlendMode
    OneMinusDstColor enum valuesf::BlendMode
    OneMinusSrcAlpha enum valuesf::BlendMode
    OneMinusSrcColor enum valuesf::BlendMode
    operator!=(const BlendMode &left, const BlendMode &right)sf::BlendModerelated
    operator==(const BlendMode &left, const BlendMode &right)sf::BlendModerelated
    ReverseSubtract enum valuesf::BlendMode
    SrcAlpha enum valuesf::BlendMode
    SrcColor enum valuesf::BlendMode
    Subtract enum valuesf::BlendMode
    Zero enum valuesf::BlendMode
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1BlendMode.html b/Space-Invaders/sfml/doc/html/structsf_1_1BlendMode.html new file mode 100644 index 000000000..a3f33484a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1BlendMode.html @@ -0,0 +1,634 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Types | +Public Member Functions | +Public Attributes | +Related Functions | +List of all members
    +
    sf::BlendMode Class Reference
    Graphics module
    +
    +
    + +

    Blending modes for drawing. + More...

    + +

    #include <SFML/Graphics/BlendMode.hpp>

    + + + + + + + + +

    +Public Types

    enum  Factor {
    +  Zero +, One +, SrcColor +, OneMinusSrcColor +,
    +  DstColor +, OneMinusDstColor +, SrcAlpha +, OneMinusSrcAlpha +,
    +  DstAlpha +, OneMinusDstAlpha +
    + }
     Enumeration of the blending factors. More...
     
    enum  Equation {
    +  Add +, Subtract +, ReverseSubtract +, Min +,
    +  Max +
    + }
     Enumeration of the blending equations. More...
     
    + + + + + + + + + + +

    +Public Member Functions

     BlendMode ()
     Default constructor.
     
     BlendMode (Factor sourceFactor, Factor destinationFactor, Equation blendEquation=Add)
     Construct the blend mode given the factors and equation.
     
     BlendMode (Factor colorSourceFactor, Factor colorDestinationFactor, Equation colorBlendEquation, Factor alphaSourceFactor, Factor alphaDestinationFactor, Equation alphaBlendEquation)
     Construct the blend mode given the factors and equation.
     
    + + + + + + + + + + + + + + + + + + + +

    +Public Attributes

    Factor colorSrcFactor
     Source blending factor for the color channels.
     
    Factor colorDstFactor
     Destination blending factor for the color channels.
     
    Equation colorEquation
     Blending equation for the color channels.
     
    Factor alphaSrcFactor
     Source blending factor for the alpha channel.
     
    Factor alphaDstFactor
     Destination blending factor for the alpha channel.
     
    Equation alphaEquation
     Blending equation for the alpha channel.
     
    + + + + + + + + +

    +Related Functions

    (Note that these are not member functions.)

    +
    bool operator== (const BlendMode &left, const BlendMode &right)
     Overload of the == operator.
     
    bool operator!= (const BlendMode &left, const BlendMode &right)
     Overload of the != operator.
     
    +

    Detailed Description

    +

    Blending modes for drawing.

    +

    sf::BlendMode is a class that represents a blend mode.

    +

    A blend mode determines how the colors of an object you draw are mixed with the colors that are already in the buffer.

    +

    The class is composed of 6 components, each of which has its own public member variable:

    +

    The source factor specifies how the pixel you are drawing contributes to the final color. The destination factor specifies how the pixel already drawn in the buffer contributes to the final color.

    +

    The color channels RGB (red, green, blue; simply referred to as color) and A (alpha; the transparency) can be treated separately. This separation can be useful for specific blend modes, but most often you won't need it and will simply treat the color as a single unit.

    +

    The blend factors and equations correspond to their OpenGL equivalents. In general, the color of the resulting pixel is calculated according to the following formula (src is the color of the source pixel, dst the color of the destination pixel, the other variables correspond to the public members, with the equations being + or - operators):

    dst.rgb = colorSrcFactor * src.rgb (colorEquation) colorDstFactor * dst.rgb
    +
    dst.a = alphaSrcFactor * src.a (alphaEquation) alphaDstFactor * dst.a
    +
    sf::BlendMode::colorSrcFactor
    Factor colorSrcFactor
    Source blending factor for the color channels.
    Definition: BlendMode.hpp:117
    +
    sf::BlendMode::alphaEquation
    Equation alphaEquation
    Blending equation for the alpha channel.
    Definition: BlendMode.hpp:122
    +
    sf::BlendMode::alphaSrcFactor
    Factor alphaSrcFactor
    Source blending factor for the alpha channel.
    Definition: BlendMode.hpp:120
    +
    sf::BlendMode::alphaDstFactor
    Factor alphaDstFactor
    Destination blending factor for the alpha channel.
    Definition: BlendMode.hpp:121
    +
    sf::BlendMode::colorDstFactor
    Factor colorDstFactor
    Destination blending factor for the color channels.
    Definition: BlendMode.hpp:118
    +
    sf::BlendMode::colorEquation
    Equation colorEquation
    Blending equation for the color channels.
    Definition: BlendMode.hpp:119
    +

    All factors and colors are represented as floating point numbers between 0 and 1. Where necessary, the result is clamped to fit in that range.

    +

    The most common blending modes are defined as constants in the sf namespace:

    +
    sf::BlendMode alphaBlending = sf::BlendAlpha;
    +
    sf::BlendMode additiveBlending = sf::BlendAdd;
    +
    sf::BlendMode multiplicativeBlending = sf::BlendMultiply;
    +
    sf::BlendMode noBlending = sf::BlendNone;
    +
    sf::BlendMode
    Blending modes for drawing.
    Definition: BlendMode.hpp:42
    +

    In SFML, a blend mode can be specified every time you draw a sf::Drawable object to a render target. It is part of the sf::RenderStates compound that is passed to the member function sf::RenderTarget::draw().

    +
    See also
    sf::RenderStates, sf::RenderTarget
    + +

    Definition at line 41 of file BlendMode.hpp.

    +

    Member Enumeration Documentation

    + +

    ◆ Equation

    + +
    +
    + + + + +
    enum sf::BlendMode::Equation
    +
    + +

    Enumeration of the blending equations.

    +

    The equations are mapped directly to their OpenGL equivalents, specified by glBlendEquation() or glBlendEquationSeparate().

    + + + + + + +
    Enumerator
    Add 

    Pixel = Src * SrcFactor + Dst * DstFactor.

    +
    Subtract 

    Pixel = Src * SrcFactor - Dst * DstFactor.

    +
    ReverseSubtract 

    Pixel = Dst * DstFactor - Src * SrcFactor.

    +
    Min 

    Pixel = min(Dst, Src)

    +
    Max 

    Pixel = max(Dst, Src)

    +
    + +

    Definition at line 69 of file BlendMode.hpp.

    + +
    +
    + +

    ◆ Factor

    + +
    +
    + + + + +
    enum sf::BlendMode::Factor
    +
    + +

    Enumeration of the blending factors.

    +

    The factors are mapped directly to their OpenGL equivalents, specified by glBlendFunc() or glBlendFuncSeparate().

    + + + + + + + + + + + +
    Enumerator
    Zero 

    (0, 0, 0, 0)

    +
    One 

    (1, 1, 1, 1)

    +
    SrcColor 

    (src.r, src.g, src.b, src.a)

    +
    OneMinusSrcColor 

    (1, 1, 1, 1) - (src.r, src.g, src.b, src.a)

    +
    DstColor 

    (dst.r, dst.g, dst.b, dst.a)

    +
    OneMinusDstColor 

    (1, 1, 1, 1) - (dst.r, dst.g, dst.b, dst.a)

    +
    SrcAlpha 

    (src.a, src.a, src.a, src.a)

    +
    OneMinusSrcAlpha 

    (1, 1, 1, 1) - (src.a, src.a, src.a, src.a)

    +
    DstAlpha 

    (dst.a, dst.a, dst.a, dst.a)

    +
    OneMinusDstAlpha 

    (1, 1, 1, 1) - (dst.a, dst.a, dst.a, dst.a)

    +
    + +

    Definition at line 49 of file BlendMode.hpp.

    + +
    +
    +

    Constructor & Destructor Documentation

    + +

    ◆ BlendMode() [1/3]

    + +
    +
    + + + + + + + +
    sf::BlendMode::BlendMode ()
    +
    + +

    Default constructor.

    +

    Constructs a blending mode that does alpha blending.

    + +
    +
    + +

    ◆ BlendMode() [2/3]

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    sf::BlendMode::BlendMode (Factor sourceFactor,
    Factor destinationFactor,
    Equation blendEquation = Add 
    )
    +
    + +

    Construct the blend mode given the factors and equation.

    +

    This constructor uses the same factors and equation for both color and alpha components. It also defaults to the Add equation.

    +
    Parameters
    + + + + +
    sourceFactorSpecifies how to compute the source factor for the color and alpha channels.
    destinationFactorSpecifies how to compute the destination factor for the color and alpha channels.
    blendEquationSpecifies how to combine the source and destination colors and alpha.
    +
    +
    + +
    +
    + +

    ◆ BlendMode() [3/3]

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    sf::BlendMode::BlendMode (Factor colorSourceFactor,
    Factor colorDestinationFactor,
    Equation colorBlendEquation,
    Factor alphaSourceFactor,
    Factor alphaDestinationFactor,
    Equation alphaBlendEquation 
    )
    +
    + +

    Construct the blend mode given the factors and equation.

    +
    Parameters
    + + + + + + + +
    colorSourceFactorSpecifies how to compute the source factor for the color channels.
    colorDestinationFactorSpecifies how to compute the destination factor for the color channels.
    colorBlendEquationSpecifies how to combine the source and destination colors.
    alphaSourceFactorSpecifies how to compute the source factor.
    alphaDestinationFactorSpecifies how to compute the destination factor.
    alphaBlendEquationSpecifies how to combine the source and destination alphas.
    +
    +
    + +
    +
    +

    Friends And Related Function Documentation

    + +

    ◆ operator!=()

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    bool operator!= (const BlendMode & left,
    const BlendMode & right 
    )
    +     		+related
    +
    + +

    Overload of the != operator.

    +
    Parameters
    + + + +
    leftLeft operand
    rightRight operand
    +
    +
    +
    Returns
    True if blending modes are different, false if they are equal
    + +
    +
    + +

    ◆ operator==()

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    bool operator== (const BlendMode & left,
    const BlendMode & right 
    )
    +     		+related
    +
    + +

    Overload of the == operator.

    +
    Parameters
    + + + +
    leftLeft operand
    rightRight operand
    +
    +
    +
    Returns
    True if blending modes are equal, false if they are different
    + +
    +
    +

    Member Data Documentation

    + +

    ◆ alphaDstFactor

    + +
    +
    + + + + +
    Factor sf::BlendMode::alphaDstFactor
    +
    + +

    Destination blending factor for the alpha channel.

    + +

    Definition at line 121 of file BlendMode.hpp.

    + +
    +
    + +

    ◆ alphaEquation

    + +
    +
    + + + + +
    Equation sf::BlendMode::alphaEquation
    +
    + +

    Blending equation for the alpha channel.

    + +

    Definition at line 122 of file BlendMode.hpp.

    + +
    +
    + +

    ◆ alphaSrcFactor

    + +
    +
    + + + + +
    Factor sf::BlendMode::alphaSrcFactor
    +
    + +

    Source blending factor for the alpha channel.

    + +

    Definition at line 120 of file BlendMode.hpp.

    + +
    +
    + +

    ◆ colorDstFactor

    + +
    +
    + + + + +
    Factor sf::BlendMode::colorDstFactor
    +
    + +

    Destination blending factor for the color channels.

    + +

    Definition at line 118 of file BlendMode.hpp.

    + +
    +
    + +

    ◆ colorEquation

    + +
    +
    + + + + +
    Equation sf::BlendMode::colorEquation
    +
    + +

    Blending equation for the color channels.

    + +

    Definition at line 119 of file BlendMode.hpp.

    + +
    +
    + +

    ◆ colorSrcFactor

    + +
    +
    + + + + +
    Factor sf::BlendMode::colorSrcFactor
    +
    + +

    Source blending factor for the color channels.

    + +

    Definition at line 117 of file BlendMode.hpp.

    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1ContextSettings-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1ContextSettings-members.html new file mode 100644 index 000000000..fdfa337b4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1ContextSettings-members.html @@ -0,0 +1,120 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::ContextSettings Member List
    +
    +
    + +

    This is the complete list of members for sf::ContextSettings, including all inherited members.

    + + + + + + + + + + + + + +
    antialiasingLevelsf::ContextSettings
    Attribute enum namesf::ContextSettings
    attributeFlagssf::ContextSettings
    ContextSettings(unsigned int depth=0, unsigned int stencil=0, unsigned int antialiasing=0, unsigned int major=1, unsigned int minor=1, unsigned int attributes=Default, bool sRgb=false)sf::ContextSettingsinlineexplicit
    Core enum valuesf::ContextSettings
    Debug enum valuesf::ContextSettings
    Default enum valuesf::ContextSettings
    depthBitssf::ContextSettings
    majorVersionsf::ContextSettings
    minorVersionsf::ContextSettings
    sRgbCapablesf::ContextSettings
    stencilBitssf::ContextSettings
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1ContextSettings.html b/Space-Invaders/sfml/doc/html/structsf_1_1ContextSettings.html new file mode 100644 index 000000000..def847467 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1ContextSettings.html @@ -0,0 +1,408 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Types | +Public Member Functions | +Public Attributes | +List of all members
    +
    sf::ContextSettings Class Reference
    Window module
    +
    +
    + +

    Structure defining the settings of the OpenGL context attached to a window. + More...

    + +

    #include <SFML/Window/ContextSettings.hpp>

    + + + + + +

    +Public Types

    enum  Attribute { Default = 0 +, Core = 1 << 0 +, Debug = 1 << 2 + }
     Enumeration of the context attribute flags. More...
     
    + + + + +

    +Public Member Functions

     ContextSettings (unsigned int depth=0, unsigned int stencil=0, unsigned int antialiasing=0, unsigned int major=1, unsigned int minor=1, unsigned int attributes=Default, bool sRgb=false)
     Default constructor.
     
    + + + + + + + + + + + + + + + + + + + + + + +

    +Public Attributes

    unsigned int depthBits
     Bits of the depth buffer.
     
    unsigned int stencilBits
     Bits of the stencil buffer.
     
    unsigned int antialiasingLevel
     Level of antialiasing.
     
    unsigned int majorVersion
     Major number of the context version to create.
     
    unsigned int minorVersion
     Minor number of the context version to create.
     
    Uint32 attributeFlags
     The attribute flags to create the context with.
     
    bool sRgbCapable
     Whether the context framebuffer is sRGB capable.
     
    +

    Detailed Description

    +

    Structure defining the settings of the OpenGL context attached to a window.

    +

    ContextSettings allows to define several advanced settings of the OpenGL context attached to a window.

    +

    All these settings with the exception of the compatibility flag and anti-aliasing level have no impact on the regular SFML rendering (graphics module), so you may need to use this structure only if you're using SFML as a windowing system for custom OpenGL rendering.

    +

    The depthBits and stencilBits members define the number of bits per pixel requested for the (respectively) depth and stencil buffers.

    +

    antialiasingLevel represents the requested number of multisampling levels for anti-aliasing.

    +

    majorVersion and minorVersion define the version of the OpenGL context that you want. Only versions greater or equal to 3.0 are relevant; versions lesser than 3.0 are all handled the same way (i.e. you can use any version < 3.0 if you don't want an OpenGL 3 context).

    +

    When requesting a context with a version greater or equal to 3.2, you have the option of specifying whether the context should follow the core or compatibility profile of all newer (>= 3.2) OpenGL specifications. For versions 3.0 and 3.1 there is only the core profile. By default a compatibility context is created. You only need to specify the core flag if you want a core profile context to use with your own OpenGL rendering. Warning: The graphics module will not function if you request a core profile context. Make sure the attributes are set to Default if you want to use the graphics module.

    +

    Setting the debug attribute flag will request a context with additional debugging features enabled. Depending on the system, this might be required for advanced OpenGL debugging. OpenGL debugging is disabled by default.

    +

    Special Note for OS X: Apple only supports choosing between either a legacy context (OpenGL 2.1) or a core context (OpenGL version depends on the operating system version but is at least 3.2). Compatibility contexts are not supported. Further information is available on the OpenGL Capabilities Tables page. OS X also currently does not support debug contexts.

    +

    Please note that these values are only a hint. No failure will be reported if one or more of these values are not supported by the system; instead, SFML will try to find the closest valid match. You can then retrieve the settings that the window actually used to create its context, with Window::getSettings().

    + +

    Definition at line 37 of file ContextSettings.hpp.

    +

    Member Enumeration Documentation

    + +

    ◆ Attribute

    + +
    +
    + + + + +
    enum sf::ContextSettings::Attribute
    +
    + +

    Enumeration of the context attribute flags.

    + + + + +
    Enumerator
    Default 

    Non-debug, compatibility context (this and the core attribute are mutually exclusive)

    +
    Core 

    Core attribute.

    +
    Debug 

    Debug attribute.

    +
    + +

    Definition at line 43 of file ContextSettings.hpp.

    + +
    +
    +

    Constructor & Destructor Documentation

    + +

    ◆ ContextSettings()

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    sf::ContextSettings::ContextSettings (unsigned int depth = 0,
    unsigned int stencil = 0,
    unsigned int antialiasing = 0,
    unsigned int major = 1,
    unsigned int minor = 1,
    unsigned int attributes = Default,
    bool sRgb = false 
    )
    +     		+inlineexplicit
    +
    + +

    Default constructor.

    +
    Parameters
    + + + + + + + + +
    depthDepth buffer bits
    stencilStencil buffer bits
    antialiasingAntialiasing level
    majorMajor number of the context version
    minorMinor number of the context version
    attributesAttribute flags of the context
    sRgbsRGB capable framebuffer
    +
    +
    + +

    Definition at line 62 of file ContextSettings.hpp.

    + +
    +
    +

    Member Data Documentation

    + +

    ◆ antialiasingLevel

    + +
    +
    + + + + +
    unsigned int sf::ContextSettings::antialiasingLevel
    +
    + +

    Level of antialiasing.

    + +

    Definition at line 78 of file ContextSettings.hpp.

    + +
    +
    + +

    ◆ attributeFlags

    + +
    +
    + + + + +
    Uint32 sf::ContextSettings::attributeFlags
    +
    + +

    The attribute flags to create the context with.

    + +

    Definition at line 81 of file ContextSettings.hpp.

    + +
    +
    + +

    ◆ depthBits

    + +
    +
    + + + + +
    unsigned int sf::ContextSettings::depthBits
    +
    + +

    Bits of the depth buffer.

    + +

    Definition at line 76 of file ContextSettings.hpp.

    + +
    +
    + +

    ◆ majorVersion

    + +
    +
    + + + + +
    unsigned int sf::ContextSettings::majorVersion
    +
    + +

    Major number of the context version to create.

    + +

    Definition at line 79 of file ContextSettings.hpp.

    + +
    +
    + +

    ◆ minorVersion

    + +
    +
    + + + + +
    unsigned int sf::ContextSettings::minorVersion
    +
    + +

    Minor number of the context version to create.

    + +

    Definition at line 80 of file ContextSettings.hpp.

    + +
    +
    + +

    ◆ sRgbCapable

    + +
    +
    + + + + +
    bool sf::ContextSettings::sRgbCapable
    +
    + +

    Whether the context framebuffer is sRGB capable.

    + +

    Definition at line 82 of file ContextSettings.hpp.

    + +
    +
    + +

    ◆ stencilBits

    + +
    +
    + + + + +
    unsigned int sf::ContextSettings::stencilBits
    +
    + +

    Bits of the stencil buffer.

    + +

    Definition at line 77 of file ContextSettings.hpp.

    + +
    +
    +
    The documentation for this class was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickButtonEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickButtonEvent-members.html new file mode 100644 index 000000000..76dd8b249 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickButtonEvent-members.html @@ -0,0 +1,110 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::JoystickButtonEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::JoystickButtonEvent, including all inherited members.

    + + + +
    buttonsf::Event::JoystickButtonEvent
    joystickIdsf::Event::JoystickButtonEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickButtonEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickButtonEvent.html new file mode 100644 index 000000000..5c54603a0 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickButtonEvent.html @@ -0,0 +1,167 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::JoystickButtonEvent Struct Reference
    +
    +
    + +

    Joystick buttons events parameters (JoystickButtonPressed, JoystickButtonReleased) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + + + + +

    +Public Attributes

    unsigned int joystickId
     Index of the joystick (in range [0 .. Joystick::Count - 1])
     
    unsigned int button
     Index of the button that has been pressed (in range [0 .. Joystick::ButtonCount - 1])
     
    +

    Detailed Description

    +

    Joystick buttons events parameters (JoystickButtonPressed, JoystickButtonReleased)

    + +

    Definition at line 155 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ button

    + +
    +
    + + + + +
    unsigned int sf::Event::JoystickButtonEvent::button
    +
    + +

    Index of the button that has been pressed (in range [0 .. Joystick::ButtonCount - 1])

    + +

    Definition at line 158 of file Event.hpp.

    + +
    +
    + +

    ◆ joystickId

    + +
    +
    + + + + +
    unsigned int sf::Event::JoystickButtonEvent::joystickId
    +
    + +

    Index of the joystick (in range [0 .. Joystick::Count - 1])

    + +

    Definition at line 157 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickConnectEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickConnectEvent-members.html new file mode 100644 index 000000000..2b0523e7e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickConnectEvent-members.html @@ -0,0 +1,109 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::JoystickConnectEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::JoystickConnectEvent, including all inherited members.

    + + +
    joystickIdsf::Event::JoystickConnectEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickConnectEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickConnectEvent.html new file mode 100644 index 000000000..5f55e6568 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickConnectEvent.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::JoystickConnectEvent Struct Reference
    +
    +
    + +

    Joystick connection events parameters (JoystickConnected, JoystickDisconnected) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + +

    +Public Attributes

    unsigned int joystickId
     Index of the joystick (in range [0 .. Joystick::Count - 1])
     
    +

    Detailed Description

    +

    Joystick connection events parameters (JoystickConnected, JoystickDisconnected)

    + +

    Definition at line 134 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ joystickId

    + +
    +
    + + + + +
    unsigned int sf::Event::JoystickConnectEvent::joystickId
    +
    + +

    Index of the joystick (in range [0 .. Joystick::Count - 1])

    + +

    Definition at line 136 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickMoveEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickMoveEvent-members.html new file mode 100644 index 000000000..988d8203e --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickMoveEvent-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::JoystickMoveEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::JoystickMoveEvent, including all inherited members.

    + + + + +
    axissf::Event::JoystickMoveEvent
    joystickIdsf::Event::JoystickMoveEvent
    positionsf::Event::JoystickMoveEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickMoveEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickMoveEvent.html new file mode 100644 index 000000000..0130cc150 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1JoystickMoveEvent.html @@ -0,0 +1,188 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::JoystickMoveEvent Struct Reference
    +
    +
    + +

    Joystick axis move event parameters (JoystickMoved) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + + + + + + + +

    +Public Attributes

    unsigned int joystickId
     Index of the joystick (in range [0 .. Joystick::Count - 1])
     
    Joystick::Axis axis
     Axis on which the joystick moved.
     
    float position
     New position on the axis (in range [-100 .. 100])
     
    +

    Detailed Description

    +

    Joystick axis move event parameters (JoystickMoved)

    + +

    Definition at line 143 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ axis

    + +
    +
    + + + + +
    Joystick::Axis sf::Event::JoystickMoveEvent::axis
    +
    + +

    Axis on which the joystick moved.

    + +

    Definition at line 146 of file Event.hpp.

    + +
    +
    + +

    ◆ joystickId

    + +
    +
    + + + + +
    unsigned int sf::Event::JoystickMoveEvent::joystickId
    +
    + +

    Index of the joystick (in range [0 .. Joystick::Count - 1])

    + +

    Definition at line 145 of file Event.hpp.

    + +
    +
    + +

    ◆ position

    + +
    +
    + + + + +
    float sf::Event::JoystickMoveEvent::position
    +
    + +

    New position on the axis (in range [-100 .. 100])

    + +

    Definition at line 147 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1KeyEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1KeyEvent-members.html new file mode 100644 index 000000000..753e1d9e8 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1KeyEvent-members.html @@ -0,0 +1,114 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::KeyEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::KeyEvent, including all inherited members.

    + + + + + + + +
    altsf::Event::KeyEvent
    codesf::Event::KeyEvent
    controlsf::Event::KeyEvent
    scancodesf::Event::KeyEvent
    shiftsf::Event::KeyEvent
    systemsf::Event::KeyEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1KeyEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1KeyEvent.html new file mode 100644 index 000000000..2299752ec --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1KeyEvent.html @@ -0,0 +1,251 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::KeyEvent Struct Reference
    +
    +
    + +

    Keyboard event parameters (KeyPressed, KeyReleased) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + + + + + + + + + + + + + + + + +

    +Public Attributes

    Keyboard::Key code
     Code of the key that has been pressed.
     
    Keyboard::Scancode scancode
     Physical code of the key that has been pressed.
     
    bool alt
     Is the Alt key pressed?
     
    bool control
     Is the Control key pressed?
     
    bool shift
     Is the Shift key pressed?
     
    bool system
     Is the System key pressed?
     
    +

    Detailed Description

    +

    Keyboard event parameters (KeyPressed, KeyReleased)

    + +

    Definition at line 62 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ alt

    + +
    +
    + + + + +
    bool sf::Event::KeyEvent::alt
    +
    + +

    Is the Alt key pressed?

    + +

    Definition at line 66 of file Event.hpp.

    + +
    +
    + +

    ◆ code

    + +
    +
    + + + + +
    Keyboard::Key sf::Event::KeyEvent::code
    +
    + +

    Code of the key that has been pressed.

    + +

    Definition at line 64 of file Event.hpp.

    + +
    +
    + +

    ◆ control

    + +
    +
    + + + + +
    bool sf::Event::KeyEvent::control
    +
    + +

    Is the Control key pressed?

    + +

    Definition at line 67 of file Event.hpp.

    + +
    +
    + +

    ◆ scancode

    + +
    +
    + + + + +
    Keyboard::Scancode sf::Event::KeyEvent::scancode
    +
    + +

    Physical code of the key that has been pressed.

    + +

    Definition at line 65 of file Event.hpp.

    + +
    +
    + +

    ◆ shift

    + +
    +
    + + + + +
    bool sf::Event::KeyEvent::shift
    +
    + +

    Is the Shift key pressed?

    + +

    Definition at line 68 of file Event.hpp.

    + +
    +
    + +

    ◆ system

    + +
    +
    + + + + +
    bool sf::Event::KeyEvent::system
    +
    + +

    Is the System key pressed?

    + +

    Definition at line 69 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseButtonEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseButtonEvent-members.html new file mode 100644 index 000000000..933c80d76 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseButtonEvent-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::MouseButtonEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::MouseButtonEvent, including all inherited members.

    + + + + +
    buttonsf::Event::MouseButtonEvent
    xsf::Event::MouseButtonEvent
    ysf::Event::MouseButtonEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseButtonEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseButtonEvent.html new file mode 100644 index 000000000..7a3b514d1 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseButtonEvent.html @@ -0,0 +1,188 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::MouseButtonEvent Struct Reference
    +
    +
    + +

    Mouse buttons events parameters (MouseButtonPressed, MouseButtonReleased) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + + + + + + + +

    +Public Attributes

    Mouse::Button button
     Code of the button that has been pressed.
     
    int x
     X position of the mouse pointer, relative to the left of the owner window.
     
    int y
     Y position of the mouse pointer, relative to the top of the owner window.
     
    +

    Detailed Description

    +

    Mouse buttons events parameters (MouseButtonPressed, MouseButtonReleased)

    + +

    Definition at line 96 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ button

    + +
    +
    + + + + +
    Mouse::Button sf::Event::MouseButtonEvent::button
    +
    + +

    Code of the button that has been pressed.

    + +

    Definition at line 98 of file Event.hpp.

    + +
    +
    + +

    ◆ x

    + +
    +
    + + + + +
    int sf::Event::MouseButtonEvent::x
    +
    + +

    X position of the mouse pointer, relative to the left of the owner window.

    + +

    Definition at line 99 of file Event.hpp.

    + +
    +
    + +

    ◆ y

    + +
    +
    + + + + +
    int sf::Event::MouseButtonEvent::y
    +
    + +

    Y position of the mouse pointer, relative to the top of the owner window.

    + +

    Definition at line 100 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseMoveEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseMoveEvent-members.html new file mode 100644 index 000000000..82a86cc06 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseMoveEvent-members.html @@ -0,0 +1,110 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::MouseMoveEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::MouseMoveEvent, including all inherited members.

    + + + +
    xsf::Event::MouseMoveEvent
    ysf::Event::MouseMoveEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseMoveEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseMoveEvent.html new file mode 100644 index 000000000..8d1e38225 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseMoveEvent.html @@ -0,0 +1,167 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::MouseMoveEvent Struct Reference
    +
    +
    + +

    Mouse move event parameters (MouseMoved) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + + + + +

    +Public Attributes

    int x
     X position of the mouse pointer, relative to the left of the owner window.
     
    int y
     Y position of the mouse pointer, relative to the top of the owner window.
     
    +

    Detailed Description

    +

    Mouse move event parameters (MouseMoved)

    + +

    Definition at line 85 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ x

    + +
    +
    + + + + +
    int sf::Event::MouseMoveEvent::x
    +
    + +

    X position of the mouse pointer, relative to the left of the owner window.

    + +

    Definition at line 87 of file Event.hpp.

    + +
    +
    + +

    ◆ y

    + +
    +
    + + + + +
    int sf::Event::MouseMoveEvent::y
    +
    + +

    Y position of the mouse pointer, relative to the top of the owner window.

    + +

    Definition at line 88 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelEvent-members.html new file mode 100644 index 000000000..9a87dd96f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelEvent-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::MouseWheelEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::MouseWheelEvent, including all inherited members.

    + + + + +
    deltasf::Event::MouseWheelEvent
    xsf::Event::MouseWheelEvent
    ysf::Event::MouseWheelEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelEvent.html new file mode 100644 index 000000000..0cb4f988a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelEvent.html @@ -0,0 +1,189 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::MouseWheelEvent Struct Reference
    +
    +
    + +

    Mouse wheel events parameters (MouseWheelMoved) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + + + + + + + +

    +Public Attributes

    int delta
     Number of ticks the wheel has moved (positive is up, negative is down)
     
    int x
     X position of the mouse pointer, relative to the left of the owner window.
     
    int y
     Y position of the mouse pointer, relative to the top of the owner window.
     
    +

    Detailed Description

    +

    Mouse wheel events parameters (MouseWheelMoved)

    +
    Deprecated:
    This event is deprecated and potentially inaccurate. Use MouseWheelScrollEvent instead.
    + +

    Definition at line 110 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ delta

    + +
    +
    + + + + +
    int sf::Event::MouseWheelEvent::delta
    +
    + +

    Number of ticks the wheel has moved (positive is up, negative is down)

    + +

    Definition at line 112 of file Event.hpp.

    + +
    +
    + +

    ◆ x

    + +
    +
    + + + + +
    int sf::Event::MouseWheelEvent::x
    +
    + +

    X position of the mouse pointer, relative to the left of the owner window.

    + +

    Definition at line 113 of file Event.hpp.

    + +
    +
    + +

    ◆ y

    + +
    +
    + + + + +
    int sf::Event::MouseWheelEvent::y
    +
    + +

    Y position of the mouse pointer, relative to the top of the owner window.

    + +

    Definition at line 114 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelScrollEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelScrollEvent-members.html new file mode 100644 index 000000000..28f1a6738 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelScrollEvent-members.html @@ -0,0 +1,112 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::MouseWheelScrollEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::MouseWheelScrollEvent, including all inherited members.

    + + + + + +
    deltasf::Event::MouseWheelScrollEvent
    wheelsf::Event::MouseWheelScrollEvent
    xsf::Event::MouseWheelScrollEvent
    ysf::Event::MouseWheelScrollEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelScrollEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelScrollEvent.html new file mode 100644 index 000000000..24cd64d8c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1MouseWheelScrollEvent.html @@ -0,0 +1,209 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::MouseWheelScrollEvent Struct Reference
    +
    +
    + +

    Mouse wheel events parameters (MouseWheelScrolled) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + + + + + + + + + + +

    +Public Attributes

    Mouse::Wheel wheel
     Which wheel (for mice with multiple ones)
     
    float delta
     Wheel offset (positive is up/left, negative is down/right). High-precision mice may use non-integral offsets.
     
    int x
     X position of the mouse pointer, relative to the left of the owner window.
     
    int y
     Y position of the mouse pointer, relative to the top of the owner window.
     
    +

    Detailed Description

    +

    Mouse wheel events parameters (MouseWheelScrolled)

    + +

    Definition at line 121 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ delta

    + +
    +
    + + + + +
    float sf::Event::MouseWheelScrollEvent::delta
    +
    + +

    Wheel offset (positive is up/left, negative is down/right). High-precision mice may use non-integral offsets.

    + +

    Definition at line 124 of file Event.hpp.

    + +
    +
    + +

    ◆ wheel

    + +
    +
    + + + + +
    Mouse::Wheel sf::Event::MouseWheelScrollEvent::wheel
    +
    + +

    Which wheel (for mice with multiple ones)

    + +

    Definition at line 123 of file Event.hpp.

    + +
    +
    + +

    ◆ x

    + +
    +
    + + + + +
    int sf::Event::MouseWheelScrollEvent::x
    +
    + +

    X position of the mouse pointer, relative to the left of the owner window.

    + +

    Definition at line 125 of file Event.hpp.

    + +
    +
    + +

    ◆ y

    + +
    +
    + + + + +
    int sf::Event::MouseWheelScrollEvent::y
    +
    + +

    Y position of the mouse pointer, relative to the top of the owner window.

    + +

    Definition at line 126 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SensorEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SensorEvent-members.html new file mode 100644 index 000000000..0e7fde1fe --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SensorEvent-members.html @@ -0,0 +1,112 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::SensorEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::SensorEvent, including all inherited members.

    + + + + + +
    typesf::Event::SensorEvent
    xsf::Event::SensorEvent
    ysf::Event::SensorEvent
    zsf::Event::SensorEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SensorEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SensorEvent.html new file mode 100644 index 000000000..e2461556f --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SensorEvent.html @@ -0,0 +1,209 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::SensorEvent Struct Reference
    +
    +
    + +

    Sensor event parameters (SensorChanged) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + + + + + + + + + + +

    +Public Attributes

    Sensor::Type type
     Type of the sensor.
     
    float x
     Current value of the sensor on X axis.
     
    float y
     Current value of the sensor on Y axis.
     
    float z
     Current value of the sensor on Z axis.
     
    +

    Detailed Description

    +

    Sensor event parameters (SensorChanged)

    + +

    Definition at line 176 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ type

    + +
    +
    + + + + +
    Sensor::Type sf::Event::SensorEvent::type
    +
    + +

    Type of the sensor.

    + +

    Definition at line 178 of file Event.hpp.

    + +
    +
    + +

    ◆ x

    + +
    +
    + + + + +
    float sf::Event::SensorEvent::x
    +
    + +

    Current value of the sensor on X axis.

    + +

    Definition at line 179 of file Event.hpp.

    + +
    +
    + +

    ◆ y

    + +
    +
    + + + + +
    float sf::Event::SensorEvent::y
    +
    + +

    Current value of the sensor on Y axis.

    + +

    Definition at line 180 of file Event.hpp.

    + +
    +
    + +

    ◆ z

    + +
    +
    + + + + +
    float sf::Event::SensorEvent::z
    +
    + +

    Current value of the sensor on Z axis.

    + +

    Definition at line 181 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SizeEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SizeEvent-members.html new file mode 100644 index 000000000..6a684f13a --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SizeEvent-members.html @@ -0,0 +1,110 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::SizeEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::SizeEvent, including all inherited members.

    + + + +
    heightsf::Event::SizeEvent
    widthsf::Event::SizeEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SizeEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SizeEvent.html new file mode 100644 index 000000000..05e87e379 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1SizeEvent.html @@ -0,0 +1,167 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::SizeEvent Struct Reference
    +
    +
    + +

    Size events parameters (Resized) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + + + + +

    +Public Attributes

    unsigned int width
     New width, in pixels.
     
    unsigned int height
     New height, in pixels.
     
    +

    Detailed Description

    +

    Size events parameters (Resized)

    + +

    Definition at line 52 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ height

    + +
    +
    + + + + +
    unsigned int sf::Event::SizeEvent::height
    +
    + +

    New height, in pixels.

    + +

    Definition at line 55 of file Event.hpp.

    + +
    +
    + +

    ◆ width

    + +
    +
    + + + + +
    unsigned int sf::Event::SizeEvent::width
    +
    + +

    New width, in pixels.

    + +

    Definition at line 54 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TextEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TextEvent-members.html new file mode 100644 index 000000000..6db5077e6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TextEvent-members.html @@ -0,0 +1,109 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::TextEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::TextEvent, including all inherited members.

    + + +
    unicodesf::Event::TextEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TextEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TextEvent.html new file mode 100644 index 000000000..a89f9e1e3 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TextEvent.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::TextEvent Struct Reference
    +
    +
    + +

    Text event parameters (TextEntered) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + +

    +Public Attributes

    Uint32 unicode
     UTF-32 Unicode value of the character.
     
    +

    Detailed Description

    +

    Text event parameters (TextEntered)

    + +

    Definition at line 76 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ unicode

    + +
    +
    + + + + +
    Uint32 sf::Event::TextEvent::unicode
    +
    + +

    UTF-32 Unicode value of the character.

    + +

    Definition at line 78 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TouchEvent-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TouchEvent-members.html new file mode 100644 index 000000000..e7a9246c7 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TouchEvent-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Event::TouchEvent Member List
    +
    +
    + +

    This is the complete list of members for sf::Event::TouchEvent, including all inherited members.

    + + + + +
    fingersf::Event::TouchEvent
    xsf::Event::TouchEvent
    ysf::Event::TouchEvent
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TouchEvent.html b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TouchEvent.html new file mode 100644 index 000000000..56bc7f301 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Event_1_1TouchEvent.html @@ -0,0 +1,188 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Event::TouchEvent Struct Reference
    +
    +
    + +

    Touch events parameters (TouchBegan, TouchMoved, TouchEnded) + More...

    + +

    #include <SFML/Window/Event.hpp>

    + + + + + + + + + + + +

    +Public Attributes

    unsigned int finger
     Index of the finger in case of multi-touch events.
     
    int x
     X position of the touch, relative to the left of the owner window.
     
    int y
     Y position of the touch, relative to the top of the owner window.
     
    +

    Detailed Description

    +

    Touch events parameters (TouchBegan, TouchMoved, TouchEnded)

    + +

    Definition at line 165 of file Event.hpp.

    +

    Member Data Documentation

    + +

    ◆ finger

    + +
    +
    + + + + +
    unsigned int sf::Event::TouchEvent::finger
    +
    + +

    Index of the finger in case of multi-touch events.

    + +

    Definition at line 167 of file Event.hpp.

    + +
    +
    + +

    ◆ x

    + +
    +
    + + + + +
    int sf::Event::TouchEvent::x
    +
    + +

    X position of the touch, relative to the left of the owner window.

    + +

    Definition at line 168 of file Event.hpp.

    + +
    +
    + +

    ◆ y

    + +
    +
    + + + + +
    int sf::Event::TouchEvent::y
    +
    + +

    Y position of the touch, relative to the top of the owner window.

    + +

    Definition at line 169 of file Event.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Font_1_1Info-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Font_1_1Info-members.html new file mode 100644 index 000000000..360cd1f64 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Font_1_1Info-members.html @@ -0,0 +1,109 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Font::Info Member List
    +
    +
    + +

    This is the complete list of members for sf::Font::Info, including all inherited members.

    + + +
    familysf::Font::Info
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Font_1_1Info.html b/Space-Invaders/sfml/doc/html/structsf_1_1Font_1_1Info.html new file mode 100644 index 000000000..46f8d7f92 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Font_1_1Info.html @@ -0,0 +1,146 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Font::Info Struct Reference
    +
    +
    + +

    Holds various information about a font. + More...

    + +

    #include <SFML/Graphics/Font.hpp>

    + + + + + +

    +Public Attributes

    std::string family
     The font family.
     
    +

    Detailed Description

    +

    Holds various information about a font.

    + +

    Definition at line 56 of file Font.hpp.

    +

    Member Data Documentation

    + +

    ◆ family

    + +
    +
    + + + + +
    std::string sf::Font::Info::family
    +
    + +

    The font family.

    + +

    Definition at line 58 of file Font.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Joystick_1_1Identification-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Joystick_1_1Identification-members.html new file mode 100644 index 000000000..b7770ffca --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Joystick_1_1Identification-members.html @@ -0,0 +1,112 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Joystick::Identification Member List
    +
    +
    + +

    This is the complete list of members for sf::Joystick::Identification, including all inherited members.

    + + + + + +
    Identification() (defined in sf::Joystick::Identification)sf::Joystick::Identification
    namesf::Joystick::Identification
    productIdsf::Joystick::Identification
    vendorIdsf::Joystick::Identification
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Joystick_1_1Identification.html b/Space-Invaders/sfml/doc/html/structsf_1_1Joystick_1_1Identification.html new file mode 100644 index 000000000..03a0ec9d6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Joystick_1_1Identification.html @@ -0,0 +1,188 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::Joystick::Identification Struct Reference
    +
    +
    + +

    Structure holding a joystick's identification. + More...

    + +

    #include <SFML/Window/Joystick.hpp>

    + + + + + + + + + + + +

    +Public Attributes

    String name
     Name of the joystick.
     
    unsigned int vendorId
     Manufacturer identifier.
     
    unsigned int productId
     Product identifier.
     
    +

    Detailed Description

    +

    Structure holding a joystick's identification.

    + +

    Definition at line 76 of file Joystick.hpp.

    +

    Member Data Documentation

    + +

    ◆ name

    + +
    +
    + + + + +
    String sf::Joystick::Identification::name
    +
    + +

    Name of the joystick.

    + +

    Definition at line 80 of file Joystick.hpp.

    + +
    +
    + +

    ◆ productId

    + +
    +
    + + + + +
    unsigned int sf::Joystick::Identification::productId
    +
    + +

    Product identifier.

    + +

    Definition at line 82 of file Joystick.hpp.

    + +
    +
    + +

    ◆ vendorId

    + +
    +
    + + + + +
    unsigned int sf::Joystick::Identification::vendorId
    +
    + +

    Manufacturer identifier.

    + +

    Definition at line 81 of file Joystick.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Keyboard_1_1Scan-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Keyboard_1_1Scan-members.html new file mode 100644 index 000000000..0a6ed458d --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Keyboard_1_1Scan-members.html @@ -0,0 +1,257 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Keyboard::Scan Member List
    +
    +
    + +

    This is the complete list of members for sf::Keyboard::Scan, including all inherited members.

    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    A enum valuesf::Keyboard::Scan
    Apostrophe enum valuesf::Keyboard::Scan
    Application enum valuesf::Keyboard::Scan
    B enum valuesf::Keyboard::Scan
    Back enum valuesf::Keyboard::Scan
    Backslash enum valuesf::Keyboard::Scan
    Backspace enum valuesf::Keyboard::Scan
    C enum valuesf::Keyboard::Scan
    CapsLock enum valuesf::Keyboard::Scan
    Comma enum valuesf::Keyboard::Scan
    Copy enum valuesf::Keyboard::Scan
    Cut enum valuesf::Keyboard::Scan
    D enum valuesf::Keyboard::Scan
    Delete enum valuesf::Keyboard::Scan
    Down enum valuesf::Keyboard::Scan
    E enum valuesf::Keyboard::Scan
    End enum valuesf::Keyboard::Scan
    Enter enum valuesf::Keyboard::Scan
    Equal enum valuesf::Keyboard::Scan
    Escape enum valuesf::Keyboard::Scan
    Execute enum valuesf::Keyboard::Scan
    F enum valuesf::Keyboard::Scan
    F1 enum valuesf::Keyboard::Scan
    F10 enum valuesf::Keyboard::Scan
    F11 enum valuesf::Keyboard::Scan
    F12 enum valuesf::Keyboard::Scan
    F13 enum valuesf::Keyboard::Scan
    F14 enum valuesf::Keyboard::Scan
    F15 enum valuesf::Keyboard::Scan
    F16 enum valuesf::Keyboard::Scan
    F17 enum valuesf::Keyboard::Scan
    F18 enum valuesf::Keyboard::Scan
    F19 enum valuesf::Keyboard::Scan
    F2 enum valuesf::Keyboard::Scan
    F20 enum valuesf::Keyboard::Scan
    F21 enum valuesf::Keyboard::Scan
    F22 enum valuesf::Keyboard::Scan
    F23 enum valuesf::Keyboard::Scan
    F24 enum valuesf::Keyboard::Scan
    F3 enum valuesf::Keyboard::Scan
    F4 enum valuesf::Keyboard::Scan
    F5 enum valuesf::Keyboard::Scan
    F6 enum valuesf::Keyboard::Scan
    F7 enum valuesf::Keyboard::Scan
    F8 enum valuesf::Keyboard::Scan
    F9 enum valuesf::Keyboard::Scan
    Favorites enum valuesf::Keyboard::Scan
    Forward enum valuesf::Keyboard::Scan
    G enum valuesf::Keyboard::Scan
    Grave enum valuesf::Keyboard::Scan
    H enum valuesf::Keyboard::Scan
    Help enum valuesf::Keyboard::Scan
    Home enum valuesf::Keyboard::Scan
    HomePage enum valuesf::Keyboard::Scan
    Hyphen enum valuesf::Keyboard::Scan
    I enum valuesf::Keyboard::Scan
    Insert enum valuesf::Keyboard::Scan
    J enum valuesf::Keyboard::Scan
    K enum valuesf::Keyboard::Scan
    L enum valuesf::Keyboard::Scan
    LAlt enum valuesf::Keyboard::Scan
    LaunchApplication1 enum valuesf::Keyboard::Scan
    LaunchApplication2 enum valuesf::Keyboard::Scan
    LaunchMail enum valuesf::Keyboard::Scan
    LaunchMediaSelect enum valuesf::Keyboard::Scan
    LBracket enum valuesf::Keyboard::Scan
    LControl enum valuesf::Keyboard::Scan
    Left enum valuesf::Keyboard::Scan
    LShift enum valuesf::Keyboard::Scan
    LSystem enum valuesf::Keyboard::Scan
    M enum valuesf::Keyboard::Scan
    MediaNextTrack enum valuesf::Keyboard::Scan
    MediaPlayPause enum valuesf::Keyboard::Scan
    MediaPreviousTrack enum valuesf::Keyboard::Scan
    MediaStop enum valuesf::Keyboard::Scan
    Menu enum valuesf::Keyboard::Scan
    ModeChange enum valuesf::Keyboard::Scan
    N enum valuesf::Keyboard::Scan
    NonUsBackslash enum valuesf::Keyboard::Scan
    Num0 enum valuesf::Keyboard::Scan
    Num1 enum valuesf::Keyboard::Scan
    Num2 enum valuesf::Keyboard::Scan
    Num3 enum valuesf::Keyboard::Scan
    Num4 enum valuesf::Keyboard::Scan
    Num5 enum valuesf::Keyboard::Scan
    Num6 enum valuesf::Keyboard::Scan
    Num7 enum valuesf::Keyboard::Scan
    Num8 enum valuesf::Keyboard::Scan
    Num9 enum valuesf::Keyboard::Scan
    NumLock enum valuesf::Keyboard::Scan
    Numpad0 enum valuesf::Keyboard::Scan
    Numpad1 enum valuesf::Keyboard::Scan
    Numpad2 enum valuesf::Keyboard::Scan
    Numpad3 enum valuesf::Keyboard::Scan
    Numpad4 enum valuesf::Keyboard::Scan
    Numpad5 enum valuesf::Keyboard::Scan
    Numpad6 enum valuesf::Keyboard::Scan
    Numpad7 enum valuesf::Keyboard::Scan
    Numpad8 enum valuesf::Keyboard::Scan
    Numpad9 enum valuesf::Keyboard::Scan
    NumpadDecimal enum valuesf::Keyboard::Scan
    NumpadDivide enum valuesf::Keyboard::Scan
    NumpadEnter enum valuesf::Keyboard::Scan
    NumpadEqual enum valuesf::Keyboard::Scan
    NumpadMinus enum valuesf::Keyboard::Scan
    NumpadMultiply enum valuesf::Keyboard::Scan
    NumpadPlus enum valuesf::Keyboard::Scan
    O enum valuesf::Keyboard::Scan
    P enum valuesf::Keyboard::Scan
    PageDown enum valuesf::Keyboard::Scan
    PageUp enum valuesf::Keyboard::Scan
    Paste enum valuesf::Keyboard::Scan
    Pause enum valuesf::Keyboard::Scan
    Period enum valuesf::Keyboard::Scan
    PrintScreen enum valuesf::Keyboard::Scan
    Q enum valuesf::Keyboard::Scan
    R enum valuesf::Keyboard::Scan
    RAlt enum valuesf::Keyboard::Scan
    RBracket enum valuesf::Keyboard::Scan
    RControl enum valuesf::Keyboard::Scan
    Redo enum valuesf::Keyboard::Scan
    Refresh enum valuesf::Keyboard::Scan
    Right enum valuesf::Keyboard::Scan
    RShift enum valuesf::Keyboard::Scan
    RSystem enum valuesf::Keyboard::Scan
    S enum valuesf::Keyboard::Scan
    Scancode enum namesf::Keyboard::Scan
    ScancodeCount enum valuesf::Keyboard::Scan
    ScrollLock enum valuesf::Keyboard::Scan
    Search enum valuesf::Keyboard::Scan
    Select enum valuesf::Keyboard::Scan
    Semicolon enum valuesf::Keyboard::Scan
    Slash enum valuesf::Keyboard::Scan
    Space enum valuesf::Keyboard::Scan
    Stop enum valuesf::Keyboard::Scan
    T enum valuesf::Keyboard::Scan
    Tab enum valuesf::Keyboard::Scan
    U enum valuesf::Keyboard::Scan
    Undo enum valuesf::Keyboard::Scan
    Unknown enum valuesf::Keyboard::Scan
    Up enum valuesf::Keyboard::Scan
    V enum valuesf::Keyboard::Scan
    VolumeDown enum valuesf::Keyboard::Scan
    VolumeMute enum valuesf::Keyboard::Scan
    VolumeUp enum valuesf::Keyboard::Scan
    W enum valuesf::Keyboard::Scan
    X enum valuesf::Keyboard::Scan
    Y enum valuesf::Keyboard::Scan
    Z enum valuesf::Keyboard::Scan
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Keyboard_1_1Scan.html b/Space-Invaders/sfml/doc/html/structsf_1_1Keyboard_1_1Scan.html new file mode 100644 index 000000000..286866479 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Keyboard_1_1Scan.html @@ -0,0 +1,628 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Types | +List of all members
    +
    sf::Keyboard::Scan Struct Reference
    +
    +
    + +

    Scancodes. + More...

    + +

    #include <SFML/Window/Keyboard.hpp>

    + + + + +

    +Public Types

    enum  Scancode {
    +  Unknown = -1 +, A = 0 +, B +, C +,
    +  D +, E +, F +, G +,
    +  H +, I +, J +, K +,
    +  L +, M +, N +, O +,
    +  P +, Q +, R +, S +,
    +  T +, U +, V +, W +,
    +  X +, Y +, Z +, Num1 +,
    +  Num2 +, Num3 +, Num4 +, Num5 +,
    +  Num6 +, Num7 +, Num8 +, Num9 +,
    +  Num0 +, Enter +, Escape +, Backspace +,
    +  Tab +, Space +, Hyphen +, Equal +,
    +  LBracket +, RBracket +, Backslash +, Semicolon +,
    +  Apostrophe +, Grave +, Comma +, Period +,
    +  Slash +, F1 +, F2 +, F3 +,
    +  F4 +, F5 +, F6 +, F7 +,
    +  F8 +, F9 +, F10 +, F11 +,
    +  F12 +, F13 +, F14 +, F15 +,
    +  F16 +, F17 +, F18 +, F19 +,
    +  F20 +, F21 +, F22 +, F23 +,
    +  F24 +, CapsLock +, PrintScreen +, ScrollLock +,
    +  Pause +, Insert +, Home +, PageUp +,
    +  Delete +, End +, PageDown +, Right +,
    +  Left +, Down +, Up +, NumLock +,
    +  NumpadDivide +, NumpadMultiply +, NumpadMinus +, NumpadPlus +,
    +  NumpadEqual +, NumpadEnter +, NumpadDecimal +, Numpad1 +,
    +  Numpad2 +, Numpad3 +, Numpad4 +, Numpad5 +,
    +  Numpad6 +, Numpad7 +, Numpad8 +, Numpad9 +,
    +  Numpad0 +, NonUsBackslash +, Application +, Execute +,
    +  ModeChange +, Help +, Menu +, Select +,
    +  Redo +, Undo +, Cut +, Copy +,
    +  Paste +, VolumeMute +, VolumeUp +, VolumeDown +,
    +  MediaPlayPause +, MediaStop +, MediaNextTrack +, MediaPreviousTrack +,
    +  LControl +, LShift +, LAlt +, LSystem +,
    +  RControl +, RShift +, RAlt +, RSystem +,
    +  Back +, Forward +, Refresh +, Stop +,
    +  Search +, Favorites +, HomePage +, LaunchApplication1 +,
    +  LaunchApplication2 +, LaunchMail +, LaunchMediaSelect +, ScancodeCount +
    + }
     
    +

    Detailed Description

    +

    Scancodes.

    +

    The enumerators are bound to a physical key and do not depend on the keyboard layout used by the operating system. Usually, the AT-101 keyboard can be used as reference for the physical position of the keys.

    + +

    Definition at line 180 of file Keyboard.hpp.

    +

    Member Enumeration Documentation

    + +

    ◆ Scancode

    + +
    +
    + + + + +
    enum sf::Keyboard::Scan::Scancode
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Enumerator
    Unknown 

    Represents any scancode not present in this enum.

    +
    A 

    Keyboard a and A key.

    +
    B 

    Keyboard b and B key.

    +
    C 

    Keyboard c and C key.

    +
    D 

    Keyboard d and D key.

    +
    E 

    Keyboard e and E key.

    +
    F 

    Keyboard f and F key.

    +
    G 

    Keyboard g and G key.

    +
    H 

    Keyboard h and H key.

    +
    I 

    Keyboard i and I key.

    +
    J 

    Keyboard j and J key.

    +
    K 

    Keyboard k and K key.

    +
    L 

    Keyboard l and L key.

    +
    M 

    Keyboard m and M key.

    +
    N 

    Keyboard n and N key.

    +
    O 

    Keyboard o and O key.

    +
    P 

    Keyboard p and P key.

    +
    Q 

    Keyboard q and Q key.

    +
    R 

    Keyboard r and R key.

    +
    S 

    Keyboard s and S key.

    +
    T 

    Keyboard t and T key.

    +
    U 

    Keyboard u and U key.

    +
    V 

    Keyboard v and V key.

    +
    W 

    Keyboard w and W key.

    +
    X 

    Keyboard x and X key.

    +
    Y 

    Keyboard y and Y key.

    +
    Z 

    Keyboard z and Z key.

    +
    Num1 

    Keyboard 1 and ! key.

    +
    Num2 

    Keyboard 2 and @ key.

    +
    Num3 

    Keyboard 3 and # key.

    +
    Num4 

    Keyboard 4 and $ key.

    +
    Num5 

    Keyboard 5 and % key.

    +
    Num6 

    Keyboard 6 and ^ key.

    +
    Num7 

    Keyboard 7 and & key.

    +
    Num8 

    Keyboard 8 and * key.

    +
    Num9 

    Keyboard 9 and ) key.

    +
    Num0 

    Keyboard 0 and ) key.

    +
    Enter 

    Keyboard Enter/Return key.

    +
    Escape 

    Keyboard Escape key.

    +
    Backspace 

    Keyboard Backspace key.

    +
    Tab 

    Keyboard Tab key.

    +
    Space 

    Keyboard Space key.

    +
    Hyphen 

    Keyboard - and _ key.

    +
    Equal 

    Keyboard = and +.

    +
    LBracket 

    Keyboard [ and { key.

    +
    RBracket 

    Keyboard ] and } key.

    +
    Backslash 

    Keyboard \ and | key OR various keys for Non-US keyboards.

    +
    Semicolon 

    Keyboard ; and : key.

    +
    Apostrophe 

    Keyboard ' and " key.

    +
    Grave 

    Keyboard ` and ~ key.

    +
    Comma 

    Keyboard , and < key.

    +
    Period 

    Keyboard . and > key.

    +
    Slash 

    Keyboard / and ? key.

    +
    F1 

    Keyboard F1 key.

    +
    F2 

    Keyboard F2 key.

    +
    F3 

    Keyboard F3 key.

    +
    F4 

    Keyboard F4 key.

    +
    F5 

    Keyboard F5 key.

    +
    F6 

    Keyboard F6 key.

    +
    F7 

    Keyboard F7 key.

    +
    F8 

    Keyboard F8 key.

    +
    F9 

    Keyboard F9 key.

    +
    F10 

    Keyboard F10 key.

    +
    F11 

    Keyboard F11 key.

    +
    F12 

    Keyboard F12 key.

    +
    F13 

    Keyboard F13 key.

    +
    F14 

    Keyboard F14 key.

    +
    F15 

    Keyboard F15 key.

    +
    F16 

    Keyboard F16 key.

    +
    F17 

    Keyboard F17 key.

    +
    F18 

    Keyboard F18 key.

    +
    F19 

    Keyboard F19 key.

    +
    F20 

    Keyboard F20 key.

    +
    F21 

    Keyboard F21 key.

    +
    F22 

    Keyboard F22 key.

    +
    F23 

    Keyboard F23 key.

    +
    F24 

    Keyboard F24 key.

    +
    CapsLock 

    Keyboard Caps Lock key.

    +
    PrintScreen 

    Keyboard Print Screen key.

    +
    ScrollLock 

    Keyboard Scroll Lock key.

    +
    Pause 

    Keyboard Pause key.

    +
    Insert 

    Keyboard Insert key.

    +
    Home 

    Keyboard Home key.

    +
    PageUp 

    Keyboard Page Up key.

    +
    Delete 

    Keyboard Delete Forward key.

    +
    End 

    Keyboard End key.

    +
    PageDown 

    Keyboard Page Down key.

    +
    Right 

    Keyboard Right Arrow key.

    +
    Left 

    Keyboard Left Arrow key.

    +
    Down 

    Keyboard Down Arrow key.

    +
    Up 

    Keyboard Up Arrow key.

    +
    NumLock 

    Keypad Num Lock and Clear key.

    +
    NumpadDivide 

    Keypad / key.

    +
    NumpadMultiply 

    Keypad * key.

    +
    NumpadMinus 

    Keypad - key.

    +
    NumpadPlus 

    Keypad + key.

    +
    NumpadEqual 

    keypad = key

    +
    NumpadEnter 

    Keypad Enter/Return key.

    +
    NumpadDecimal 

    Keypad . and Delete key.

    +
    Numpad1 

    Keypad 1 and End key.

    +
    Numpad2 

    Keypad 2 and Down Arrow key.

    +
    Numpad3 

    Keypad 3 and Page Down key.

    +
    Numpad4 

    Keypad 4 and Left Arrow key.

    +
    Numpad5 

    Keypad 5 key.

    +
    Numpad6 

    Keypad 6 and Right Arrow key.

    +
    Numpad7 

    Keypad 7 and Home key.

    +
    Numpad8 

    Keypad 8 and Up Arrow key.

    +
    Numpad9 

    Keypad 9 and Page Up key.

    +
    Numpad0 

    Keypad 0 and Insert key.

    +
    NonUsBackslash 

    Keyboard Non-US \ and | key.

    +
    Application 

    Keyboard Application key.

    +
    Execute 

    Keyboard Execute key.

    +
    ModeChange 

    Keyboard Mode Change key.

    +
    Help 

    Keyboard Help key.

    +
    Menu 

    Keyboard Menu key.

    +
    Select 

    Keyboard Select key.

    +
    Redo 

    Keyboard Redo key.

    +
    Undo 

    Keyboard Undo key.

    +
    Cut 

    Keyboard Cut key.

    +
    Copy 

    Keyboard Copy key.

    +
    Paste 

    Keyboard Paste key.

    +
    VolumeMute 

    Keyboard Volume Mute key.

    +
    VolumeUp 

    Keyboard Volume Up key.

    +
    VolumeDown 

    Keyboard Volume Down key.

    +
    MediaPlayPause 

    Keyboard Media Play Pause key.

    +
    MediaStop 

    Keyboard Media Stop key.

    +
    MediaNextTrack 

    Keyboard Media Next Track key.

    +
    MediaPreviousTrack 

    Keyboard Media Previous Track key.

    +
    LControl 

    Keyboard Left Control key.

    +
    LShift 

    Keyboard Left Shift key.

    +
    LAlt 

    Keyboard Left Alt key.

    +
    LSystem 

    Keyboard Left System key.

    +
    RControl 

    Keyboard Right Control key.

    +
    RShift 

    Keyboard Right Shift key.

    +
    RAlt 

    Keyboard Right Alt key.

    +
    RSystem 

    Keyboard Right System key.

    +
    Back 

    Keyboard Back key.

    +
    Forward 

    Keyboard Forward key.

    +
    Refresh 

    Keyboard Refresh key.

    +
    Stop 

    Keyboard Stop key.

    +
    Search 

    Keyboard Search key.

    +
    Favorites 

    Keyboard Favorites key.

    +
    HomePage 

    Keyboard Home Page key.

    +
    LaunchApplication1 

    Keyboard Launch Application 1 key.

    +
    LaunchApplication2 

    Keyboard Launch Application 2 key.

    +
    LaunchMail 

    Keyboard Launch Mail key.

    +
    LaunchMediaSelect 

    Keyboard Launch Media Select key.

    +
    ScancodeCount 

    Keep last – the total number of scancodes.

    +
    + +

    Definition at line 192 of file Keyboard.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Music_1_1Span-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1Music_1_1Span-members.html new file mode 100644 index 000000000..876c39473 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Music_1_1Span-members.html @@ -0,0 +1,112 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Music::Span< T > Member List
    +
    +
    + +

    This is the complete list of members for sf::Music::Span< T >, including all inherited members.

    + + + + + +
    lengthsf::Music::Span< T >
    offsetsf::Music::Span< T >
    Span()sf::Music::Span< T >inline
    Span(T off, T len)sf::Music::Span< T >inline
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Music_1_1Span.html b/Space-Invaders/sfml/doc/html/structsf_1_1Music_1_1Span.html new file mode 100644 index 000000000..0a1bb59a5 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Music_1_1Span.html @@ -0,0 +1,263 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Member Functions | +Public Attributes | +List of all members
    +
    sf::Music::Span< T > Struct Template Reference
    +
    +
    + +

    Structure defining a time range using the template type. + More...

    + +

    #include <SFML/Audio/Music.hpp>

    + + + + + + + + +

    +Public Member Functions

     Span ()
     Default constructor.
     
     Span (T off, T len)
     Initialization constructor.
     
    + + + + + + + +

    +Public Attributes

    T offset
     The beginning offset of the time range.
     
    T length
     The length of the time range.
     
    +

    Detailed Description

    +
    template<typename T>
    +struct sf::Music::Span< T >

    Structure defining a time range using the template type.

    + +

    Definition at line 57 of file Music.hpp.

    +

    Constructor & Destructor Documentation

    + +

    ◆ Span() [1/2]

    + +
    +
    +
    +template<typename T >
    + + + + + +
    + + + + + + + +
    sf::Music::Span< T >::Span ()
    +     		+inline
    +
    + +

    Default constructor.

    + +

    Definition at line 63 of file Music.hpp.

    + +
    +
    + +

    ◆ Span() [2/2]

    + +
    +
    +
    +template<typename T >
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    sf::Music::Span< T >::Span (T off,
    T len 
    )
    +     		+inline
    +
    + +

    Initialization constructor.

    +
    Parameters
    + + + +
    offInitial Offset
    lenInitial Length
    +
    +
    + +

    Definition at line 75 of file Music.hpp.

    + +
    +
    +

    Member Data Documentation

    + +

    ◆ length

    + +
    +
    +
    +template<typename T >
    + + + + +
    T sf::Music::Span< T >::length
    +
    + +

    The length of the time range.

    + +

    Definition at line 83 of file Music.hpp.

    + +
    +
    + +

    ◆ offset

    + +
    +
    +
    +template<typename T >
    + + + + +
    T sf::Music::Span< T >::offset
    +
    + +

    The beginning offset of the time range.

    + +

    Definition at line 82 of file Music.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1Shader_1_1CurrentTextureType.html b/Space-Invaders/sfml/doc/html/structsf_1_1Shader_1_1CurrentTextureType.html new file mode 100644 index 000000000..118fc074c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1Shader_1_1CurrentTextureType.html @@ -0,0 +1,118 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::Shader::CurrentTextureType Struct Reference
    +
    +
    + +

    Special type that can be passed to setUniform(), and that represents the texture of the object being drawn. + More...

    + +

    #include <SFML/Graphics/Shader.hpp>

    +

    Detailed Description

    +

    Special type that can be passed to setUniform(), and that represents the texture of the object being drawn.

    +
    See also
    setUniform(const std::string&, CurrentTextureType)
    + +

    Definition at line 74 of file Shader.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1SoundFileReader_1_1Info-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1SoundFileReader_1_1Info-members.html new file mode 100644 index 000000000..6e3515fa6 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1SoundFileReader_1_1Info-members.html @@ -0,0 +1,111 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::SoundFileReader::Info Member List
    +
    +
    + +

    This is the complete list of members for sf::SoundFileReader::Info, including all inherited members.

    + + + + +
    channelCountsf::SoundFileReader::Info
    sampleCountsf::SoundFileReader::Info
    sampleRatesf::SoundFileReader::Info
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1SoundFileReader_1_1Info.html b/Space-Invaders/sfml/doc/html/structsf_1_1SoundFileReader_1_1Info.html new file mode 100644 index 000000000..6dc7c0bf4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1SoundFileReader_1_1Info.html @@ -0,0 +1,188 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::SoundFileReader::Info Struct Reference
    +
    +
    + +

    Structure holding the audio properties of a sound file. + More...

    + +

    #include <SFML/Audio/SoundFileReader.hpp>

    + + + + + + + + + + + +

    +Public Attributes

    Uint64 sampleCount
     Total number of samples in the file.
     
    unsigned int channelCount
     Number of channels of the sound.
     
    unsigned int sampleRate
     Samples rate of the sound, in samples per second.
     
    +

    Detailed Description

    +

    Structure holding the audio properties of a sound file.

    + +

    Definition at line 51 of file SoundFileReader.hpp.

    +

    Member Data Documentation

    + +

    ◆ channelCount

    + +
    +
    + + + + +
    unsigned int sf::SoundFileReader::Info::channelCount
    +
    + +

    Number of channels of the sound.

    + +

    Definition at line 54 of file SoundFileReader.hpp.

    + +
    +
    + +

    ◆ sampleCount

    + +
    +
    + + + + +
    Uint64 sf::SoundFileReader::Info::sampleCount
    +
    + +

    Total number of samples in the file.

    + +

    Definition at line 53 of file SoundFileReader.hpp.

    + +
    +
    + +

    ◆ sampleRate

    + +
    +
    + + + + +
    unsigned int sf::SoundFileReader::Info::sampleRate
    +
    + +

    Samples rate of the sound, in samples per second.

    + +

    Definition at line 55 of file SoundFileReader.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1SoundStream_1_1Chunk-members.html b/Space-Invaders/sfml/doc/html/structsf_1_1SoundStream_1_1Chunk-members.html new file mode 100644 index 000000000..053f59ba4 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1SoundStream_1_1Chunk-members.html @@ -0,0 +1,110 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    sf::SoundStream::Chunk Member List
    +
    +
    + +

    This is the complete list of members for sf::SoundStream::Chunk, including all inherited members.

    + + + +
    sampleCountsf::SoundStream::Chunk
    samplessf::SoundStream::Chunk
    + + + + diff --git a/Space-Invaders/sfml/doc/html/structsf_1_1SoundStream_1_1Chunk.html b/Space-Invaders/sfml/doc/html/structsf_1_1SoundStream_1_1Chunk.html new file mode 100644 index 000000000..8831c491c --- /dev/null +++ b/Space-Invaders/sfml/doc/html/structsf_1_1SoundStream_1_1Chunk.html @@ -0,0 +1,167 @@ + + + + SFML - Simple and Fast Multimedia Library + + + + + + + + + + + + + + +
    + + + + + +
    +
    + + +
    +
    +
    +
    +
    +
    Loading...
    +
    Searching...
    +
    No Matches
    +
    +
    +
    +
    + + +
    +
    +
    +Public Attributes | +List of all members
    +
    sf::SoundStream::Chunk Struct Reference
    +
    +
    + +

    Structure defining a chunk of audio data to stream. + More...

    + +

    #include <SFML/Audio/SoundStream.hpp>

    + + + + + + + + +

    +Public Attributes

    const Int16 * samples
     Pointer to the audio samples.
     
    std::size_t sampleCount
     Number of samples pointed by Samples.
     
    +

    Detailed Description

    +

    Structure defining a chunk of audio data to stream.

    + +

    Definition at line 53 of file SoundStream.hpp.

    +

    Member Data Documentation

    + +

    ◆ sampleCount

    + +
    +
    + + + + +
    std::size_t sf::SoundStream::Chunk::sampleCount
    +
    + +

    Number of samples pointed by Samples.

    + +

    Definition at line 56 of file SoundStream.hpp.

    + +
    +
    + +

    ◆ samples

    + +
    +
    + + + + +
    const Int16* sf::SoundStream::Chunk::samples
    +
    + +

    Pointer to the audio samples.

    + +

    Definition at line 55 of file SoundStream.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    + + + + diff --git a/Space-Invaders/sfml/doc/html/sync_off.png b/Space-Invaders/sfml/doc/html/sync_off.png new file mode 100644 index 000000000..3b443fc62 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/sync_off.png differ diff --git a/Space-Invaders/sfml/doc/html/sync_on.png b/Space-Invaders/sfml/doc/html/sync_on.png new file mode 100644 index 000000000..e08320fb6 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/sync_on.png differ diff --git a/Space-Invaders/sfml/doc/html/tab_a.png b/Space-Invaders/sfml/doc/html/tab_a.png new file mode 100644 index 000000000..3b725c41c Binary files /dev/null and b/Space-Invaders/sfml/doc/html/tab_a.png differ diff --git a/Space-Invaders/sfml/doc/html/tab_ad.png b/Space-Invaders/sfml/doc/html/tab_ad.png new file mode 100644 index 000000000..e34850acf Binary files /dev/null and b/Space-Invaders/sfml/doc/html/tab_ad.png differ diff --git a/Space-Invaders/sfml/doc/html/tab_b.png b/Space-Invaders/sfml/doc/html/tab_b.png new file mode 100644 index 000000000..e2b4a8638 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/tab_b.png differ diff --git a/Space-Invaders/sfml/doc/html/tab_bd.png b/Space-Invaders/sfml/doc/html/tab_bd.png new file mode 100644 index 000000000..91c252498 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/tab_bd.png differ diff --git a/Space-Invaders/sfml/doc/html/tab_h.png b/Space-Invaders/sfml/doc/html/tab_h.png new file mode 100644 index 000000000..fd5cb7054 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/tab_h.png differ diff --git a/Space-Invaders/sfml/doc/html/tab_hd.png b/Space-Invaders/sfml/doc/html/tab_hd.png new file mode 100644 index 000000000..2489273d4 Binary files /dev/null and b/Space-Invaders/sfml/doc/html/tab_hd.png differ diff --git a/Space-Invaders/sfml/doc/html/tab_s.png b/Space-Invaders/sfml/doc/html/tab_s.png new file mode 100644 index 000000000..ab478c95b Binary files /dev/null and b/Space-Invaders/sfml/doc/html/tab_s.png differ diff --git a/Space-Invaders/sfml/doc/html/tab_sd.png b/Space-Invaders/sfml/doc/html/tab_sd.png new file mode 100644 index 000000000..757a565ce Binary files /dev/null and b/Space-Invaders/sfml/doc/html/tab_sd.png differ diff --git a/Space-Invaders/sfml/doc/html/tabs.css b/Space-Invaders/sfml/doc/html/tabs.css new file mode 100644 index 000000000..cd5f91665 --- /dev/null +++ b/Space-Invaders/sfml/doc/html/tabs.css @@ -0,0 +1,62 @@ +.tabs, .tabs2, .tabs3 { + background-image: url('tab_b.png'); + width: 100%; + z-index: 101; + font-size: 13px; + font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif; + display: table; +} + +.tabs2 { + font-size: 10px; +} +.tabs3 { + font-size: 9px; +} + +.tablist { + margin: 0; + padding: 0; + display: block; +} + +.tablist li { + float: left; + display: table-cell; + background-image: url('tab_b.png'); + line-height: 36px; + list-style: none; +} + +.tablist a { + display: block; + padding: 0 20px; + font-weight: bold; + background-image:url('tab_s.png'); + background-repeat:no-repeat; + background-position:right; + color: #283A5D; + text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); + text-decoration: none; + outline: none; +} + +.tabs3 .tablist a { + padding: 0 10px; +} + +.tablist a:hover { + background-image: url('tab_h.png'); + background-repeat:repeat-x; + color: white; + text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0); + text-decoration: none; +} + +.tablist li.current a { + background-image: url('tab_a.png'); + background-repeat:repeat-x; + color: white; + text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0); +} + diff --git a/Space-Invaders/sfml/examples/asset_licenses.md b/Space-Invaders/sfml/examples/asset_licenses.md new file mode 100644 index 000000000..989917d48 --- /dev/null +++ b/Space-Invaders/sfml/examples/asset_licenses.md @@ -0,0 +1,26 @@ +# Assets used by SFML's example projects. + +All assets are under public domain (CC0): + +| Name | Author | Link | +| ------------------------------- | ------------------------- | -------------------------- | +| Tuffy 1.1 font | Thatcher Ulrich | [Ulrich's fonts][1] | +| sounds/resources/doodle_pop.ogg | MrZeusTheCoder | [public-domain][2] | +| tennis/resources/ball.wav | MrZeusTheCoder | [public-domain][2] | +| opengl/resources/background.jpg | Nidhoggn | [Open Game Art][3] | +| shader/resources/background.jpg | Arcana Dea | [Public Domain Images][4] | +| shader/resources/devices.png | Kenny.nl | [Game Icons Pack][5] | +| sound/resources/ding.flac | Kenny.nl | [Interface Sounds Pack][6] | +| sound/resources/ding.mp3 | Kenny.nl | [Interface Sounds Pack][6] | +| win32/resources/image1.jpg | Kenny.nl | [Toon Character Pack][7] | +| win32/resources/image2.jpg | Kenny.nl | [Toon Character Pack][7] | +| sound/resources/killdeer.wav | US National Park Services | [Bird sounds][8] | + +[1]: http://tulrich.com/fonts/ +[2]: https://github.com/MrZeusTheCoder/public-domain +[3]: https://opengameart.org/content/backgrounds-3 +[4]: https://www.publicdomainpictures.net/en/view-image.php?image=10979&picture=monarch-butterfly +[5]: https://www.kenney.nl/assets/game-icons +[6]: https://www.kenney.nl/assets/interface-sounds +[7]: https://www.kenney.nl/assets/toon-characters-1 +[8]: https://www.nps.gov/subjects/sound/sounds-killdeer.htm \ No newline at end of file diff --git a/Space-Invaders/sfml/examples/assets/logo.png b/Space-Invaders/sfml/examples/assets/logo.png new file mode 100644 index 000000000..7b04c41ac Binary files /dev/null and b/Space-Invaders/sfml/examples/assets/logo.png differ diff --git a/Space-Invaders/sfml/examples/ftp/Ftp.cpp b/Space-Invaders/sfml/examples/ftp/Ftp.cpp new file mode 100644 index 000000000..e4de8adc7 --- /dev/null +++ b/Space-Invaders/sfml/examples/ftp/Ftp.cpp @@ -0,0 +1,206 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include + + +//////////////////////////////////////////////////////////// +/// Print a FTP response into a standard output stream +/// +//////////////////////////////////////////////////////////// +std::ostream& operator <<(std::ostream& stream, const sf::Ftp::Response& response) +{ + return stream << response.getStatus() << response.getMessage(); +} + + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + // Choose the server address + sf::IpAddress address; + do + { + std::cout << "Enter the FTP server address: "; + std::cin >> address; + } + while (address == sf::IpAddress::None); + + // Connect to the server + sf::Ftp server; + sf::Ftp::Response connectResponse = server.connect(address); + std::cout << connectResponse << std::endl; + if (!connectResponse.isOk()) + return EXIT_FAILURE; + + // Ask for user name and password + std::string user, password; + std::cout << "User name: "; + std::cin >> user; + std::cout << "Password: "; + std::cin >> password; + + // Login to the server + sf::Ftp::Response loginResponse = server.login(user, password); + std::cout << loginResponse << std::endl; + if (!loginResponse.isOk()) + return EXIT_FAILURE; + + // Main menu + int choice = 0; + do + { + // Main FTP menu + std::cout << std::endl; + std::cout << "Choose an action:" << std::endl; + std::cout << "1. Print working directory" << std::endl; + std::cout << "2. Print contents of working directory" << std::endl; + std::cout << "3. Change directory" << std::endl; + std::cout << "4. Create directory" << std::endl; + std::cout << "5. Delete directory" << std::endl; + std::cout << "6. Rename file" << std::endl; + std::cout << "7. Remove file" << std::endl; + std::cout << "8. Download file" << std::endl; + std::cout << "9. Upload file" << std::endl; + std::cout << "0. Disconnect" << std::endl; + std::cout << std::endl; + + std::cout << "Your choice: "; + std::cin >> choice; + std::cout << std::endl; + + switch (choice) + { + default: + { + // Wrong choice + std::cout << "Invalid choice!" << std::endl; + std::cin.clear(); + std::cin.ignore(10000, '\n'); + break; + } + + case 1: + { + // Print the current server directory + sf::Ftp::DirectoryResponse response = server.getWorkingDirectory(); + std::cout << response << std::endl; + std::cout << "Current directory is " << response.getDirectory() << std::endl; + break; + } + + case 2: + { + // Print the contents of the current server directory + sf::Ftp::ListingResponse response = server.getDirectoryListing(); + std::cout << response << std::endl; + const std::vector& names = response.getListing(); + for (std::vector::const_iterator it = names.begin(); it != names.end(); ++it) + std::cout << *it << std::endl; + break; + } + + case 3: + { + // Change the current directory + std::string directory; + std::cout << "Choose a directory: "; + std::cin >> directory; + std::cout << server.changeDirectory(directory) << std::endl; + break; + } + + case 4: + { + // Create a new directory + std::string directory; + std::cout << "Name of the directory to create: "; + std::cin >> directory; + std::cout << server.createDirectory(directory) << std::endl; + break; + } + + case 5: + { + // Remove an existing directory + std::string directory; + std::cout << "Name of the directory to remove: "; + std::cin >> directory; + std::cout << server.deleteDirectory(directory) << std::endl; + break; + } + + case 6: + { + // Rename a file + std::string source, destination; + std::cout << "Name of the file to rename: "; + std::cin >> source; + std::cout << "New name: "; + std::cin >> destination; + std::cout << server.renameFile(source, destination) << std::endl; + break; + } + + case 7: + { + // Remove an existing directory + std::string filename; + std::cout << "Name of the file to remove: "; + std::cin >> filename; + std::cout << server.deleteFile(filename) << std::endl; + break; + } + + case 8: + { + // Download a file from server + std::string filename, directory; + std::cout << "Filename of the file to download (relative to current directory): "; + std::cin >> filename; + std::cout << "Directory to download the file to: "; + std::cin >> directory; + std::cout << server.download(filename, directory) << std::endl; + break; + } + + case 9: + { + // Upload a file to server + std::string filename, directory; + std::cout << "Path of the file to upload (absolute or relative to working directory): "; + std::cin >> filename; + std::cout << "Directory to upload the file to (relative to current directory): "; + std::cin >> directory; + std::cout << server.upload(filename, directory) << std::endl; + break; + } + + case 0: + { + // Disconnect + break; + } + } + + } while (choice != 0); + + // Disconnect from the server + std::cout << "Disconnecting from server..." << std::endl; + std::cout << server.disconnect() << std::endl; + + // Wait until the user presses 'enter' key + std::cout << "Press enter to exit..." << std::endl; + std::cin.ignore(10000, '\n'); + std::cin.ignore(10000, '\n'); + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/examples/island/Island.cpp b/Space-Invaders/sfml/examples/island/Island.cpp new file mode 100644 index 000000000..1ec46cb3a --- /dev/null +++ b/Space-Invaders/sfml/examples/island/Island.cpp @@ -0,0 +1,607 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#define STB_PERLIN_IMPLEMENTATION +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace +{ + // Width and height of the application window + const unsigned int windowWidth = 800; + const unsigned int windowHeight = 600; + + // Resolution of the generated terrain + const unsigned int resolutionX = 800; + const unsigned int resolutionY = 600; + + // Thread pool parameters + const unsigned int threadCount = 4; + const unsigned int blockCount = 32; + + struct WorkItem + { + sf::Vertex* targetBuffer; + unsigned int index; + }; + + std::deque workQueue; + std::vector threads; + int pendingWorkCount = 0; + bool workPending = true; + bool bufferUploadPending = false; + sf::Mutex workQueueMutex; + + struct Setting + { + const char* name; + float* value; + }; + + // Terrain noise parameters + const int perlinOctaves = 3; + + float perlinFrequency = 7.0f; + float perlinFrequencyBase = 4.0f; + + // Terrain generation parameters + float heightBase = 0.0f; + float edgeFactor = 0.9f; + float edgeDropoffExponent = 1.5f; + + float snowcapHeight = 0.6f; + + // Terrain lighting parameters + float heightFactor = windowHeight / 2.0f; + float heightFlatten = 3.0f; + float lightFactor = 0.7f; +} + + +// Forward declarations of the functions we define further down +void threadFunction(); +void generateTerrain(sf::Vertex* vertexBuffer); + + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + // Create the window of the application + sf::RenderWindow window(sf::VideoMode(windowWidth, windowHeight), "SFML Island", + sf::Style::Titlebar | sf::Style::Close); + window.setVerticalSyncEnabled(true); + + sf::Font font; + if (!font.loadFromFile("resources/tuffy.ttf")) + return EXIT_FAILURE; + + // Create all of our graphics resources + sf::Text hudText; + sf::Text statusText; + sf::Shader terrainShader; + sf::RenderStates terrainStates(&terrainShader); + sf::VertexBuffer terrain(sf::Triangles, sf::VertexBuffer::Static); + + // Set up our text drawables + statusText.setFont(font); + statusText.setCharacterSize(28); + statusText.setFillColor(sf::Color::White); + statusText.setOutlineColor(sf::Color::Black); + statusText.setOutlineThickness(2.0f); + + hudText.setFont(font); + hudText.setCharacterSize(14); + hudText.setFillColor(sf::Color::White); + hudText.setOutlineColor(sf::Color::Black); + hudText.setOutlineThickness(2.0f); + hudText.setPosition(5.0f, 5.0f); + + // Staging buffer for our terrain data that we will upload to our VertexBuffer + std::vector terrainStagingBuffer; + + // Check whether the prerequisites are suppprted + bool prerequisitesSupported = sf::VertexBuffer::isAvailable() && sf::Shader::isAvailable(); + + // Set up our graphics resources and set the status text accordingly + if (!prerequisitesSupported) + { + statusText.setString("Shaders and/or Vertex Buffers Unsupported"); + } + else if (!terrainShader.loadFromFile("resources/terrain.vert", "resources/terrain.frag")) + { + prerequisitesSupported = false; + + statusText.setString("Failed to load shader program"); + } + else + { + // Start up our thread pool + for (unsigned int i = 0; i < threadCount; i++) + { + threads.push_back(new sf::Thread(threadFunction)); + threads.back()->launch(); + } + + // Create our VertexBuffer with enough space to hold all the terrain geometry + terrain.create(resolutionX * resolutionY * 6); + + // Resize the staging buffer to be able to hold all the terrain geometry + terrainStagingBuffer.resize(resolutionX * resolutionY * 6); + + // Generate the initial terrain + generateTerrain(&terrainStagingBuffer[0]); + + statusText.setString("Generating Terrain..."); + } + + // Center the status text + statusText.setPosition((windowWidth - statusText.getLocalBounds().width) / 2.f, (windowHeight - statusText.getLocalBounds().height) / 2.f); + + // Set up an array of pointers to our settings for arrow navigation + Setting settings[] = + { + {"perlinFrequency", &perlinFrequency}, + {"perlinFrequencyBase", &perlinFrequencyBase}, + {"heightBase", &heightBase}, + {"edgeFactor", &edgeFactor}, + {"edgeDropoffExponent", &edgeDropoffExponent}, + {"snowcapHeight", &snowcapHeight}, + {"heightFactor", &heightFactor}, + {"heightFlatten", &heightFlatten}, + {"lightFactor", &lightFactor} + }; + + const int settingCount = 9; + int currentSetting = 0; + + std::ostringstream osstr; + sf::Clock clock; + + while (window.isOpen()) + { + // Handle events + sf::Event event; + while (window.pollEvent(event)) + { + // Window closed or escape key pressed: exit + if ((event.type == sf::Event::Closed) || + ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))) + { + window.close(); + break; + } + + // Arrow key pressed: + if (prerequisitesSupported && (event.type == sf::Event::KeyPressed)) + { + switch (event.key.code) + { + case sf::Keyboard::Return: generateTerrain(&terrainStagingBuffer[0]); break; + case sf::Keyboard::Down: currentSetting = (currentSetting + 1) % settingCount; break; + case sf::Keyboard::Up: currentSetting = (currentSetting + settingCount - 1) % settingCount; break; + case sf::Keyboard::Left: *(settings[currentSetting].value) -= 0.1f; break; + case sf::Keyboard::Right: *(settings[currentSetting].value) += 0.1f; break; + default: break; + } + } + } + + // Clear, draw graphics objects and display + window.clear(); + + window.draw(statusText); + + if (prerequisitesSupported) + { + { + sf::Lock lock(workQueueMutex); + + // Don't bother updating/drawing the VertexBuffer while terrain is being regenerated + if (!pendingWorkCount) + { + // If there is new data pending to be uploaded to the VertexBuffer, do it now + if (bufferUploadPending) + { + terrain.update(&terrainStagingBuffer[0]); + bufferUploadPending = false; + } + + terrainShader.setUniform("lightFactor", lightFactor); + window.draw(terrain, terrainStates); + } + } + + // Update and draw the HUD text + osstr.str(""); + osstr << "Frame: " << clock.restart().asMilliseconds() << "ms\n" + << "perlinOctaves: " << perlinOctaves << "\n\n" + << "Use the arrow keys to change the values.\nUse the return key to regenerate the terrain.\n\n"; + + for (int i = 0; i < settingCount; ++i) + osstr << ((i == currentSetting) ? ">> " : " ") << settings[i].name << ": " << *(settings[i].value) << "\n"; + + hudText.setString(osstr.str()); + + window.draw(hudText); + } + + // Display things on screen + window.display(); + } + + // Shut down our thread pool + { + sf::Lock lock(workQueueMutex); + workPending = false; + } + + while (!threads.empty()) + { + threads.back()->wait(); + delete threads.back(); + threads.pop_back(); + } + + return EXIT_SUCCESS; +} + + +//////////////////////////////////////////////////////////// +/// Get the terrain elevation at the given coordinates. +/// +//////////////////////////////////////////////////////////// +float getElevation(float x, float y) +{ + x = x / resolutionX - 0.5f; + y = y / resolutionY - 0.5f; + + float elevation = 0.0f; + + for (int i = 0; i < perlinOctaves; i++) + { + elevation += stb_perlin_noise3( + x * perlinFrequency * static_cast(std::pow(perlinFrequencyBase, i)), + y * perlinFrequency * static_cast(std::pow(perlinFrequencyBase, i)), + 0, 0, 0, 0 + ) * static_cast(std::pow(perlinFrequencyBase, -i)); + } + + elevation = (elevation + 1.f) / 2.f; + + float distance = 2.0f * std::sqrt(x * x + y * y); + elevation = (elevation + heightBase) * (1.0f - edgeFactor * std::pow(distance, edgeDropoffExponent)); + elevation = std::min(std::max(elevation, 0.0f), 1.0f); + + return elevation; +} + +float getElevation(unsigned int x, unsigned int y) +{ + return getElevation(static_cast(x), static_cast(y)); +} + + +//////////////////////////////////////////////////////////// +/// Get the terrain moisture at the given coordinates. +/// +//////////////////////////////////////////////////////////// +float getMoisture(float x, float y) +{ + x = x / resolutionX - 0.5f; + y = y / resolutionY - 0.5f; + + float moisture = stb_perlin_noise3( + x * 4.f + 0.5f, + y * 4.f + 0.5f, + 0, 0, 0, 0 + ); + + return (moisture + 1.f) / 2.f; +} + +float getMoisture(unsigned int x, unsigned int y) +{ + return getMoisture(static_cast(x), static_cast(y)); +} + + +//////////////////////////////////////////////////////////// +/// Get the lowlands terrain color for the given moisture. +/// +//////////////////////////////////////////////////////////// +sf::Color colorFromFloats(float r, float g, float b) +{ + return sf::Color(static_cast(r), + static_cast(g), + static_cast(b)); +} + +sf::Color getLowlandsTerrainColor(float moisture) +{ + sf::Color color = + moisture < 0.27f ? colorFromFloats(240, 240, 180) : + moisture < 0.3f ? colorFromFloats(240 - (240 * (moisture - 0.27f) / 0.03f), 240 - (40 * (moisture - 0.27f) / 0.03f), 180 - (180 * (moisture - 0.27f) / 0.03f)) : + moisture < 0.4f ? colorFromFloats(0, 200, 0) : + moisture < 0.48f ? colorFromFloats(0, 200 - (40 * (moisture - 0.4f) / 0.08f), 0) : + moisture < 0.6f ? colorFromFloats(0, 160, 0) : + moisture < 0.7f ? colorFromFloats((34 * (moisture - 0.6f) / 0.1f), 160 - (60 * (moisture - 0.6f) / 0.1f), (34 * (moisture - 0.6f) / 0.1f)) : + colorFromFloats(34, 100, 34); + + return color; +} + + +//////////////////////////////////////////////////////////// +/// Get the highlands terrain color for the given elevation +/// and moisture. +/// +//////////////////////////////////////////////////////////// +sf::Color getHighlandsTerrainColor(float elevation, float moisture) +{ + sf::Color lowlandsColor = getLowlandsTerrainColor(moisture); + + sf::Color color = + moisture < 0.6f ? sf::Color(112, 128, 144) : + colorFromFloats(112 + (110 * (moisture - 0.6f) / 0.4f), 128 + (56 * (moisture - 0.6f) / 0.4f), 144 - (9 * (moisture - 0.6f) / 0.4f)); + + float factor = std::min((elevation - 0.4f) / 0.1f, 1.f); + + color.r = static_cast(lowlandsColor.r * (1.f - factor) + color.r * factor); + color.g = static_cast(lowlandsColor.g * (1.f - factor) + color.g * factor); + color.b = static_cast(lowlandsColor.b * (1.f - factor) + color.b * factor); + + return color; +} + + +//////////////////////////////////////////////////////////// +/// Get the snowcap terrain color for the given elevation +/// and moisture. +/// +//////////////////////////////////////////////////////////// +sf::Color getSnowcapTerrainColor(float elevation, float moisture) +{ + sf::Color highlandsColor = getHighlandsTerrainColor(elevation, moisture); + + sf::Color color = sf::Color::White; + + float factor = std::min((elevation - snowcapHeight) / 0.05f, 1.f); + + color.r = static_cast(highlandsColor.r * (1.f - factor) + color.r * factor); + color.g = static_cast(highlandsColor.g * (1.f - factor) + color.g * factor); + color.b = static_cast(highlandsColor.b * (1.f - factor) + color.b * factor); + + return color; +} + + +//////////////////////////////////////////////////////////// +/// Get the terrain color for the given elevation and +/// moisture. +/// +//////////////////////////////////////////////////////////// +sf::Color getTerrainColor(float elevation, float moisture) +{ + sf::Color color = + elevation < 0.11f ? sf::Color(0, 0, static_cast(elevation / 0.11f * 74.f + 181.0f)) : + elevation < 0.14f ? sf::Color(static_cast(std::pow((elevation - 0.11f) / 0.03f, 0.3f) * 48.f), static_cast(std::pow((elevation - 0.11f) / 0.03f, 0.3f) * 48.f), 255) : + elevation < 0.16f ? sf::Color(static_cast((elevation - 0.14f) * 128.f / 0.02f + 48.f), static_cast((elevation - 0.14f) * 128.f / 0.02f + 48.f), static_cast(127.0f + (0.16f - elevation) * 128.f / 0.02f)) : + elevation < 0.17f ? sf::Color(240, 230, 140) : + elevation < 0.4f ? getLowlandsTerrainColor(moisture) : + elevation < snowcapHeight ? getHighlandsTerrainColor(elevation, moisture) : + getSnowcapTerrainColor(elevation, moisture); + + return color; +} + + +//////////////////////////////////////////////////////////// +/// Compute a compressed representation of the surface +/// normal based on the given coordinates, and the elevation +/// of the 4 adjacent neighbours. +/// +//////////////////////////////////////////////////////////// +sf::Vector2f computeNormal(float left, float right, float bottom, float top) +{ + sf::Vector3f deltaX(1, 0, (std::pow(right, heightFlatten) - std::pow(left, heightFlatten)) * heightFactor); + sf::Vector3f deltaY(0, 1, (std::pow(top, heightFlatten) - std::pow(bottom, heightFlatten)) * heightFactor); + + sf::Vector3f crossProduct( + deltaX.y * deltaY.z - deltaX.z * deltaY.y, + deltaX.z * deltaY.x - deltaX.x * deltaY.z, + deltaX.x * deltaY.y - deltaX.y * deltaY.x + ); + + // Scale cross product to make z component 1.0f so we can drop it + crossProduct /= crossProduct.z; + + // Return "compressed" normal + return sf::Vector2f(crossProduct.x, crossProduct.y); +} + + +//////////////////////////////////////////////////////////// +/// Process a terrain generation work item. Use the vector +/// of vertices as scratch memory and upload the data to +/// the vertex buffer when done. +/// +//////////////////////////////////////////////////////////// +void processWorkItem(std::vector& vertices, const WorkItem& workItem) +{ + unsigned int rowBlockSize = (resolutionY / blockCount) + 1; + unsigned int rowStart = rowBlockSize * workItem.index; + + if (rowStart >= resolutionY) + return; + + unsigned int rowEnd = std::min(rowStart + rowBlockSize, resolutionY); + unsigned int rowCount = rowEnd - rowStart; + + const float scalingFactorX = static_cast(windowWidth) / static_cast(resolutionX); + const float scalingFactorY = static_cast(windowHeight) / static_cast(resolutionY); + + for (unsigned int y = rowStart; y < rowEnd; y++) + { + for (unsigned int x = 0; x < resolutionX; x++) + { + unsigned int arrayIndexBase = ((y - rowStart) * resolutionX + x) * 6; + + // Top left corner (first triangle) + if (x > 0) + { + vertices[arrayIndexBase + 0] = vertices[arrayIndexBase - 6 + 5]; + } + else if (y > rowStart) + { + vertices[arrayIndexBase + 0] = vertices[arrayIndexBase - resolutionX * 6 + 1]; + } + else + { + vertices[arrayIndexBase + 0].position = sf::Vector2f(static_cast(x) * scalingFactorX, static_cast(y) * scalingFactorY); + vertices[arrayIndexBase + 0].color = getTerrainColor(getElevation(x, y), getMoisture(x, y)); + vertices[arrayIndexBase + 0].texCoords = computeNormal(getElevation(x - 1, y), getElevation(x + 1, y), getElevation(x, y + 1), getElevation(x, y - 1)); + } + + // Bottom left corner (first triangle) + if (x > 0) + { + vertices[arrayIndexBase + 1] = vertices[arrayIndexBase - 6 + 2]; + } + else + { + vertices[arrayIndexBase + 1].position = sf::Vector2f(static_cast(x) * scalingFactorX, static_cast(y + 1) * scalingFactorY); + vertices[arrayIndexBase + 1].color = getTerrainColor(getElevation(x, y + 1), getMoisture(x, y + 1)); + vertices[arrayIndexBase + 1].texCoords = computeNormal(getElevation(x - 1, y + 1), getElevation(x + 1, y + 1), getElevation(x, y + 2), getElevation(x, y)); + } + + // Bottom right corner (first triangle) + vertices[arrayIndexBase + 2].position = sf::Vector2f(static_cast(x + 1) * scalingFactorX, static_cast(y + 1) * scalingFactorY); + vertices[arrayIndexBase + 2].color = getTerrainColor(getElevation(x + 1, y + 1), getMoisture(x + 1, y + 1)); + vertices[arrayIndexBase + 2].texCoords = computeNormal(getElevation(x, y + 1), getElevation(x + 2, y + 1), getElevation(x + 1, y + 2), getElevation(x + 1, y)); + + // Top left corner (second triangle) + vertices[arrayIndexBase + 3] = vertices[arrayIndexBase + 0]; + + // Bottom right corner (second triangle) + vertices[arrayIndexBase + 4] = vertices[arrayIndexBase + 2]; + + // Top right corner (second triangle) + if (y > rowStart) + { + vertices[arrayIndexBase + 5] = vertices[arrayIndexBase - resolutionX * 6 + 2]; + } + else + { + vertices[arrayIndexBase + 5].position = sf::Vector2f(static_cast(x + 1) * scalingFactorX, static_cast(y) * scalingFactorY); + vertices[arrayIndexBase + 5].color = getTerrainColor(getElevation(x + 1, y), getMoisture(x + 1, y)); + vertices[arrayIndexBase + 5].texCoords = computeNormal(getElevation(x, y), getElevation(x + 2, y), getElevation(x + 1, y + 1), getElevation(x + 1, y - 1)); + } + } + } + + // Copy the resulting geometry from our thread-local buffer into the target buffer + std::memcpy(workItem.targetBuffer + (resolutionX * rowStart * 6), &vertices[0], sizeof(sf::Vertex) * resolutionX * rowCount * 6); +} + + +//////////////////////////////////////////////////////////// +/// Worker thread entry point. We use a thread pool to avoid +/// the heavy cost of constantly recreating and starting +/// new threads whenever we need to regenerate the terrain. +/// +//////////////////////////////////////////////////////////// +void threadFunction() +{ + unsigned int rowBlockSize = (resolutionY / blockCount) + 1; + + std::vector vertices(resolutionX * rowBlockSize * 6); + + WorkItem workItem = {0, 0}; + + // Loop until the application exits + for (;;) + { + workItem.targetBuffer = 0; + + // Check if there are new work items in the queue + { + sf::Lock lock(workQueueMutex); + + if (!workPending) + return; + + if (!workQueue.empty()) + { + workItem = workQueue.front(); + workQueue.pop_front(); + } + } + + // If we didn't receive a new work item, keep looping + if (!workItem.targetBuffer) + { + sf::sleep(sf::milliseconds(10)); + + continue; + } + + processWorkItem(vertices, workItem); + + { + sf::Lock lock(workQueueMutex); + + --pendingWorkCount; + } + } +} + + +//////////////////////////////////////////////////////////// +/// Terrain generation entry point. This queues up the +/// generation work items which the worker threads dequeue +/// and process. +/// +//////////////////////////////////////////////////////////// +void generateTerrain(sf::Vertex* buffer) +{ + bufferUploadPending = true; + + // Make sure the work queue is empty before queuing new work + for (;;) + { + { + sf::Lock lock(workQueueMutex); + + if (workQueue.empty()) + break; + } + + sf::sleep(sf::milliseconds(10)); + } + + // Queue all the new work items + { + sf::Lock lock(workQueueMutex); + + for (unsigned int i = 0; i < blockCount; i++) + { + WorkItem workItem = {buffer, i}; + workQueue.push_back(workItem); + } + + pendingWorkCount = blockCount; + } +} diff --git a/Space-Invaders/sfml/examples/island/resources/terrain.frag b/Space-Invaders/sfml/examples/island/resources/terrain.frag new file mode 100644 index 000000000..ae1818713 --- /dev/null +++ b/Space-Invaders/sfml/examples/island/resources/terrain.frag @@ -0,0 +1,11 @@ +varying vec3 normal; +uniform float lightFactor; + +void main() +{ + vec3 lightPosition = vec3(-1.0, 1.0, 1.0); + vec3 eyePosition = vec3(0.0, 0.0, 1.0); + vec3 halfVector = normalize(lightPosition + eyePosition); + float intensity = lightFactor + (1.0 - lightFactor) * dot(normalize(normal), normalize(halfVector)); + gl_FragColor = gl_Color * vec4(intensity, intensity, intensity, 1.0); +} diff --git a/Space-Invaders/sfml/examples/island/resources/terrain.vert b/Space-Invaders/sfml/examples/island/resources/terrain.vert new file mode 100644 index 000000000..a06996df5 --- /dev/null +++ b/Space-Invaders/sfml/examples/island/resources/terrain.vert @@ -0,0 +1,8 @@ +varying vec3 normal; + +void main() +{ + gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; + gl_FrontColor = gl_Color; + normal = vec3(gl_MultiTexCoord0.xy, 1.0); +} diff --git a/Space-Invaders/sfml/examples/island/resources/tuffy.ttf b/Space-Invaders/sfml/examples/island/resources/tuffy.ttf new file mode 100644 index 000000000..8ea647090 Binary files /dev/null and b/Space-Invaders/sfml/examples/island/resources/tuffy.ttf differ diff --git a/Space-Invaders/sfml/examples/joystick/Joystick.cpp b/Space-Invaders/sfml/examples/joystick/Joystick.cpp new file mode 100644 index 000000000..d3a635ffa --- /dev/null +++ b/Space-Invaders/sfml/examples/joystick/Joystick.cpp @@ -0,0 +1,238 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include +#include +#include + + +namespace +{ + struct JoystickObject + { + sf::Text label; + sf::Text value; + }; + + typedef std::map Texts; + Texts texts; + std::ostringstream sstr; + float threshold = 0.1f; + + // Axes labels in as C strings + const char* axislabels[] = {"X", "Y", "Z", "R", "U", "V", "PovX", "PovY"}; + + // Helper to set text entries to a specified value + template + void set(const char* label, const T& value) + { + sstr.str(""); + sstr << value; + texts[label].value.setString(sstr.str()); + } + + // Update joystick identification + void updateIdentification(unsigned int index) + { + sstr.str(""); + sstr << "Joystick " << index << ":"; + texts["ID"].label.setString(sstr.str()); + texts["ID"].value.setString(sf::Joystick::getIdentification(index).name); + } + + // Update joystick axes + void updateAxes(unsigned int index) + { + for (unsigned int j = 0; j < sf::Joystick::AxisCount; ++j) + { + if (sf::Joystick::hasAxis(index, static_cast(j))) + set(axislabels[j], sf::Joystick::getAxisPosition(index, static_cast(j))); + } + } + + // Update joystick buttons + void updateButtons(unsigned int index) + { + for (unsigned int j = 0; j < sf::Joystick::getButtonCount(index); ++j) + { + sstr.str(""); + sstr << "Button " << j; + + set(sstr.str().c_str(), sf::Joystick::isButtonPressed(index, j)); + } + } + + // Helper to update displayed joystick values + void updateValues(unsigned int index) + { + if (sf::Joystick::isConnected(index)) { + // Update the label-value sf::Text objects based on the current joystick state + updateIdentification(index); + updateAxes(index); + updateButtons(index); + } + } +} + + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + // Create the window of the application + sf::RenderWindow window(sf::VideoMode(400, 775), "Joystick", sf::Style::Close); + window.setVerticalSyncEnabled(true); + + // Load the text font + sf::Font font; + if (!font.loadFromFile("resources/tuffy.ttf")) + return EXIT_FAILURE; + + // Set up our string conversion parameters + sstr.precision(2); + sstr.setf(std::ios::fixed | std::ios::boolalpha); + + // Set up our joystick identification sf::Text objects + texts["ID"].label.setPosition(5.f, 5.f); + texts["ID"].value.setPosition(80.f, 5.f); + + texts["ID"].label.setString(""); + texts["ID"].value.setString(""); + + // Set up our threshold sf::Text objects + sstr.str(""); + sstr << threshold << " (Change with up/down arrow keys)"; + + texts["Threshold"].label.setPosition(5.f, 5.f + 2 * font.getLineSpacing(14)); + texts["Threshold"].value.setPosition(80.f, 5.f + 2 * font.getLineSpacing(14)); + + texts["Threshold"].label.setString("Threshold:"); + texts["Threshold"].value.setString(sstr.str()); + + // Set up our label-value sf::Text objects + for (unsigned int i = 0; i < sf::Joystick::AxisCount; ++i) + { + JoystickObject& object = texts[axislabels[i]]; + + object.label.setPosition(5.f, 5.f + (static_cast(i + 4) * font.getLineSpacing(14))); + object.label.setString(std::string(axislabels[i]) + ":"); + + object.value.setPosition(80.f, 5.f + (static_cast(i + 4) * font.getLineSpacing(14))); + object.value.setString("N/A"); + } + + for (unsigned int i = 0; i < sf::Joystick::ButtonCount; ++i) + { + sstr.str(""); + sstr << "Button " << i; + JoystickObject& object = texts[sstr.str()]; + + object.label.setPosition(5.f, 5.f + (static_cast(sf::Joystick::AxisCount + i + 4) * font.getLineSpacing(14))); + object.label.setString(sstr.str() + ":"); + + object.value.setPosition(80.f, 5.f + (static_cast(sf::Joystick::AxisCount + i + 4) * font.getLineSpacing(14))); + object.value.setString("N/A"); + } + + for (Texts::iterator it = texts.begin(); it != texts.end(); ++it) + { + it->second.label.setFont(font); + it->second.label.setCharacterSize(14); + it->second.label.setFillColor(sf::Color::White); + + it->second.value.setFont(font); + it->second.value.setCharacterSize(14); + it->second.value.setFillColor(sf::Color::White); + } + + // Update initially displayed joystick values if a joystick is already connected on startup + for (unsigned int i = 0; i < sf::Joystick::Count; ++i) + { + if (sf::Joystick::isConnected(i)) + { + updateValues(i); + break; + } + } + + while (window.isOpen()) + { + // Handle events + sf::Event event; + while (window.pollEvent(event)) + { + // Window closed or escape key pressed: exit + if ((event.type == sf::Event::Closed) || + ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))) + { + window.close(); + break; + } + else if ((event.type == sf::Event::JoystickButtonPressed) || + (event.type == sf::Event::JoystickButtonReleased) || + (event.type == sf::Event::JoystickMoved) || + (event.type == sf::Event::JoystickConnected)) + { + // Update displayed joystick values + updateValues(event.joystickConnect.joystickId); + } + else if (event.type == sf::Event::JoystickDisconnected) + { + // Reset displayed joystick values to empty + for (Texts::iterator it = texts.begin(); it != texts.end(); ++it) + it->second.value.setString("N/A"); + + texts["ID"].label.setString(""); + texts["ID"].value.setString(""); + + sstr.str(""); + sstr << threshold << " (Change with up/down arrow keys)"; + + texts["Threshold"].value.setString(sstr.str()); + } + } + + // Update threshold if the user wants to change it + float newThreshold = threshold; + + if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) + newThreshold += 0.1f; + + if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) + newThreshold -= 0.1f; + + newThreshold = std::min(std::max(newThreshold, 0.1f), 100.0f); + + if (newThreshold != threshold) + { + threshold = newThreshold; + window.setJoystickThreshold(threshold); + + sstr.str(""); + sstr << threshold << " (Change with up/down arrow keys)"; + + texts["Threshold"].value.setString(sstr.str()); + } + + // Clear the window + window.clear(); + + // Draw the label-value sf::Text objects + for (Texts::const_iterator it = texts.begin(); it != texts.end(); ++it) + { + window.draw(it->second.label); + window.draw(it->second.value); + } + + // Display things on screen + window.display(); + } +} diff --git a/Space-Invaders/sfml/examples/joystick/resources/tuffy.ttf b/Space-Invaders/sfml/examples/joystick/resources/tuffy.ttf new file mode 100644 index 000000000..8ea647090 Binary files /dev/null and b/Space-Invaders/sfml/examples/joystick/resources/tuffy.ttf differ diff --git a/Space-Invaders/sfml/examples/opengl/OpenGL.cpp b/Space-Invaders/sfml/examples/opengl/OpenGL.cpp new file mode 100644 index 000000000..3f726feed --- /dev/null +++ b/Space-Invaders/sfml/examples/opengl/OpenGL.cpp @@ -0,0 +1,310 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include + +#define GLAD_GL_IMPLEMENTATION +#include + +#ifdef SFML_SYSTEM_IOS +#include +#endif + +#ifndef GL_SRGB8_ALPHA8 +#define GL_SRGB8_ALPHA8 0x8C43 +#endif + +std::string resourcesDir() +{ +#ifdef SFML_SYSTEM_IOS + return ""; +#else + return "resources/"; +#endif +} + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + bool exit = false; + bool sRgb = false; + + while (!exit) + { + // Request a 24-bits depth buffer when creating the window + sf::ContextSettings contextSettings; + contextSettings.depthBits = 24; + contextSettings.sRgbCapable = sRgb; + + // Create the main window + sf::RenderWindow window(sf::VideoMode(800, 600), "SFML graphics with OpenGL", sf::Style::Default, contextSettings); + window.setVerticalSyncEnabled(true); + + // Create a sprite for the background + sf::Texture backgroundTexture; + backgroundTexture.setSrgb(sRgb); + if (!backgroundTexture.loadFromFile(resourcesDir() + "background.jpg")) + return EXIT_FAILURE; + sf::Sprite background(backgroundTexture); + + // Create some text to draw on top of our OpenGL object + sf::Font font; + if (!font.loadFromFile(resourcesDir() + "tuffy.ttf")) + return EXIT_FAILURE; + sf::Text text("SFML / OpenGL demo", font); + sf::Text sRgbInstructions("Press space to toggle sRGB conversion", font); + sf::Text mipmapInstructions("Press return to toggle mipmapping", font); + text.setFillColor(sf::Color(255, 255, 255, 170)); + sRgbInstructions.setFillColor(sf::Color(255, 255, 255, 170)); + mipmapInstructions.setFillColor(sf::Color(255, 255, 255, 170)); + text.setPosition(280.f, 450.f); + sRgbInstructions.setPosition(175.f, 500.f); + mipmapInstructions.setPosition(200.f, 550.f); + + // Load a texture to apply to our 3D cube + sf::Texture texture; + if (!texture.loadFromFile(resourcesDir() + "logo.png")) + return EXIT_FAILURE; + + // Attempt to generate a mipmap for our cube texture + // We don't check the return value here since + // mipmapping is purely optional in this example + texture.generateMipmap(); + + // Make the window the active window for OpenGL calls + window.setActive(true); + + // Load OpenGL or OpenGL ES entry points using glad +#ifdef SFML_OPENGL_ES + gladLoadGLES1(reinterpret_cast(sf::Context::getFunction)); +#else + gladLoadGL(reinterpret_cast(sf::Context::getFunction)); +#endif + + // Enable Z-buffer read and write + glEnable(GL_DEPTH_TEST); + glDepthMask(GL_TRUE); +#ifdef SFML_OPENGL_ES + glClearDepthf(1.f); +#else + glClearDepth(1.f); +#endif + + // Disable lighting + glDisable(GL_LIGHTING); + + // Configure the viewport (the same size as the window) + glViewport(0, 0, static_cast(window.getSize().x), static_cast(window.getSize().y)); + + // Setup a perspective projection + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + GLfloat ratio = static_cast(window.getSize().x) / static_cast(window.getSize().y); +#ifdef SFML_OPENGL_ES + glFrustumf(-ratio, ratio, -1.f, 1.f, 1.f, 500.f); +#else + glFrustum(-ratio, ratio, -1.f, 1.f, 1.f, 500.f); +#endif + + // Bind the texture + glEnable(GL_TEXTURE_2D); + sf::Texture::bind(&texture); + + // Define a 3D cube (6 faces made of 2 triangles composed by 3 vertices) + static const GLfloat cube[] = + { + // positions // texture coordinates + -20, -20, -20, 0, 0, + -20, 20, -20, 1, 0, + -20, -20, 20, 0, 1, + -20, -20, 20, 0, 1, + -20, 20, -20, 1, 0, + -20, 20, 20, 1, 1, + + 20, -20, -20, 0, 0, + 20, 20, -20, 1, 0, + 20, -20, 20, 0, 1, + 20, -20, 20, 0, 1, + 20, 20, -20, 1, 0, + 20, 20, 20, 1, 1, + + -20, -20, -20, 0, 0, + 20, -20, -20, 1, 0, + -20, -20, 20, 0, 1, + -20, -20, 20, 0, 1, + 20, -20, -20, 1, 0, + 20, -20, 20, 1, 1, + + -20, 20, -20, 0, 0, + 20, 20, -20, 1, 0, + -20, 20, 20, 0, 1, + -20, 20, 20, 0, 1, + 20, 20, -20, 1, 0, + 20, 20, 20, 1, 1, + + -20, -20, -20, 0, 0, + 20, -20, -20, 1, 0, + -20, 20, -20, 0, 1, + -20, 20, -20, 0, 1, + 20, -20, -20, 1, 0, + 20, 20, -20, 1, 1, + + -20, -20, 20, 0, 0, + 20, -20, 20, 1, 0, + -20, 20, 20, 0, 1, + -20, 20, 20, 0, 1, + 20, -20, 20, 1, 0, + 20, 20, 20, 1, 1 + }; + + // Enable position and texture coordinates vertex components + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glVertexPointer(3, GL_FLOAT, 5 * sizeof(GLfloat), cube); + glTexCoordPointer(2, GL_FLOAT, 5 * sizeof(GLfloat), cube + 3); + + // Disable normal and color vertex components + glDisableClientState(GL_NORMAL_ARRAY); + glDisableClientState(GL_COLOR_ARRAY); + + // Make the window no longer the active window for OpenGL calls + window.setActive(false); + + // Create a clock for measuring the time elapsed + sf::Clock clock; + + // Flag to track whether mipmapping is currently enabled + bool mipmapEnabled = true; + + // Start game loop + while (window.isOpen()) + { + // Process events + sf::Event event; + while (window.pollEvent(event)) + { + // Close window: exit + if (event.type == sf::Event::Closed) + { + exit = true; + window.close(); + } + + // Escape key: exit + if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape)) + { + exit = true; + window.close(); + } + + // Return key: toggle mipmapping + if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Enter)) + { + if (mipmapEnabled) + { + // We simply reload the texture to disable mipmapping + if (!texture.loadFromFile(resourcesDir() + "logo.png")) + return EXIT_FAILURE; + + mipmapEnabled = false; + } + else + { + texture.generateMipmap(); + + mipmapEnabled = true; + } + } + + // Space key: toggle sRGB conversion + if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Space)) + { + sRgb = !sRgb; + window.close(); + } + + // Adjust the viewport when the window is resized + if (event.type == sf::Event::Resized) + { + sf::Vector2u textureSize = backgroundTexture.getSize(); + + // Make the window the active window for OpenGL calls + window.setActive(true); + + glViewport(0, 0, static_cast(event.size.width), static_cast(event.size.height)); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + GLfloat newRatio = static_cast(event.size.width) / static_cast(event.size.height); +#ifdef SFML_OPENGL_ES + glFrustumf(-newRatio, newRatio, -1.f, 1.f, 1.f, 500.f); +#else + glFrustum(-newRatio, newRatio, -1.f, 1.f, 1.f, 500.f); +#endif + + // Make the window no longer the active window for OpenGL calls + window.setActive(false); + + sf::View view; + view.setSize(sf::Vector2f(textureSize)); + view.setCenter(sf::Vector2f(textureSize) / 2.f); + window.setView(view); + } + } + + // Draw the background + window.pushGLStates(); + window.draw(background); + window.popGLStates(); + + // Make the window the active window for OpenGL calls + window.setActive(true); + + // Clear the depth buffer + glClear(GL_DEPTH_BUFFER_BIT); + + // We get the position of the mouse cursor (or touch), so that we can move the box accordingly + sf::Vector2i pos; + + #ifdef SFML_SYSTEM_IOS + pos = sf::Touch::getPosition(0); + #else + pos = sf::Mouse::getPosition(window); + #endif + + float x = static_cast(pos.x) * 200.f / static_cast(window.getSize().x) - 100.f; + float y = -static_cast(pos.y) * 200.f / static_cast(window.getSize().y) + 100.f; + + // Apply some transformations + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(x, y, -100.f); + glRotatef(clock.getElapsedTime().asSeconds() * 50.f, 1.f, 0.f, 0.f); + glRotatef(clock.getElapsedTime().asSeconds() * 30.f, 0.f, 1.f, 0.f); + glRotatef(clock.getElapsedTime().asSeconds() * 90.f, 0.f, 0.f, 1.f); + + // Draw the cube + glDrawArrays(GL_TRIANGLES, 0, 36); + + // Make the window no longer the active window for OpenGL calls + window.setActive(false); + + // Draw some text on top of our OpenGL object + window.pushGLStates(); + window.draw(text); + window.draw(sRgbInstructions); + window.draw(mipmapInstructions); + window.popGLStates(); + + // Finally, display the rendered frame on screen + window.display(); + } + } + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/examples/opengl/resources/background.jpg b/Space-Invaders/sfml/examples/opengl/resources/background.jpg new file mode 100644 index 000000000..fb3b41856 Binary files /dev/null and b/Space-Invaders/sfml/examples/opengl/resources/background.jpg differ diff --git a/Space-Invaders/sfml/examples/opengl/resources/logo.png b/Space-Invaders/sfml/examples/opengl/resources/logo.png new file mode 100644 index 000000000..ffee4ce86 Binary files /dev/null and b/Space-Invaders/sfml/examples/opengl/resources/logo.png differ diff --git a/Space-Invaders/sfml/examples/opengl/resources/tuffy.ttf b/Space-Invaders/sfml/examples/opengl/resources/tuffy.ttf new file mode 100644 index 000000000..8ea647090 Binary files /dev/null and b/Space-Invaders/sfml/examples/opengl/resources/tuffy.ttf differ diff --git a/Space-Invaders/sfml/examples/shader/Effect.hpp b/Space-Invaders/sfml/examples/shader/Effect.hpp new file mode 100644 index 000000000..0ff65b433 --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/Effect.hpp @@ -0,0 +1,88 @@ +#ifndef EFFECT_HPP +#define EFFECT_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include + + +//////////////////////////////////////////////////////////// +// Base class for effects +//////////////////////////////////////////////////////////// +class Effect : public sf::Drawable +{ +public: + + virtual ~Effect() + { + } + + static void setFont(const sf::Font& font) + { + s_font = &font; + } + + const std::string& getName() const + { + return m_name; + } + + void load() + { + m_isLoaded = sf::Shader::isAvailable() && onLoad(); + } + + void update(float time, float x, float y) + { + if (m_isLoaded) + onUpdate(time, x, y); + } + + void draw(sf::RenderTarget& target, sf::RenderStates states) const + { + if (m_isLoaded) + { + onDraw(target, states); + } + else + { + sf::Text error("Shader not\nsupported", getFont()); + error.setPosition(320.f, 200.f); + error.setCharacterSize(36); + target.draw(error, states); + } + } + +protected: + + Effect(const std::string& name) : + m_name(name), + m_isLoaded(false) + { + } + + static const sf::Font& getFont() + { + assert(s_font != NULL); + return *s_font; + } + +private: + + // Virtual functions to be implemented in derived effects + virtual bool onLoad() = 0; + virtual void onUpdate(float time, float x, float y) = 0; + virtual void onDraw(sf::RenderTarget& target, sf::RenderStates states) const = 0; + +private: + + std::string m_name; + bool m_isLoaded; + + static const sf::Font* s_font; +}; + +#endif // EFFECT_HPP diff --git a/Space-Invaders/sfml/examples/shader/Shader.cpp b/Space-Invaders/sfml/examples/shader/Shader.cpp new file mode 100644 index 000000000..7cb8cd79c --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/Shader.cpp @@ -0,0 +1,464 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include "Effect.hpp" +#include +#include + + +const sf::Font* Effect::s_font = NULL; + +//////////////////////////////////////////////////////////// +// "Pixelate" fragment shader +//////////////////////////////////////////////////////////// +class Pixelate : public Effect +{ +public: + + Pixelate() : + Effect("Pixelate") + { + } + + bool onLoad() + { + // Load the texture and initialize the sprite + if (!m_texture.loadFromFile("resources/background.jpg")) + return false; + m_sprite.setTexture(m_texture); + + // Load the shader + if (!m_shader.loadFromFile("resources/pixelate.frag", sf::Shader::Fragment)) + return false; + m_shader.setUniform("texture", sf::Shader::CurrentTexture); + + return true; + } + + void onUpdate(float, float x, float y) + { + m_shader.setUniform("pixel_threshold", (x + y) / 30); + } + + void onDraw(sf::RenderTarget& target, sf::RenderStates states) const + { + states.shader = &m_shader; + target.draw(m_sprite, states); + } + +private: + + sf::Texture m_texture; + sf::Sprite m_sprite; + sf::Shader m_shader; +}; + + +//////////////////////////////////////////////////////////// +// "Wave" vertex shader + "blur" fragment shader +//////////////////////////////////////////////////////////// +class WaveBlur : public Effect +{ +public: + + WaveBlur() : + Effect("Wave + Blur") + { + } + + bool onLoad() + { + // Create the text + m_text.setString("Praesent suscipit augue in velit pulvinar hendrerit varius purus aliquam.\n" + "Mauris mi odio, bibendum quis fringilla a, laoreet vel orci. Proin vitae vulputate tortor.\n" + "Praesent cursus ultrices justo, ut feugiat ante vehicula quis.\n" + "Donec fringilla scelerisque mauris et viverra.\n" + "Maecenas adipiscing ornare scelerisque. Nullam at libero elit.\n" + "Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.\n" + "Nullam leo urna, tincidunt id semper eget, ultricies sed mi.\n" + "Morbi mauris massa, commodo id dignissim vel, lobortis et elit.\n" + "Fusce vel libero sed neque scelerisque venenatis.\n" + "Integer mattis tincidunt quam vitae iaculis.\n" + "Vivamus fringilla sem non velit venenatis fermentum.\n" + "Vivamus varius tincidunt nisi id vehicula.\n" + "Integer ullamcorper, enim vitae euismod rutrum, massa nisl semper ipsum,\n" + "vestibulum sodales sem ante in massa.\n" + "Vestibulum in augue non felis convallis viverra.\n" + "Mauris ultricies dolor sed massa convallis sed aliquet augue fringilla.\n" + "Duis erat eros, porta in accumsan in, blandit quis sem.\n" + "In hac habitasse platea dictumst. Etiam fringilla est id odio dapibus sit amet semper dui laoreet.\n"); + m_text.setFont(getFont()); + m_text.setCharacterSize(22); + m_text.setPosition(30, 20); + + // Load the shader + if (!m_shader.loadFromFile("resources/wave.vert", "resources/blur.frag")) + return false; + + return true; + } + + void onUpdate(float time, float x, float y) + { + m_shader.setUniform("wave_phase", time); + m_shader.setUniform("wave_amplitude", sf::Vector2f(x * 40, y * 40)); + m_shader.setUniform("blur_radius", (x + y) * 0.008f); + } + + void onDraw(sf::RenderTarget& target, sf::RenderStates states) const + { + states.shader = &m_shader; + target.draw(m_text, states); + } + +private: + + sf::Text m_text; + sf::Shader m_shader; +}; + + +//////////////////////////////////////////////////////////// +// "Storm" vertex shader + "blink" fragment shader +//////////////////////////////////////////////////////////// +class StormBlink : public Effect +{ +public: + + StormBlink() : + Effect("Storm + Blink") + { + } + + bool onLoad() + { + // Create the points + m_points.setPrimitiveType(sf::Points); + for (int i = 0; i < 40000; ++i) + { + float x = static_cast(std::rand() % 800); + float y = static_cast(std::rand() % 600); + sf::Uint8 r = static_cast(std::rand() % 255); + sf::Uint8 g = static_cast(std::rand() % 255); + sf::Uint8 b = static_cast(std::rand() % 255); + m_points.append(sf::Vertex(sf::Vector2f(x, y), sf::Color(r, g, b))); + } + + // Load the shader + if (!m_shader.loadFromFile("resources/storm.vert", "resources/blink.frag")) + return false; + + return true; + } + + void onUpdate(float time, float x, float y) + { + float radius = 200 + std::cos(time) * 150; + m_shader.setUniform("storm_position", sf::Vector2f(x * 800, y * 600)); + m_shader.setUniform("storm_inner_radius", radius / 3); + m_shader.setUniform("storm_total_radius", radius); + m_shader.setUniform("blink_alpha", 0.5f + std::cos(time * 3) * 0.25f); + } + + void onDraw(sf::RenderTarget& target, sf::RenderStates states) const + { + states.shader = &m_shader; + target.draw(m_points, states); + } + +private: + + sf::VertexArray m_points; + sf::Shader m_shader; +}; + + +//////////////////////////////////////////////////////////// +// "Edge" post-effect fragment shader +//////////////////////////////////////////////////////////// +class Edge : public Effect +{ +public: + + Edge() : + Effect("Edge Post-effect") + { + } + + bool onLoad() + { + // Create the off-screen surface + if (!m_surface.create(800, 600)) + return false; + m_surface.setSmooth(true); + + // Load the textures + if (!m_backgroundTexture.loadFromFile("resources/sfml.png")) + return false; + m_backgroundTexture.setSmooth(true); + if (!m_entityTexture.loadFromFile("resources/devices.png")) + return false; + m_entityTexture.setSmooth(true); + + // Initialize the background sprite + m_backgroundSprite.setTexture(m_backgroundTexture); + m_backgroundSprite.setPosition(135, 100); + + // Load the moving entities + for (int i = 0; i < 6; ++i) + { + sf::Sprite entity(m_entityTexture, sf::IntRect(96 * i, 0, 96, 96)); + m_entities.push_back(entity); + } + + // Load the shader + if (!m_shader.loadFromFile("resources/edge.frag", sf::Shader::Fragment)) + return false; + m_shader.setUniform("texture", sf::Shader::CurrentTexture); + + return true; + } + + void onUpdate(float time, float x, float y) + { + m_shader.setUniform("edge_threshold", 1 - (x + y) / 2); + + // Update the position of the moving entities + for (std::size_t i = 0; i < m_entities.size(); ++i) + { + sf::Vector2f position; + position.x = std::cos(0.25f * (time * static_cast(i) + static_cast(m_entities.size() - i))) * 300 + 350; + position.y = std::sin(0.25f * (time * static_cast(m_entities.size() - i) + static_cast(i))) * 200 + 250; + m_entities[i].setPosition(position); + } + + // Render the updated scene to the off-screen surface + m_surface.clear(sf::Color::White); + m_surface.draw(m_backgroundSprite); + for (std::size_t i = 0; i < m_entities.size(); ++i) + m_surface.draw(m_entities[i]); + m_surface.display(); + } + + void onDraw(sf::RenderTarget& target, sf::RenderStates states) const + { + states.shader = &m_shader; + target.draw(sf::Sprite(m_surface.getTexture()), states); + } + +private: + + sf::RenderTexture m_surface; + sf::Texture m_backgroundTexture; + sf::Texture m_entityTexture; + sf::Sprite m_backgroundSprite; + std::vector m_entities; + sf::Shader m_shader; +}; + + +//////////////////////////////////////////////////////////// +// "Geometry" geometry shader example +//////////////////////////////////////////////////////////// +class Geometry : public Effect +{ +public: + + Geometry() : + Effect("Geometry Shader Billboards"), + m_pointCloud(sf::Points, 10000) + { + } + + bool onLoad() + { + // Check if geometry shaders are supported + if (!sf::Shader::isGeometryAvailable()) + return false; + + // Move the points in the point cloud to random positions + for (std::size_t i = 0; i < 10000; i++) + { + // Spread the coordinates from -480 to +480 + // So they'll always fill the viewport at 800x600 + m_pointCloud[i].position.x = static_cast(rand() % 960) - 480.f; + m_pointCloud[i].position.y = static_cast(rand() % 960) - 480.f; + } + + // Load the texture + if (!m_logoTexture.loadFromFile("resources/logo.png")) + return false; + + // Load the shader + if (!m_shader.loadFromFile("resources/billboard.vert", "resources/billboard.geom", "resources/billboard.frag")) + return false; + m_shader.setUniform("texture", sf::Shader::CurrentTexture); + + // Set the render resolution (used for proper scaling) + m_shader.setUniform("resolution", sf::Vector2f(800, 600)); + + return true; + } + + void onUpdate(float /*time*/, float x, float y) + { + // Reset our transformation matrix + m_transform = sf::Transform::Identity; + // Move to the center of the window + m_transform.translate(400, 300); + // Rotate everything based on cursor position + m_transform.rotate(x * 360.f); + + // Adjust billboard size to scale between 25 and 75 + float size = 25 + std::abs(y) * 50; + + // Update the shader parameter + m_shader.setUniform("size", sf::Vector2f(size, size)); + } + + void onDraw(sf::RenderTarget& target, sf::RenderStates states) const + { + // Prepare the render state + states.shader = &m_shader; + states.texture = &m_logoTexture; + states.transform = m_transform; + + // Draw the point cloud + target.draw(m_pointCloud, states); + } + +private: + + sf::Texture m_logoTexture; + sf::Transform m_transform; + sf::Shader m_shader; + sf::VertexArray m_pointCloud; +}; + + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + // Create the main window + sf::RenderWindow window(sf::VideoMode(800, 600), "SFML Shader", + sf::Style::Titlebar | sf::Style::Close); + window.setVerticalSyncEnabled(true); + + // Load the application font and pass it to the Effect class + sf::Font font; + if (!font.loadFromFile("resources/tuffy.ttf")) + return EXIT_FAILURE; + Effect::setFont(font); + + // Create the effects + std::vector effects; + effects.push_back(new Pixelate); + effects.push_back(new WaveBlur); + effects.push_back(new StormBlink); + effects.push_back(new Edge); + effects.push_back(new Geometry); + std::size_t current = 0; + + // Initialize them + for (std::size_t i = 0; i < effects.size(); ++i) + effects[i]->load(); + + // Create the messages background + sf::Texture textBackgroundTexture; + if (!textBackgroundTexture.loadFromFile("resources/text-background.png")) + return EXIT_FAILURE; + sf::Sprite textBackground(textBackgroundTexture); + textBackground.setPosition(0, 520); + textBackground.setColor(sf::Color(255, 255, 255, 200)); + + // Create the description text + sf::Text description("Current effect: " + effects[current]->getName(), font, 20); + description.setPosition(10, 530); + description.setFillColor(sf::Color(80, 80, 80)); + + // Create the instructions text + sf::Text instructions("Press left and right arrows to change the current shader", font, 20); + instructions.setPosition(280, 555); + instructions.setFillColor(sf::Color(80, 80, 80)); + + // Start the game loop + sf::Clock clock; + while (window.isOpen()) + { + // Process events + sf::Event event; + while (window.pollEvent(event)) + { + // Close window: exit + if (event.type == sf::Event::Closed) + window.close(); + + if (event.type == sf::Event::KeyPressed) + { + switch (event.key.code) + { + // Escape key: exit + case sf::Keyboard::Escape: + window.close(); + break; + + // Left arrow key: previous shader + case sf::Keyboard::Left: + if (current == 0) + current = effects.size() - 1; + else + current--; + description.setString("Current effect: " + effects[current]->getName()); + break; + + // Right arrow key: next shader + case sf::Keyboard::Right: + if (current == effects.size() - 1) + current = 0; + else + current++; + description.setString("Current effect: " + effects[current]->getName()); + break; + + default: + break; + } + } + } + + // Update the current example + float x = static_cast(sf::Mouse::getPosition(window).x) / static_cast(window.getSize().x); + float y = static_cast(sf::Mouse::getPosition(window).y) / static_cast(window.getSize().y); + effects[current]->update(clock.getElapsedTime().asSeconds(), x, y); + + // Clear the window + if(effects[current]->getName() == "Edge Post-effect"){ + window.clear(sf::Color::White); + } else { + window.clear(sf::Color(50, 50, 50)); + } + + // Draw the current example + window.draw(*effects[current]); + + // Draw the text + window.draw(textBackground); + window.draw(instructions); + window.draw(description); + + // Finally, display the rendered frame on screen + window.display(); + } + + // delete the effects + for (std::size_t i = 0; i < effects.size(); ++i) + delete effects[i]; + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/examples/shader/resources/background.jpg b/Space-Invaders/sfml/examples/shader/resources/background.jpg new file mode 100644 index 000000000..4c814cb41 Binary files /dev/null and b/Space-Invaders/sfml/examples/shader/resources/background.jpg differ diff --git a/Space-Invaders/sfml/examples/shader/resources/billboard.frag b/Space-Invaders/sfml/examples/shader/resources/billboard.frag new file mode 100644 index 000000000..3057f64b0 --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/resources/billboard.frag @@ -0,0 +1,11 @@ +#version 150 + +uniform sampler2D texture; + +in vec2 tex_coord; + +void main() +{ + // Read and apply a color from the texture + gl_FragColor = texture2D(texture, tex_coord); +} diff --git a/Space-Invaders/sfml/examples/shader/resources/billboard.geom b/Space-Invaders/sfml/examples/shader/resources/billboard.geom new file mode 100644 index 000000000..2f47a1faf --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/resources/billboard.geom @@ -0,0 +1,56 @@ +#version 150 + +// The render target's resolution (used for scaling) +uniform vec2 resolution; + +// The billboards' size +uniform vec2 size; + +// Input is the passed point cloud +layout (points) in; + +// The output will consist of triangle strips with four vertices each +layout (triangle_strip, max_vertices = 4) out; + +// Output texture coordinates +out vec2 tex_coord; + +// Main entry point +void main() +{ + // Caculate the half width/height of the billboards + vec2 half_size = size / 2.f; + + // Scale the size based on resolution (1 would be full width/height) + half_size /= resolution; + + // Iterate over all vertices + for (int i = 0; i < gl_in.length(); i++) + { + // Retrieve the passed vertex position + vec2 pos = gl_in[i].gl_Position.xy; + + // Bottom left vertex + gl_Position = vec4(pos - half_size, 0.f, 1.f); + tex_coord = vec2(1.f, 1.f); + EmitVertex(); + + // Bottom right vertex + gl_Position = vec4(pos.x + half_size.x, pos.y - half_size.y, 0.f, 1.f); + tex_coord = vec2(0.f, 1.f); + EmitVertex(); + + // Top left vertex + gl_Position = vec4(pos.x - half_size.x, pos.y + half_size.y, 0.f, 1.f); + tex_coord = vec2(1.f, 0.f); + EmitVertex(); + + // Top right vertex + gl_Position = vec4(pos + half_size, 0.f, 1.f); + tex_coord = vec2(0.f, 0.f); + EmitVertex(); + + // And finalize the primitive + EndPrimitive(); + } +} diff --git a/Space-Invaders/sfml/examples/shader/resources/billboard.vert b/Space-Invaders/sfml/examples/shader/resources/billboard.vert new file mode 100644 index 000000000..3a899052c --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/resources/billboard.vert @@ -0,0 +1,5 @@ +void main() +{ + // Transform the vertex position + gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; +} diff --git a/Space-Invaders/sfml/examples/shader/resources/blink.frag b/Space-Invaders/sfml/examples/shader/resources/blink.frag new file mode 100644 index 000000000..50a04a510 --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/resources/blink.frag @@ -0,0 +1,9 @@ +uniform sampler2D texture; +uniform float blink_alpha; + +void main() +{ + vec4 pixel = gl_Color; + pixel.a = blink_alpha; + gl_FragColor = pixel; +} diff --git a/Space-Invaders/sfml/examples/shader/resources/blur.frag b/Space-Invaders/sfml/examples/shader/resources/blur.frag new file mode 100644 index 000000000..b8aba3803 --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/resources/blur.frag @@ -0,0 +1,20 @@ +uniform sampler2D texture; +uniform float blur_radius; + +void main() +{ + vec2 offx = vec2(blur_radius, 0.0); + vec2 offy = vec2(0.0, blur_radius); + + vec4 pixel = texture2D(texture, gl_TexCoord[0].xy) * 4.0 + + texture2D(texture, gl_TexCoord[0].xy - offx) * 2.0 + + texture2D(texture, gl_TexCoord[0].xy + offx) * 2.0 + + texture2D(texture, gl_TexCoord[0].xy - offy) * 2.0 + + texture2D(texture, gl_TexCoord[0].xy + offy) * 2.0 + + texture2D(texture, gl_TexCoord[0].xy - offx - offy) * 1.0 + + texture2D(texture, gl_TexCoord[0].xy - offx + offy) * 1.0 + + texture2D(texture, gl_TexCoord[0].xy + offx - offy) * 1.0 + + texture2D(texture, gl_TexCoord[0].xy + offx + offy) * 1.0; + + gl_FragColor = gl_Color * (pixel / 16.0); +} diff --git a/Space-Invaders/sfml/examples/shader/resources/devices.png b/Space-Invaders/sfml/examples/shader/resources/devices.png new file mode 100644 index 000000000..866294a26 Binary files /dev/null and b/Space-Invaders/sfml/examples/shader/resources/devices.png differ diff --git a/Space-Invaders/sfml/examples/shader/resources/edge.frag b/Space-Invaders/sfml/examples/shader/resources/edge.frag new file mode 100644 index 000000000..7f869f534 --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/resources/edge.frag @@ -0,0 +1,32 @@ +uniform sampler2D texture; +uniform float edge_threshold; + +void main() +{ + const float offset = 1.0 / 512.0; + vec2 offx = vec2(offset, 0.0); + vec2 offy = vec2(0.0, offset); + + vec4 hEdge = texture2D(texture, gl_TexCoord[0].xy - offy) * -2.0 + + texture2D(texture, gl_TexCoord[0].xy + offy) * 2.0 + + texture2D(texture, gl_TexCoord[0].xy - offx - offy) * -1.0 + + texture2D(texture, gl_TexCoord[0].xy - offx + offy) * 1.0 + + texture2D(texture, gl_TexCoord[0].xy + offx - offy) * -1.0 + + texture2D(texture, gl_TexCoord[0].xy + offx + offy) * 1.0; + + vec4 vEdge = texture2D(texture, gl_TexCoord[0].xy - offx) * 2.0 + + texture2D(texture, gl_TexCoord[0].xy + offx) * -2.0 + + texture2D(texture, gl_TexCoord[0].xy - offx - offy) * 1.0 + + texture2D(texture, gl_TexCoord[0].xy - offx + offy) * -1.0 + + texture2D(texture, gl_TexCoord[0].xy + offx - offy) * 1.0 + + texture2D(texture, gl_TexCoord[0].xy + offx + offy) * -1.0; + + vec3 result = sqrt(hEdge.rgb * hEdge.rgb + vEdge.rgb * vEdge.rgb); + float edge = length(result); + vec4 pixel = gl_Color * texture2D(texture, gl_TexCoord[0].xy); + if (edge > (edge_threshold * 8.0)) + pixel.rgb = vec3(0.0, 0.0, 0.0); + else + pixel.a = edge_threshold; + gl_FragColor = pixel; +} diff --git a/Space-Invaders/sfml/examples/shader/resources/logo.png b/Space-Invaders/sfml/examples/shader/resources/logo.png new file mode 100644 index 000000000..29ba0102e Binary files /dev/null and b/Space-Invaders/sfml/examples/shader/resources/logo.png differ diff --git a/Space-Invaders/sfml/examples/shader/resources/pixelate.frag b/Space-Invaders/sfml/examples/shader/resources/pixelate.frag new file mode 100644 index 000000000..79f88683f --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/resources/pixelate.frag @@ -0,0 +1,9 @@ +uniform sampler2D texture; +uniform float pixel_threshold; + +void main() +{ + float factor = 1.0 / (pixel_threshold + 0.001); + vec2 pos = floor(gl_TexCoord[0].xy * factor + 0.5) / factor; + gl_FragColor = texture2D(texture, pos) * gl_Color; +} diff --git a/Space-Invaders/sfml/examples/shader/resources/sfml.png b/Space-Invaders/sfml/examples/shader/resources/sfml.png new file mode 100644 index 000000000..1da719ff0 Binary files /dev/null and b/Space-Invaders/sfml/examples/shader/resources/sfml.png differ diff --git a/Space-Invaders/sfml/examples/shader/resources/storm.vert b/Space-Invaders/sfml/examples/shader/resources/storm.vert new file mode 100644 index 000000000..fab9da41b --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/resources/storm.vert @@ -0,0 +1,19 @@ +uniform vec2 storm_position; +uniform float storm_total_radius; +uniform float storm_inner_radius; + +void main() +{ + vec4 vertex = gl_ModelViewMatrix * gl_Vertex; + vec2 offset = vertex.xy - storm_position; + float len = length(offset); + if (len < storm_total_radius) + { + float push_distance = storm_inner_radius + len / storm_total_radius * (storm_total_radius - storm_inner_radius); + vertex.xy = storm_position + normalize(offset) * push_distance; + } + + gl_Position = gl_ProjectionMatrix * vertex; + gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0; + gl_FrontColor = gl_Color; +} diff --git a/Space-Invaders/sfml/examples/shader/resources/text-background.png b/Space-Invaders/sfml/examples/shader/resources/text-background.png new file mode 100644 index 000000000..c86e9b6c0 Binary files /dev/null and b/Space-Invaders/sfml/examples/shader/resources/text-background.png differ diff --git a/Space-Invaders/sfml/examples/shader/resources/tuffy.ttf b/Space-Invaders/sfml/examples/shader/resources/tuffy.ttf new file mode 100644 index 000000000..8ea647090 Binary files /dev/null and b/Space-Invaders/sfml/examples/shader/resources/tuffy.ttf differ diff --git a/Space-Invaders/sfml/examples/shader/resources/wave.vert b/Space-Invaders/sfml/examples/shader/resources/wave.vert new file mode 100644 index 000000000..278a53b45 --- /dev/null +++ b/Space-Invaders/sfml/examples/shader/resources/wave.vert @@ -0,0 +1,15 @@ +uniform float wave_phase; +uniform vec2 wave_amplitude; + +void main() +{ + vec4 vertex = gl_Vertex; + vertex.x += cos(gl_Vertex.y * 0.02 + wave_phase * 3.8) * wave_amplitude.x + + sin(gl_Vertex.y * 0.02 + wave_phase * 6.3) * wave_amplitude.x * 0.3; + vertex.y += sin(gl_Vertex.x * 0.02 + wave_phase * 2.4) * wave_amplitude.y + + cos(gl_Vertex.x * 0.02 + wave_phase * 5.2) * wave_amplitude.y * 0.3; + + gl_Position = gl_ModelViewProjectionMatrix * vertex; + gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0; + gl_FrontColor = gl_Color; +} diff --git a/Space-Invaders/sfml/examples/sockets/Sockets.cpp b/Space-Invaders/sfml/examples/sockets/Sockets.cpp new file mode 100644 index 000000000..6bdd44bc1 --- /dev/null +++ b/Space-Invaders/sfml/examples/sockets/Sockets.cpp @@ -0,0 +1,59 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include + + +void runTcpServer(unsigned short port); +void runTcpClient(unsigned short port); +void runUdpServer(unsigned short port); +void runUdpClient(unsigned short port); + + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + // Choose an arbitrary port for opening sockets + const unsigned short port = 50001; + + // TCP, UDP or connected UDP ? + char protocol; + std::cout << "Do you want to use TCP (t) or UDP (u)? "; + std::cin >> protocol; + + // Client or server ? + char who; + std::cout << "Do you want to be a server (s) or a client (c)? "; + std::cin >> who; + + if (protocol == 't') + { + // Test the TCP protocol + if (who == 's') + runTcpServer(port); + else + runTcpClient(port); + } + else + { + // Test the unconnected UDP protocol + if (who == 's') + runUdpServer(port); + else + runUdpClient(port); + } + + // Wait until the user presses 'enter' key + std::cout << "Press enter to exit..." << std::endl; + std::cin.ignore(10000, '\n'); + std::cin.ignore(10000, '\n'); + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/examples/sockets/TCP.cpp b/Space-Invaders/sfml/examples/sockets/TCP.cpp new file mode 100644 index 000000000..64fb7f911 --- /dev/null +++ b/Space-Invaders/sfml/examples/sockets/TCP.cpp @@ -0,0 +1,81 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include + + +//////////////////////////////////////////////////////////// +/// Launch a server, wait for an incoming connection, +/// send a message and wait for the answer. +/// +//////////////////////////////////////////////////////////// +void runTcpServer(unsigned short port) +{ + // Create a server socket to accept new connections + sf::TcpListener listener; + + // Listen to the given port for incoming connections + if (listener.listen(port) != sf::Socket::Done) + return; + std::cout << "Server is listening to port " << port << ", waiting for connections... " << std::endl; + + // Wait for a connection + sf::TcpSocket socket; + if (listener.accept(socket) != sf::Socket::Done) + return; + std::cout << "Client connected: " << socket.getRemoteAddress() << std::endl; + + // Send a message to the connected client + const char out[] = "Hi, I'm the server"; + if (socket.send(out, sizeof(out)) != sf::Socket::Done) + return; + std::cout << "Message sent to the client: \"" << out << "\"" << std::endl; + + // Receive a message back from the client + char in[128]; + std::size_t received; + if (socket.receive(in, sizeof(in), received) != sf::Socket::Done) + return; + std::cout << "Answer received from the client: \"" << in << "\"" << std::endl; +} + + +//////////////////////////////////////////////////////////// +/// Create a client, connect it to a server, display the +/// welcome message and send an answer. +/// +//////////////////////////////////////////////////////////// +void runTcpClient(unsigned short port) +{ + // Ask for the server address + sf::IpAddress server; + do + { + std::cout << "Type the address or name of the server to connect to: "; + std::cin >> server; + } + while (server == sf::IpAddress::None); + + // Create a socket for communicating with the server + sf::TcpSocket socket; + + // Connect to the server + if (socket.connect(server, port) != sf::Socket::Done) + return; + std::cout << "Connected to server " << server << std::endl; + + // Receive a message from the server + char in[128]; + std::size_t received; + if (socket.receive(in, sizeof(in), received) != sf::Socket::Done) + return; + std::cout << "Message received from the server: \"" << in << "\"" << std::endl; + + // Send an answer to the server + const char out[] = "Hi, I'm a client"; + if (socket.send(out, sizeof(out)) != sf::Socket::Done) + return; + std::cout << "Message sent to the server: \"" << out << "\"" << std::endl; +} diff --git a/Space-Invaders/sfml/examples/sockets/UDP.cpp b/Space-Invaders/sfml/examples/sockets/UDP.cpp new file mode 100644 index 000000000..37a07c530 --- /dev/null +++ b/Space-Invaders/sfml/examples/sockets/UDP.cpp @@ -0,0 +1,72 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include + + +//////////////////////////////////////////////////////////// +/// Launch a server, wait for a message, send an answer. +/// +//////////////////////////////////////////////////////////// +void runUdpServer(unsigned short port) +{ + // Create a socket to receive a message from anyone + sf::UdpSocket socket; + + // Listen to messages on the specified port + if (socket.bind(port) != sf::Socket::Done) + return; + std::cout << "Server is listening to port " << port << ", waiting for a message... " << std::endl; + + // Wait for a message + char in[128]; + std::size_t received; + sf::IpAddress sender; + unsigned short senderPort; + if (socket.receive(in, sizeof(in), received, sender, senderPort) != sf::Socket::Done) + return; + std::cout << "Message received from client " << sender << ": \"" << in << "\"" << std::endl; + + // Send an answer to the client + const char out[] = "Hi, I'm the server"; + if (socket.send(out, sizeof(out), sender, senderPort) != sf::Socket::Done) + return; + std::cout << "Message sent to the client: \"" << out << "\"" << std::endl; +} + + +//////////////////////////////////////////////////////////// +/// Send a message to the server, wait for the answer +/// +//////////////////////////////////////////////////////////// +void runUdpClient(unsigned short port) +{ + // Ask for the server address + sf::IpAddress server; + do + { + std::cout << "Type the address or name of the server to connect to: "; + std::cin >> server; + } + while (server == sf::IpAddress::None); + + // Create a socket for communicating with the server + sf::UdpSocket socket; + + // Send a message to the server + const char out[] = "Hi, I'm a client"; + if (socket.send(out, sizeof(out), server, port) != sf::Socket::Done) + return; + std::cout << "Message sent to the server: \"" << out << "\"" << std::endl; + + // Receive an answer from anyone (but most likely from the server) + char in[128]; + std::size_t received; + sf::IpAddress sender; + unsigned short senderPort; + if (socket.receive(in, sizeof(in), received, sender, senderPort) != sf::Socket::Done) + return; + std::cout << "Message received from " << sender << ": \"" << in << "\"" << std::endl; +} diff --git a/Space-Invaders/sfml/examples/sound/Sound.cpp b/Space-Invaders/sfml/examples/sound/Sound.cpp new file mode 100644 index 000000000..4d26a6288 --- /dev/null +++ b/Space-Invaders/sfml/examples/sound/Sound.cpp @@ -0,0 +1,104 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include + + +//////////////////////////////////////////////////////////// +/// Play a sound +/// +//////////////////////////////////////////////////////////// +void playSound() +{ + // Load a sound buffer from a wav file + sf::SoundBuffer buffer; + if (!buffer.loadFromFile("resources/killdeer.wav")) + return; + + // Display sound informations + std::cout << "killdeer.wav:" << std::endl; + std::cout << " " << buffer.getDuration().asSeconds() << " seconds" << std::endl; + std::cout << " " << buffer.getSampleRate() << " samples / sec" << std::endl; + std::cout << " " << buffer.getChannelCount() << " channels" << std::endl; + + // Create a sound instance and play it + sf::Sound sound(buffer); + sound.play(); + + // Loop while the sound is playing + while (sound.getStatus() == sf::Sound::Playing) + { + // Leave some CPU time for other processes + sf::sleep(sf::milliseconds(100)); + + // Display the playing position + std::cout << "\rPlaying... " << sound.getPlayingOffset().asSeconds() << " sec "; + std::cout << std::flush; + } + std::cout << std::endl << std::endl; +} + + +//////////////////////////////////////////////////////////// +/// Play a music +/// +//////////////////////////////////////////////////////////// +void playMusic(const std::string& filename) +{ + // Load an ogg music file + sf::Music music; + if (!music.openFromFile("resources/" + filename)) + return; + + // Display music informations + std::cout << filename << ":" << std::endl; + std::cout << " " << music.getDuration().asSeconds() << " seconds" << std::endl; + std::cout << " " << music.getSampleRate() << " samples / sec" << std::endl; + std::cout << " " << music.getChannelCount() << " channels" << std::endl; + + // Play it + music.play(); + + // Loop while the music is playing + while (music.getStatus() == sf::Music::Playing) + { + // Leave some CPU time for other processes + sf::sleep(sf::milliseconds(100)); + + // Display the playing position + std::cout << "\rPlaying... " << music.getPlayingOffset().asSeconds() << " sec "; + std::cout << std::flush; + } + std::cout << std::endl << std::endl; +} + + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + // Play a sound + playSound(); + + // Play music from an ogg file + playMusic("doodle_pop.ogg"); + + // Play music from a flac file + playMusic("ding.flac"); + + // Play music from a mp3 file + playMusic("ding.mp3"); + + // Wait until the user presses 'enter' key + std::cout << "Press enter to exit..." << std::endl; + std::cin.ignore(10000, '\n'); + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/examples/sound/resources/ding.flac b/Space-Invaders/sfml/examples/sound/resources/ding.flac new file mode 100644 index 000000000..9c873290e Binary files /dev/null and b/Space-Invaders/sfml/examples/sound/resources/ding.flac differ diff --git a/Space-Invaders/sfml/examples/sound/resources/ding.mp3 b/Space-Invaders/sfml/examples/sound/resources/ding.mp3 new file mode 100644 index 000000000..ef47fd329 Binary files /dev/null and b/Space-Invaders/sfml/examples/sound/resources/ding.mp3 differ diff --git a/Space-Invaders/sfml/examples/sound/resources/doodle_pop.ogg b/Space-Invaders/sfml/examples/sound/resources/doodle_pop.ogg new file mode 100644 index 000000000..555ea3480 Binary files /dev/null and b/Space-Invaders/sfml/examples/sound/resources/doodle_pop.ogg differ diff --git a/Space-Invaders/sfml/examples/sound/resources/killdeer.wav b/Space-Invaders/sfml/examples/sound/resources/killdeer.wav new file mode 100644 index 000000000..46080e9fd Binary files /dev/null and b/Space-Invaders/sfml/examples/sound/resources/killdeer.wav differ diff --git a/Space-Invaders/sfml/examples/sound_capture/SoundCapture.cpp b/Space-Invaders/sfml/examples/sound_capture/SoundCapture.cpp new file mode 100644 index 000000000..19f114b46 --- /dev/null +++ b/Space-Invaders/sfml/examples/sound_capture/SoundCapture.cpp @@ -0,0 +1,94 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include + + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + // Check that the device can capture audio + if (sf::SoundRecorder::isAvailable() == false) + { + std::cout << "Sorry, audio capture is not supported by your system" << std::endl; + return EXIT_SUCCESS; + } + + // Choose the sample rate + unsigned int sampleRate; + std::cout << "Please choose the sample rate for sound capture (44100 is CD quality): "; + std::cin >> sampleRate; + std::cin.ignore(10000, '\n'); + + // Wait for user input... + std::cout << "Press enter to start recording audio"; + std::cin.ignore(10000, '\n'); + + // Here we'll use an integrated custom recorder, which saves the captured data into a SoundBuffer + sf::SoundBufferRecorder recorder; + + // Audio capture is done in a separate thread, so we can block the main thread while it is capturing + recorder.start(sampleRate); + std::cout << "Recording... press enter to stop"; + std::cin.ignore(10000, '\n'); + recorder.stop(); + + // Get the buffer containing the captured data + const sf::SoundBuffer& buffer = recorder.getBuffer(); + + // Display captured sound informations + std::cout << "Sound information:" << std::endl; + std::cout << " " << buffer.getDuration().asSeconds() << " seconds" << std::endl; + std::cout << " " << buffer.getSampleRate() << " samples / seconds" << std::endl; + std::cout << " " << buffer.getChannelCount() << " channels" << std::endl; + + // Choose what to do with the recorded sound data + char choice; + std::cout << "What do you want to do with captured sound (p = play, s = save) ? "; + std::cin >> choice; + std::cin.ignore(10000, '\n'); + + if (choice == 's') + { + // Choose the filename + std::string filename; + std::cout << "Choose the file to create: "; + std::getline(std::cin, filename); + + // Save the buffer + buffer.saveToFile(filename); + } + else + { + // Create a sound instance and play it + sf::Sound sound(buffer); + sound.play(); + + // Wait until finished + while (sound.getStatus() == sf::Sound::Playing) + { + // Display the playing position + std::cout << "\rPlaying... " << sound.getPlayingOffset().asSeconds() << " sec "; + std::cout << std::flush; + + // Leave some CPU time for other threads + sf::sleep(sf::milliseconds(100)); + } + } + + // Finished! + std::cout << std::endl << "Done!" << std::endl; + + // Wait until the user presses 'enter' key + std::cout << "Press enter to exit..." << std::endl; + std::cin.ignore(10000, '\n'); + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/examples/tennis/Tennis.cpp b/Space-Invaders/sfml/examples/tennis/Tennis.cpp new file mode 100644 index 000000000..bc80bf5ed --- /dev/null +++ b/Space-Invaders/sfml/examples/tennis/Tennis.cpp @@ -0,0 +1,291 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include +#include + +#ifdef SFML_SYSTEM_IOS +#include +#endif + +std::string resourcesDir() +{ +#ifdef SFML_SYSTEM_IOS + return ""; +#else + return "resources/"; +#endif +} + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + std::srand(static_cast(std::time(NULL))); + + // Define some constants + const float pi = 3.14159f; + const float gameWidth = 800; + const float gameHeight = 600; + sf::Vector2f paddleSize(25, 100); + float ballRadius = 10.f; + + // Create the window of the application + sf::RenderWindow window(sf::VideoMode(static_cast(gameWidth), static_cast(gameHeight), 32), "SFML Tennis", + sf::Style::Titlebar | sf::Style::Close); + window.setVerticalSyncEnabled(true); + + // Load the sounds used in the game + sf::SoundBuffer ballSoundBuffer; + if (!ballSoundBuffer.loadFromFile(resourcesDir() + "ball.wav")) + return EXIT_FAILURE; + sf::Sound ballSound(ballSoundBuffer); + + // Create the SFML logo texture: + sf::Texture sfmlLogoTexture; + if(!sfmlLogoTexture.loadFromFile(resourcesDir() + "sfml_logo.png")) + return EXIT_FAILURE; + sf::Sprite sfmlLogo; + sfmlLogo.setTexture(sfmlLogoTexture); + sfmlLogo.setPosition(170, 50); + + // Create the left paddle + sf::RectangleShape leftPaddle; + leftPaddle.setSize(paddleSize - sf::Vector2f(3, 3)); + leftPaddle.setOutlineThickness(3); + leftPaddle.setOutlineColor(sf::Color::Black); + leftPaddle.setFillColor(sf::Color(100, 100, 200)); + leftPaddle.setOrigin(paddleSize / 2.f); + + // Create the right paddle + sf::RectangleShape rightPaddle; + rightPaddle.setSize(paddleSize - sf::Vector2f(3, 3)); + rightPaddle.setOutlineThickness(3); + rightPaddle.setOutlineColor(sf::Color::Black); + rightPaddle.setFillColor(sf::Color(200, 100, 100)); + rightPaddle.setOrigin(paddleSize / 2.f); + + // Create the ball + sf::CircleShape ball; + ball.setRadius(ballRadius - 3); + ball.setOutlineThickness(2); + ball.setOutlineColor(sf::Color::Black); + ball.setFillColor(sf::Color::White); + ball.setOrigin(ballRadius / 2, ballRadius / 2); + + // Load the text font + sf::Font font; + if (!font.loadFromFile(resourcesDir() + "tuffy.ttf")) + return EXIT_FAILURE; + + // Initialize the pause message + sf::Text pauseMessage; + pauseMessage.setFont(font); + pauseMessage.setCharacterSize(40); + pauseMessage.setPosition(170.f, 200.f); + pauseMessage.setFillColor(sf::Color::White); + + #ifdef SFML_SYSTEM_IOS + pauseMessage.setString("Welcome to SFML Tennis!\nTouch the screen to start the game."); + #else + pauseMessage.setString("Welcome to SFML Tennis!\n\nPress space to start the game."); + #endif + + // Define the paddles properties + sf::Clock AITimer; + const sf::Time AITime = sf::seconds(0.1f); + const float paddleSpeed = 400.f; + float rightPaddleSpeed = 0.f; + const float ballSpeed = 400.f; + float ballAngle = 0.f; // to be changed later + + sf::Clock clock; + bool isPlaying = false; + while (window.isOpen()) + { + // Handle events + sf::Event event; + while (window.pollEvent(event)) + { + // Window closed or escape key pressed: exit + if ((event.type == sf::Event::Closed) || + ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))) + { + window.close(); + break; + } + + // Space key pressed: play + if (((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Space)) || + (event.type == sf::Event::TouchBegan)) + { + if (!isPlaying) + { + // (re)start the game + isPlaying = true; + clock.restart(); + + // Reset the position of the paddles and ball + leftPaddle.setPosition(10.f + paddleSize.x / 2.f, gameHeight / 2.f); + rightPaddle.setPosition(gameWidth - 10.f - paddleSize.x / 2.f, gameHeight / 2.f); + ball.setPosition(gameWidth / 2.f, gameHeight / 2.f); + + // Reset the ball angle + do + { + // Make sure the ball initial angle is not too much vertical + ballAngle = static_cast(std::rand() % 360) * 2.f * pi / 360.f; + } + while (std::abs(std::cos(ballAngle)) < 0.7f); + } + } + + // Window size changed, adjust view appropriately + if (event.type == sf::Event::Resized) + { + sf::View view; + view.setSize(gameWidth, gameHeight); + view.setCenter(gameWidth / 2.f, gameHeight /2.f); + window.setView(view); + } + } + + if (isPlaying) + { + float deltaTime = clock.restart().asSeconds(); + + // Move the player's paddle + if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up) && + (leftPaddle.getPosition().y - paddleSize.y / 2 > 5.f)) + { + leftPaddle.move(0.f, -paddleSpeed * deltaTime); + } + if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down) && + (leftPaddle.getPosition().y + paddleSize.y / 2 < gameHeight - 5.f)) + { + leftPaddle.move(0.f, paddleSpeed * deltaTime); + } + + if (sf::Touch::isDown(0)) + { + sf::Vector2i pos = sf::Touch::getPosition(0); + sf::Vector2f mappedPos = window.mapPixelToCoords(pos); + leftPaddle.setPosition(leftPaddle.getPosition().x, mappedPos.y); + } + + // Move the computer's paddle + if (((rightPaddleSpeed < 0.f) && (rightPaddle.getPosition().y - paddleSize.y / 2 > 5.f)) || + ((rightPaddleSpeed > 0.f) && (rightPaddle.getPosition().y + paddleSize.y / 2 < gameHeight - 5.f))) + { + rightPaddle.move(0.f, rightPaddleSpeed * deltaTime); + } + + // Update the computer's paddle direction according to the ball position + if (AITimer.getElapsedTime() > AITime) + { + AITimer.restart(); + if (ball.getPosition().y + ballRadius > rightPaddle.getPosition().y + paddleSize.y / 2) + rightPaddleSpeed = paddleSpeed; + else if (ball.getPosition().y - ballRadius < rightPaddle.getPosition().y - paddleSize.y / 2) + rightPaddleSpeed = -paddleSpeed; + else + rightPaddleSpeed = 0.f; + } + + // Move the ball + float factor = ballSpeed * deltaTime; + ball.move(std::cos(ballAngle) * factor, std::sin(ballAngle) * factor); + + #ifdef SFML_SYSTEM_IOS + const std::string inputString = "Touch the screen to restart."; + #else + const std::string inputString = "Press space to restart or\nescape to exit."; + #endif + + // Check collisions between the ball and the screen + if (ball.getPosition().x - ballRadius < 0.f) + { + isPlaying = false; + pauseMessage.setString("You Lost!\n\n" + inputString); + } + if (ball.getPosition().x + ballRadius > gameWidth) + { + isPlaying = false; + pauseMessage.setString("You Won!\n\n" + inputString); + } + if (ball.getPosition().y - ballRadius < 0.f) + { + ballSound.play(); + ballAngle = -ballAngle; + ball.setPosition(ball.getPosition().x, ballRadius + 0.1f); + } + if (ball.getPosition().y + ballRadius > gameHeight) + { + ballSound.play(); + ballAngle = -ballAngle; + ball.setPosition(ball.getPosition().x, gameHeight - ballRadius - 0.1f); + } + + // Check the collisions between the ball and the paddles + // Left Paddle + if (ball.getPosition().x - ballRadius < leftPaddle.getPosition().x + paddleSize.x / 2 && + ball.getPosition().x - ballRadius > leftPaddle.getPosition().x && + ball.getPosition().y + ballRadius >= leftPaddle.getPosition().y - paddleSize.y / 2 && + ball.getPosition().y - ballRadius <= leftPaddle.getPosition().y + paddleSize.y / 2) + { + if (ball.getPosition().y > leftPaddle.getPosition().y) + ballAngle = pi - ballAngle + static_cast(std::rand() % 20) * pi / 180; + else + ballAngle = pi - ballAngle - static_cast(std::rand() % 20) * pi / 180; + + ballSound.play(); + ball.setPosition(leftPaddle.getPosition().x + ballRadius + paddleSize.x / 2 + 0.1f, ball.getPosition().y); + } + + // Right Paddle + if (ball.getPosition().x + ballRadius > rightPaddle.getPosition().x - paddleSize.x / 2 && + ball.getPosition().x + ballRadius < rightPaddle.getPosition().x && + ball.getPosition().y + ballRadius >= rightPaddle.getPosition().y - paddleSize.y / 2 && + ball.getPosition().y - ballRadius <= rightPaddle.getPosition().y + paddleSize.y / 2) + { + if (ball.getPosition().y > rightPaddle.getPosition().y) + ballAngle = pi - ballAngle + static_cast(std::rand() % 20) * pi / 180; + else + ballAngle = pi - ballAngle - static_cast(std::rand() % 20) * pi / 180; + + ballSound.play(); + ball.setPosition(rightPaddle.getPosition().x - ballRadius - paddleSize.x / 2 - 0.1f, ball.getPosition().y); + } + } + + // Clear the window + window.clear(sf::Color(50, 50, 50)); + + if (isPlaying) + { + // Draw the paddles and the ball + window.draw(leftPaddle); + window.draw(rightPaddle); + window.draw(ball); + } + else + { + // Draw the pause message + window.draw(pauseMessage); + window.draw(sfmlLogo); + } + + // Display things on screen + window.display(); + } + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/examples/tennis/resources/ball.wav b/Space-Invaders/sfml/examples/tennis/resources/ball.wav new file mode 100644 index 000000000..c969f4702 Binary files /dev/null and b/Space-Invaders/sfml/examples/tennis/resources/ball.wav differ diff --git a/Space-Invaders/sfml/examples/tennis/resources/sfml_logo.png b/Space-Invaders/sfml/examples/tennis/resources/sfml_logo.png new file mode 100644 index 000000000..509acc074 Binary files /dev/null and b/Space-Invaders/sfml/examples/tennis/resources/sfml_logo.png differ diff --git a/Space-Invaders/sfml/examples/tennis/resources/tuffy.ttf b/Space-Invaders/sfml/examples/tennis/resources/tuffy.ttf new file mode 100644 index 000000000..8ea647090 Binary files /dev/null and b/Space-Invaders/sfml/examples/tennis/resources/tuffy.ttf differ diff --git a/Space-Invaders/sfml/examples/voip/Client.cpp b/Space-Invaders/sfml/examples/voip/Client.cpp new file mode 100644 index 000000000..300370989 --- /dev/null +++ b/Space-Invaders/sfml/examples/voip/Client.cpp @@ -0,0 +1,141 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include + + +const sf::Uint8 clientAudioData = 1; +const sf::Uint8 clientEndOfStream = 2; + + +//////////////////////////////////////////////////////////// +/// Specialization of audio recorder for sending recorded audio +/// data through the network +//////////////////////////////////////////////////////////// +class NetworkRecorder : public sf::SoundRecorder +{ +public: + + //////////////////////////////////////////////////////////// + /// Constructor + /// + /// \param host Remote host to which send the recording data + /// \param port Port of the remote host + /// + //////////////////////////////////////////////////////////// + NetworkRecorder(const sf::IpAddress& host, unsigned short port) : + m_host(host), + m_port(port) + { + } + + //////////////////////////////////////////////////////////// + /// Destructor + /// + /// \see SoundRecorder::~SoundRecorder() + /// + //////////////////////////////////////////////////////////// + ~NetworkRecorder() + { + // Make sure to stop the recording thread + stop(); + } + +private: + + //////////////////////////////////////////////////////////// + /// \see SoundRecorder::onStart + /// + //////////////////////////////////////////////////////////// + virtual bool onStart() + { + if (m_socket.connect(m_host, m_port) == sf::Socket::Done) + { + std::cout << "Connected to server " << m_host << std::endl; + return true; + } + else + { + return false; + } + } + + //////////////////////////////////////////////////////////// + /// \see SoundRecorder::onProcessSamples + /// + //////////////////////////////////////////////////////////// + virtual bool onProcessSamples(const sf::Int16* samples, std::size_t sampleCount) + { + // Pack the audio samples into a network packet + sf::Packet packet; + packet << clientAudioData; + packet.append(samples, sampleCount * sizeof(sf::Int16)); + + // Send the audio packet to the server + return m_socket.send(packet) == sf::Socket::Done; + } + + //////////////////////////////////////////////////////////// + /// \see SoundRecorder::onStop + /// + //////////////////////////////////////////////////////////// + virtual void onStop() + { + // Send a "end-of-stream" packet + sf::Packet packet; + packet << clientEndOfStream; + m_socket.send(packet); + + // Close the socket + m_socket.disconnect(); + } + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + sf::IpAddress m_host; ///< Address of the remote host + unsigned short m_port; ///< Remote port + sf::TcpSocket m_socket; ///< Socket used to communicate with the server +}; + + +//////////////////////////////////////////////////////////// +/// Create a client, connect it to a running server and +/// start sending him audio data +/// +//////////////////////////////////////////////////////////// +void doClient(unsigned short port) +{ + // Check that the device can capture audio + if (!sf::SoundRecorder::isAvailable()) + { + std::cout << "Sorry, audio capture is not supported by your system" << std::endl; + return; + } + + // Ask for server address + sf::IpAddress server; + do + { + std::cout << "Type address or name of the server to connect to: "; + std::cin >> server; + } + while (server == sf::IpAddress::None); + + // Create an instance of our custom recorder + NetworkRecorder recorder(server, port); + + // Wait for user input... + std::cin.ignore(10000, '\n'); + std::cout << "Press enter to start recording audio"; + std::cin.ignore(10000, '\n'); + + // Start capturing audio data + recorder.start(44100); + std::cout << "Recording... press enter to stop"; + std::cin.ignore(10000, '\n'); + recorder.stop(); +} diff --git a/Space-Invaders/sfml/examples/voip/Server.cpp b/Space-Invaders/sfml/examples/voip/Server.cpp new file mode 100644 index 000000000..577c8aa71 --- /dev/null +++ b/Space-Invaders/sfml/examples/voip/Server.cpp @@ -0,0 +1,202 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include +#include +#include + + +const sf::Uint8 serverAudioData = 1; +const sf::Uint8 serverEndOfStream = 2; + + +//////////////////////////////////////////////////////////// +/// Customized sound stream for acquiring audio data +/// from the network +//////////////////////////////////////////////////////////// +class NetworkAudioStream : public sf::SoundStream +{ +public: + + //////////////////////////////////////////////////////////// + /// Default constructor + /// + //////////////////////////////////////////////////////////// + NetworkAudioStream() : + m_offset (0), + m_hasFinished(false) + { + // Set the sound parameters + initialize(1, 44100); + } + + //////////////////////////////////////////////////////////// + /// Run the server, stream audio data from the client + /// + //////////////////////////////////////////////////////////// + void start(unsigned short port) + { + if (!m_hasFinished) + { + // Listen to the given port for incoming connections + if (m_listener.listen(port) != sf::Socket::Done) + return; + std::cout << "Server is listening to port " << port << ", waiting for connections... " << std::endl; + + // Wait for a connection + if (m_listener.accept(m_client) != sf::Socket::Done) + return; + std::cout << "Client connected: " << m_client.getRemoteAddress() << std::endl; + + // Start playback + play(); + + // Start receiving audio data + receiveLoop(); + } + else + { + // Start playback + play(); + } + } + +private: + + //////////////////////////////////////////////////////////// + /// /see SoundStream::OnGetData + /// + //////////////////////////////////////////////////////////// + virtual bool onGetData(sf::SoundStream::Chunk& data) + { + // We have reached the end of the buffer and all audio data have been played: we can stop playback + if ((m_offset >= m_samples.size()) && m_hasFinished) + return false; + + // No new data has arrived since last update: wait until we get some + while ((m_offset >= m_samples.size()) && !m_hasFinished) + sf::sleep(sf::milliseconds(10)); + + // Copy samples into a local buffer to avoid synchronization problems + // (don't forget that we run in two separate threads) + { + sf::Lock lock(m_mutex); + m_tempBuffer.assign(m_samples.begin() + static_cast::difference_type>(m_offset), m_samples.end()); + } + + // Fill audio data to pass to the stream + data.samples = &m_tempBuffer[0]; + data.sampleCount = m_tempBuffer.size(); + + // Update the playing offset + m_offset += m_tempBuffer.size(); + + return true; + } + + //////////////////////////////////////////////////////////// + /// /see SoundStream::OnSeek + /// + //////////////////////////////////////////////////////////// + virtual void onSeek(sf::Time timeOffset) + { + m_offset = static_cast(timeOffset.asMilliseconds()) * getSampleRate() * getChannelCount() / 1000; + } + + //////////////////////////////////////////////////////////// + /// Get audio data from the client until playback is stopped + /// + //////////////////////////////////////////////////////////// + void receiveLoop() + { + while (!m_hasFinished) + { + // Get waiting audio data from the network + sf::Packet packet; + if (m_client.receive(packet) != sf::Socket::Done) + break; + + // Extract the message ID + sf::Uint8 id; + packet >> id; + + if (id == serverAudioData) + { + // Extract audio samples from the packet, and append it to our samples buffer + std::size_t sampleCount = (packet.getDataSize() - 1) / sizeof(sf::Int16); + + // Don't forget that the other thread can access the sample array at any time + // (so we protect any operation on it with the mutex) + { + sf::Lock lock(m_mutex); + std::size_t oldSize = m_samples.size(); + m_samples.resize(oldSize + sampleCount); + std::memcpy(&(m_samples[oldSize]), static_cast(packet.getData()) + 1, sampleCount * sizeof(sf::Int16)); + } + } + else if (id == serverEndOfStream) + { + // End of stream reached: we stop receiving audio data + std::cout << "Audio data has been 100% received!" << std::endl; + m_hasFinished = true; + } + else + { + // Something's wrong... + std::cout << "Invalid packet received..." << std::endl; + m_hasFinished = true; + } + } + } + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + sf::TcpListener m_listener; + sf::TcpSocket m_client; + sf::Mutex m_mutex; + std::vector m_samples; + std::vector m_tempBuffer; + std::size_t m_offset; + bool m_hasFinished; +}; + + +//////////////////////////////////////////////////////////// +/// Launch a server and wait for incoming audio data from +/// a connected client +/// +//////////////////////////////////////////////////////////// +void doServer(unsigned short port) +{ + // Build an audio stream to play sound data as it is received through the network + NetworkAudioStream audioStream; + audioStream.start(port); + + // Loop until the sound playback is finished + while (audioStream.getStatus() != sf::SoundStream::Stopped) + { + // Leave some CPU time for other threads + sf::sleep(sf::milliseconds(100)); + } + + std::cin.ignore(10000, '\n'); + + // Wait until the user presses 'enter' key + std::cout << "Press enter to replay the sound..." << std::endl; + std::cin.ignore(10000, '\n'); + + // Replay the sound (just to make sure replaying the received data is OK) + audioStream.play(); + + // Loop until the sound playback is finished + while (audioStream.getStatus() != sf::SoundStream::Stopped) + { + // Leave some CPU time for other threads + sf::sleep(sf::milliseconds(100)); + } +} diff --git a/Space-Invaders/sfml/examples/voip/VoIP.cpp b/Space-Invaders/sfml/examples/voip/VoIP.cpp new file mode 100644 index 000000000..06c37b743 --- /dev/null +++ b/Space-Invaders/sfml/examples/voip/VoIP.cpp @@ -0,0 +1,50 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include + + +//////////////////////////////////////////////////////////// +// Function prototypes +// (I'm too lazy to put them into separate headers...) +//////////////////////////////////////////////////////////// +void doClient(unsigned short port); +void doServer(unsigned short port); + + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + // Choose a random port for opening sockets (ports < 1024 are reserved) + const unsigned short port = 2435; + + // Client or server ? + char who; + std::cout << "Do you want to be a server ('s') or a client ('c')? "; + std::cin >> who; + + if (who == 's') + { + // Run as a server + doServer(port); + } + else + { + // Run as a client + doClient(port); + } + + // Wait until the user presses 'enter' key + std::cout << "Press enter to exit..." << std::endl; + std::cin.ignore(10000, '\n'); + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/examples/vulkan/Vulkan.cpp b/Space-Invaders/sfml/examples/vulkan/Vulkan.cpp new file mode 100644 index 000000000..ade2d14fa --- /dev/null +++ b/Space-Invaders/sfml/examples/vulkan/Vulkan.cpp @@ -0,0 +1,2559 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#define GLAD_VULKAN_IMPLEMENTATION +#include + +// Include graphics because we use sf::Image for loading images +#include + +#include +#include +#include +#include +#include + + +//////////////////////////////////////////////////////////// +// Helper functions +//////////////////////////////////////////////////////////// +namespace +{ + typedef float Vec3[3]; + typedef float Matrix[4][4]; + + // Multiply 2 matrices + void matrixMultiply(Matrix& result, const Matrix& left, const Matrix& right) + { + Matrix temp; + + for (int i = 0; i < 4; i++) + { + for (int j = 0; j < 4; j++) + temp[i][j] = left[0][j] * right[i][0] + left[1][j] * right[i][1] + left[2][j] * right[i][2] + left[3][j] * right[i][3]; + } + + std::memcpy(result, temp, sizeof(Matrix)); + } + + // Rotate a matrix around the x-axis + void matrixRotateX(Matrix& result, float angle) + { + Matrix matrix = { + {1.f, 0.f, 0.f, 0.f}, + {0.f, std::cos(angle), std::sin(angle), 0.f}, + {0.f, -std::sin(angle), std::cos(angle), 0.f}, + {0.f, 0.f, 0.f, 1.f} + }; + + matrixMultiply(result, result, matrix); + } + + // Rotate a matrix around the y-axis + void matrixRotateY(Matrix& result, float angle) + { + Matrix matrix = { + { std::cos(angle), 0.f, std::sin(angle), 0.f}, + { 0.f, 1.f, 0.f, 0.f}, + {-std::sin(angle), 0.f, std::cos(angle), 0.f}, + { 0.f, 0.f, 0.f, 1.f} + }; + + matrixMultiply(result, result, matrix); + } + + // Rotate a matrix around the z-axis + void matrixRotateZ(Matrix& result, float angle) + { + Matrix matrix = { + { std::cos(angle), std::sin(angle), 0.f, 0.f}, + {-std::sin(angle), std::cos(angle), 0.f, 0.f}, + { 0.f, 0.f, 1.f, 0.f}, + { 0.f, 0.f, 0.f, 1.f} + }; + + matrixMultiply(result, result, matrix); + } + + // Construct a lookat view matrix + void matrixLookAt(Matrix& result, const Vec3& eye, const Vec3& center, const Vec3& up) + { + // Forward-looking vector + Vec3 forward = { + center[0] - eye[0], + center[1] - eye[1], + center[2] - eye[2] + }; + + // Normalize + float factor = 1.0f / std::sqrt(forward[0] * forward[0] + forward[1] * forward[1] + forward[2] * forward[2]); + + for(int i = 0; i < 3; i++) + forward[i] = forward[i] * factor; + + // Side vector (Forward cross product Up) + Vec3 side = { + forward[1] * up[2] - forward[2] * up[1], + forward[2] * up[0] - forward[0] * up[2], + forward[0] * up[1] - forward[1] * up[0] + }; + + // Normalize + factor = 1.0f / std::sqrt(side[0] * side[0] + side[1] * side[1] + side[2] * side[2]); + + for(int i = 0; i < 3; i++) + side[i] = side[i] * factor; + + result[0][0] = side[0]; + result[0][1] = side[1] * forward[2] - side[2] * forward[1]; + result[0][2] = -forward[0]; + result[0][3] = 0.f; + + result[1][0] = side[1]; + result[1][1] = side[2] * forward[0] - side[0] * forward[2]; + result[1][2] = -forward[1]; + result[1][3] = 0.f; + + result[2][0] = side[2]; + result[2][1] = side[0] * forward[1] - side[1] * forward[0]; + result[2][2] = -forward[2]; + result[2][3] = 0.f; + + result[3][0] = (-eye[0]) * result[0][0] + (-eye[1]) * result[1][0] + (-eye[2]) * result[2][0]; + result[3][1] = (-eye[0]) * result[0][1] + (-eye[1]) * result[1][1] + (-eye[2]) * result[2][1]; + result[3][2] = (-eye[0]) * result[0][2] + (-eye[1]) * result[1][2] + (-eye[2]) * result[2][2]; + result[3][3] = (-eye[0]) * result[0][3] + (-eye[1]) * result[1][3] + (-eye[2]) * result[2][3] + 1.0f; + } + + // Construct a perspective projection matrix + void matrixPerspective(Matrix& result, float fov, float aspect, float nearPlane, float farPlane) + { + const float a = 1.f / std::tan(fov / 2.f); + + result[0][0] = a / aspect; + result[0][1] = 0.f; + result[0][2] = 0.f; + result[0][3] = 0.f; + + result[1][0] = 0.f; + result[1][1] = -a; + result[1][2] = 0.f; + result[1][3] = 0.f; + + result[2][0] = 0.f; + result[2][1] = 0.f; + result[2][2] = -((farPlane + nearPlane) / (farPlane - nearPlane)); + result[2][3] = -1.f; + + result[3][0] = 0.f; + result[3][1] = 0.f; + result[3][2] = -((2.f * farPlane * nearPlane) / (farPlane - nearPlane)); + result[3][3] = 0.f; + } + + // Clamp a value between low and high values + template + T clamp(T value, T low, T high) + { + return (value <= low) ? low : ((value >= high) ? high : value); + } + + // Helper function we pass to GLAD to load Vulkan functions via SFML + GLADapiproc getVulkanFunction(const char* name) + { + return sf::Vulkan::getFunction(name); + } + + // Debug we pass to Vulkan to call when it detects warnings or errors + VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugReportFlagsEXT, VkDebugReportObjectTypeEXT, uint64_t, size_t, int32_t, const char*, const char* pMessage, void*) + { + sf::err() << pMessage << std::endl; + + return VK_FALSE; + } +} + + +//////////////////////////////////////////////////////////// +// VulkanExample class +//////////////////////////////////////////////////////////// +class VulkanExample +{ +public: + // Constructor + VulkanExample() : + window(sf::VideoMode(800, 600), "SFML window with Vulkan", sf::Style::Default), + vulkanAvailable(sf::Vulkan::isAvailable()), + maxFramesInFlight(2), + currentFrame(0), + swapchainOutOfDate(false), + instance(0), + debugReportCallback(0), + surface(0), + gpu(0), + queueFamilyIndex(-1), + device(0), + queue(0), + swapchainFormat(), + swapchainExtent(), + swapchain(0), + depthFormat(VK_FORMAT_UNDEFINED), + depthImage(0), + depthImageMemory(0), + depthImageView(0), + vertexShaderModule(0), + fragmentShaderModule(0), + descriptorSetLayout(0), + pipelineLayout(0), + renderPass(0), + graphicsPipeline(0), + commandPool(0), + vertexBuffer(0), + vertexBufferMemory(0), + indexBuffer(0), + indexBufferMemory(0), + textureImage(0), + textureImageMemory(0), + textureImageView(0), + textureSampler(0), + descriptorPool(0) + { + // Vulkan setup procedure + if (vulkanAvailable) setupInstance(); + if (vulkanAvailable) setupDebugReportCallback(); + if (vulkanAvailable) setupSurface(); + if (vulkanAvailable) setupPhysicalDevice(); + if (vulkanAvailable) setupLogicalDevice(); + if (vulkanAvailable) setupSwapchain(); + if (vulkanAvailable) setupSwapchainImages(); + if (vulkanAvailable) setupShaders(); + if (vulkanAvailable) setupRenderpass(); + if (vulkanAvailable) setupDescriptorSetLayout(); + if (vulkanAvailable) setupPipelineLayout(); + if (vulkanAvailable) setupPipeline(); + if (vulkanAvailable) setupCommandPool(); + if (vulkanAvailable) setupVertexBuffer(); + if (vulkanAvailable) setupIndexBuffer(); + if (vulkanAvailable) setupUniformBuffers(); + if (vulkanAvailable) setupDepthImage(); + if (vulkanAvailable) setupDepthImageView(); + if (vulkanAvailable) setupTextureImage(); + if (vulkanAvailable) setupTextureImageView(); + if (vulkanAvailable) setupTextureSampler(); + if (vulkanAvailable) setupFramebuffers(); + if (vulkanAvailable) setupDescriptorPool(); + if (vulkanAvailable) setupDescriptorSets(); + if (vulkanAvailable) setupCommandBuffers(); + if (vulkanAvailable) setupDraw(); + if (vulkanAvailable) setupSemaphores(); + if (vulkanAvailable) setupFences(); + + // If something went wrong, notify the user by setting the window title + if (!vulkanAvailable) + window.setTitle("SFML window with Vulkan (Vulkan not available)"); + } + + + // Destructor + ~VulkanExample() + { + // Wait until there are no pending frames + if (device) + vkDeviceWaitIdle(device); + + // Teardown swapchain + cleanupSwapchain(); + + // Vulkan teardown procedure + for (std::size_t i = 0; i < fences.size(); i++) + vkDestroyFence(device, fences[i], 0); + + for (std::size_t i = 0; i < renderFinishedSemaphores.size(); i++) + vkDestroySemaphore(device, renderFinishedSemaphores[i], 0); + + for (std::size_t i = 0; i < imageAvailableSemaphores.size(); i++) + vkDestroySemaphore(device, imageAvailableSemaphores[i], 0); + + if (descriptorPool) + vkDestroyDescriptorPool(device, descriptorPool, 0); + + for (std::size_t i = 0; i < uniformBuffersMemory.size(); i++) + vkFreeMemory(device, uniformBuffersMemory[i], 0); + + for (std::size_t i = 0; i < uniformBuffers.size(); i++) + vkDestroyBuffer(device, uniformBuffers[i], 0); + + if (textureSampler) + vkDestroySampler(device, textureSampler, 0); + + if (textureImageView) + vkDestroyImageView(device, textureImageView, 0); + + if (textureImageMemory) + vkFreeMemory(device, textureImageMemory, 0); + + if (textureImage) + vkDestroyImage(device, textureImage, 0); + + if (indexBufferMemory) + vkFreeMemory(device, indexBufferMemory, 0); + + if (indexBuffer) + vkDestroyBuffer(device, indexBuffer, 0); + + if (vertexBufferMemory) + vkFreeMemory(device, vertexBufferMemory, 0); + + if (vertexBuffer) + vkDestroyBuffer(device, vertexBuffer, 0); + + if (commandPool) + vkDestroyCommandPool(device, commandPool, 0); + + if (descriptorSetLayout) + vkDestroyDescriptorSetLayout(device, descriptorSetLayout, 0); + + if (fragmentShaderModule) + vkDestroyShaderModule(device, fragmentShaderModule, 0); + + if (vertexShaderModule) + vkDestroyShaderModule(device, vertexShaderModule, 0); + + if (device) + vkDestroyDevice(device, 0); + + if (surface) + vkDestroySurfaceKHR(instance, surface, 0); + + if (debugReportCallback) + vkDestroyDebugReportCallbackEXT(instance, debugReportCallback, 0); + + if (instance) + vkDestroyInstance(instance, 0); + } + + // Cleanup swapchain + void cleanupSwapchain() + { + // Swapchain teardown procedure + for (std::size_t i = 0; i < fences.size(); i++) + vkWaitForFences(device, 1, &fences[i], VK_TRUE, std::numeric_limits::max()); + + if (commandBuffers.size()) + vkFreeCommandBuffers(device, commandPool, static_cast(commandBuffers.size()), &commandBuffers[0]); + + commandBuffers.clear(); + + for (std::size_t i = 0; i < swapchainFramebuffers.size(); i++) + vkDestroyFramebuffer(device, swapchainFramebuffers[i], 0); + + swapchainFramebuffers.clear(); + + if (graphicsPipeline) + vkDestroyPipeline(device, graphicsPipeline, 0); + + if (renderPass) + vkDestroyRenderPass(device, renderPass, 0); + + if (pipelineLayout) + vkDestroyPipelineLayout(device, pipelineLayout, 0); + + if (depthImageView) + vkDestroyImageView(device, depthImageView, 0); + + if (depthImageMemory) + vkFreeMemory(device, depthImageMemory, 0); + + if (depthImage) + vkDestroyImage(device, depthImage, 0); + + for (std::size_t i = 0; i < swapchainImageViews.size(); i++) + vkDestroyImageView(device, swapchainImageViews[i], 0); + + swapchainImageViews.clear(); + + if (swapchain) + vkDestroySwapchainKHR(device, swapchain, 0); + } + + // Cleanup and recreate swapchain + void recreateSwapchain() + { + // Wait until there are no pending frames + vkDeviceWaitIdle(device); + + // Cleanup swapchain + cleanupSwapchain(); + + // Swapchain setup procedure + if (vulkanAvailable) setupSwapchain(); + if (vulkanAvailable) setupSwapchainImages(); + if (vulkanAvailable) setupPipelineLayout(); + if (vulkanAvailable) setupRenderpass(); + if (vulkanAvailable) setupPipeline(); + if (vulkanAvailable) setupDepthImage(); + if (vulkanAvailable) setupDepthImageView(); + if (vulkanAvailable) setupFramebuffers(); + if (vulkanAvailable) setupCommandBuffers(); + if (vulkanAvailable) setupDraw(); + } + + // Setup Vulkan instance + void setupInstance() + { + // Load bootstrap entry points + gladLoadVulkan(0, getVulkanFunction); + + if (!vkCreateInstance) + { + vulkanAvailable = false; + return; + } + + // Retrieve the available instance layers + uint32_t objectCount = 0; + + std::vector layers; + + if (vkEnumerateInstanceLayerProperties(&objectCount, 0) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + layers.resize(objectCount); + + if (vkEnumerateInstanceLayerProperties(&objectCount, &layers[0]) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + // Activate the layers we are interested in + std::vector validationLayers; + + for (std::size_t i = 0; i < layers.size(); i++) + { + // VK_LAYER_LUNARG_standard_validation, meta-layer for the following layers: + // -- VK_LAYER_GOOGLE_threading + // -- VK_LAYER_LUNARG_parameter_validation + // -- VK_LAYER_LUNARG_device_limits + // -- VK_LAYER_LUNARG_object_tracker + // -- VK_LAYER_LUNARG_image + // -- VK_LAYER_LUNARG_core_validation + // -- VK_LAYER_LUNARG_swapchain + // -- VK_LAYER_GOOGLE_unique_objects + // These layers perform error checking and warn about bad or sub-optimal Vulkan API usage + // VK_LAYER_LUNARG_monitor appends an FPS counter to the window title + if (!std::strcmp(layers[i].layerName, "VK_LAYER_LUNARG_standard_validation")) + { + validationLayers.push_back("VK_LAYER_LUNARG_standard_validation"); + } + else if (!std::strcmp(layers[i].layerName, "VK_LAYER_LUNARG_monitor")) + { + validationLayers.push_back("VK_LAYER_LUNARG_monitor"); + } + } + + // Retrieve the extensions we need to enable in order to use Vulkan with SFML + std::vector requiredExtentions = sf::Vulkan::getGraphicsRequiredInstanceExtensions(); + requiredExtentions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME); + + // Register our application information + VkApplicationInfo applicationInfo = VkApplicationInfo(); + applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + applicationInfo.pApplicationName = "SFML Vulkan Test"; + applicationInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0); + applicationInfo.pEngineName = "SFML Vulkan Test Engine"; + applicationInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0); + applicationInfo.apiVersion = VK_API_VERSION_1_0; + + VkInstanceCreateInfo instanceCreateInfo = VkInstanceCreateInfo(); + instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + instanceCreateInfo.pApplicationInfo = &applicationInfo; + instanceCreateInfo.enabledLayerCount = static_cast(validationLayers.size()); + instanceCreateInfo.ppEnabledLayerNames = &validationLayers[0]; + instanceCreateInfo.enabledExtensionCount = static_cast(requiredExtentions.size()); + instanceCreateInfo.ppEnabledExtensionNames = &requiredExtentions[0]; + + // Try to create a Vulkan instance with debug report enabled + VkResult result = vkCreateInstance(&instanceCreateInfo, 0, &instance); + + // If an extension is missing, try disabling debug report + if (result == VK_ERROR_EXTENSION_NOT_PRESENT) + { + requiredExtentions.pop_back(); + + instanceCreateInfo.enabledExtensionCount = static_cast(requiredExtentions.size()); + instanceCreateInfo.ppEnabledExtensionNames = &requiredExtentions[0]; + + result = vkCreateInstance(&instanceCreateInfo, 0, &instance); + } + + // If instance creation still fails, give up + if (result != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + // Load instance entry points + gladLoadVulkan(0, getVulkanFunction); + } + + // Setup our debug callback function to be called by Vulkan + void setupDebugReportCallback() + { + // Don't try to register the callback if the extension is not available + if (!vkCreateDebugReportCallbackEXT) + return; + + // Register for warnings and errors + VkDebugReportCallbackCreateInfoEXT debugReportCallbackCreateInfo = VkDebugReportCallbackCreateInfoEXT(); + debugReportCallbackCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; + debugReportCallbackCreateInfo.flags = VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT | VK_DEBUG_REPORT_ERROR_BIT_EXT; + debugReportCallbackCreateInfo.pfnCallback = debugCallback; + + // Create the debug callback + if (vkCreateDebugReportCallbackEXT(instance, &debugReportCallbackCreateInfo, 0, &debugReportCallback) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Setup the SFML window Vulkan rendering surface + void setupSurface() + { + if (!window.createVulkanSurface(instance, surface)) + vulkanAvailable = false; + } + + // Select a GPU to use and query its capabilities + void setupPhysicalDevice() + { + // Last sanity check + if (!vkEnumeratePhysicalDevices || !vkCreateDevice || !vkGetPhysicalDeviceProperties) + { + vulkanAvailable = false; + return; + } + + // Retrieve list of GPUs + uint32_t objectCount = 0; + + std::vector devices; + + if (vkEnumeratePhysicalDevices(instance, &objectCount, 0) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + devices.resize(objectCount); + + if (vkEnumeratePhysicalDevices(instance, &objectCount, &devices[0]) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + // Look for a GPU that supports swapchains + for (std::size_t i = 0; i < devices.size(); i++) + { + VkPhysicalDeviceProperties deviceProperties; + vkGetPhysicalDeviceProperties(devices[i], &deviceProperties); + + std::vector extensions; + + if (vkEnumerateDeviceExtensionProperties(devices[i], 0, &objectCount, 0) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + extensions.resize(objectCount); + + if (vkEnumerateDeviceExtensionProperties(devices[i], 0, &objectCount, &extensions[0]) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + bool supportsSwapchain = false; + + for (std::size_t j = 0; j < extensions.size(); j++) + { + if (!std::strcmp(extensions[j].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME)) + { + supportsSwapchain = true; + break; + } + } + + if (!supportsSwapchain) + continue; + + // Prefer discrete over integrated GPUs if multiple are available + if (deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) + { + gpu = devices[i]; + break; + } + else if (deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) + { + gpu = devices[i]; + } + } + + if (!gpu) + { + vulkanAvailable = false; + return; + } + + // Load physical device entry points + gladLoadVulkan(gpu, getVulkanFunction); + + // Check what depth formats are available and select one + VkFormatProperties formatProperties = VkFormatProperties(); + + vkGetPhysicalDeviceFormatProperties(gpu, VK_FORMAT_D24_UNORM_S8_UINT, &formatProperties); + + if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) { + depthFormat = VK_FORMAT_D24_UNORM_S8_UINT; + } + else + { + vkGetPhysicalDeviceFormatProperties(gpu, VK_FORMAT_D32_SFLOAT_S8_UINT, &formatProperties); + + if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) { + depthFormat = VK_FORMAT_D32_SFLOAT_S8_UINT; + } + else + { + vkGetPhysicalDeviceFormatProperties(gpu, VK_FORMAT_D32_SFLOAT, &formatProperties); + + if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) { + depthFormat = VK_FORMAT_D32_SFLOAT; + } + else + { + vulkanAvailable = false; + return; + } + } + } + } + + // Setup logical device and device queue + void setupLogicalDevice() + { + // Select a queue family that supports graphics operations and surface presentation + uint32_t objectCount = 0; + + std::vector queueFamilyProperties; + + vkGetPhysicalDeviceQueueFamilyProperties(gpu, &objectCount, 0); + + queueFamilyProperties.resize(objectCount); + + vkGetPhysicalDeviceQueueFamilyProperties(gpu, &objectCount, &queueFamilyProperties[0]); + + for (std::size_t i = 0; i < queueFamilyProperties.size(); i++) + { + VkBool32 surfaceSupported = VK_FALSE; + + vkGetPhysicalDeviceSurfaceSupportKHR(gpu, static_cast(i), surface, &surfaceSupported); + + if ((queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && (surfaceSupported == VK_TRUE)) + { + queueFamilyIndex = static_cast(i); + break; + } + } + + if (queueFamilyIndex < 0) + { + vulkanAvailable = false; + return; + } + + float queuePriority = 1.0f; + + VkDeviceQueueCreateInfo deviceQueueCreateInfo = VkDeviceQueueCreateInfo(); + deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + deviceQueueCreateInfo.queueCount = 1; + deviceQueueCreateInfo.queueFamilyIndex = static_cast(queueFamilyIndex); + deviceQueueCreateInfo.pQueuePriorities = &queuePriority; + + // Enable the swapchain extension + const char* extentions[1] = { VK_KHR_SWAPCHAIN_EXTENSION_NAME }; + + // Enable anisotropic filtering + VkPhysicalDeviceFeatures physicalDeviceFeatures = VkPhysicalDeviceFeatures(); + physicalDeviceFeatures.samplerAnisotropy = VK_TRUE; + + VkDeviceCreateInfo deviceCreateInfo = VkDeviceCreateInfo(); + deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + deviceCreateInfo.enabledExtensionCount = 1; + deviceCreateInfo.ppEnabledExtensionNames = extentions; + deviceCreateInfo.queueCreateInfoCount = 1; + deviceCreateInfo.pQueueCreateInfos = &deviceQueueCreateInfo; + deviceCreateInfo.pEnabledFeatures = &physicalDeviceFeatures; + + // Create our logical device + if (vkCreateDevice(gpu, &deviceCreateInfo, 0, &device) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + // Retrieve a handle to the logical device command queue + vkGetDeviceQueue(device, static_cast(queueFamilyIndex), 0, &queue); + } + + // Query surface formats and set up swapchain + void setupSwapchain() + { + // Select a surface format that supports RGBA color format + uint32_t objectCount = 0; + + std::vector surfaceFormats; + + if (vkGetPhysicalDeviceSurfaceFormatsKHR(gpu, surface, &objectCount, 0) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + surfaceFormats.resize(objectCount); + + if (vkGetPhysicalDeviceSurfaceFormatsKHR(gpu, surface, &objectCount, &surfaceFormats[0]) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + if ((surfaceFormats.size() == 1) && (surfaceFormats[0].format == VK_FORMAT_UNDEFINED)) + { + swapchainFormat.format = VK_FORMAT_B8G8R8A8_UNORM; + swapchainFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + else if (!surfaceFormats.empty()) + { + for (std::size_t i = 0; i < surfaceFormats.size(); i++) + { + if ((surfaceFormats[i].format == VK_FORMAT_B8G8R8A8_UNORM) && (surfaceFormats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)) + { + swapchainFormat.format = VK_FORMAT_B8G8R8A8_UNORM; + swapchainFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + + break; + } + } + + if (swapchainFormat.format == VK_FORMAT_UNDEFINED) + swapchainFormat = surfaceFormats[0]; + } + else + { + vulkanAvailable = false; + return; + } + + // Select a swapchain present mode + std::vector presentModes; + + if (vkGetPhysicalDeviceSurfacePresentModesKHR(gpu, surface, &objectCount, 0) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + presentModes.resize(objectCount); + + if (vkGetPhysicalDeviceSurfacePresentModesKHR(gpu, surface, &objectCount, &presentModes[0]) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + // Prefer mailbox over FIFO if it is available + VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR; + + for (std::size_t i = 0; i < presentModes.size(); i++) + { + if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) + { + presentMode = presentModes[i]; + break; + } + } + + // Determine size and count of swapchain images + VkSurfaceCapabilitiesKHR surfaceCapabilities; + + if (vkGetPhysicalDeviceSurfaceCapabilitiesKHR(gpu, surface, &surfaceCapabilities) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + swapchainExtent.width = clamp(window.getSize().x, surfaceCapabilities.minImageExtent.width, surfaceCapabilities.maxImageExtent.width); + swapchainExtent.height = clamp(window.getSize().y, surfaceCapabilities.minImageExtent.height, surfaceCapabilities.maxImageExtent.height); + + uint32_t imageCount = clamp(2, surfaceCapabilities.minImageCount, surfaceCapabilities.maxImageCount); + + VkSwapchainCreateInfoKHR swapchainCreateInfo = VkSwapchainCreateInfoKHR(); + swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; + swapchainCreateInfo.surface = surface; + swapchainCreateInfo.minImageCount = imageCount; + swapchainCreateInfo.imageFormat = swapchainFormat.format; + swapchainCreateInfo.imageColorSpace = swapchainFormat.colorSpace; + swapchainCreateInfo.imageExtent = swapchainExtent; + swapchainCreateInfo.imageArrayLayers = 1; + swapchainCreateInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + swapchainCreateInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; + swapchainCreateInfo.preTransform = surfaceCapabilities.currentTransform; + swapchainCreateInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; + swapchainCreateInfo.presentMode = presentMode; + swapchainCreateInfo.clipped = VK_TRUE; + swapchainCreateInfo.oldSwapchain = VK_NULL_HANDLE; + + // Create the swapchain + if (vkCreateSwapchainKHR(device, &swapchainCreateInfo, 0, &swapchain) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Retrieve the swapchain images and create image views for them + void setupSwapchainImages() + { + // Retrieve swapchain images + uint32_t objectCount = 0; + + if (vkGetSwapchainImagesKHR(device, swapchain, &objectCount, 0) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + swapchainImages.resize(objectCount); + swapchainImageViews.resize(objectCount); + + if (vkGetSwapchainImagesKHR(device, swapchain, &objectCount, &swapchainImages[0]) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + VkImageViewCreateInfo imageViewCreateInfo = VkImageViewCreateInfo(); + imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; + imageViewCreateInfo.format = swapchainFormat.format; + imageViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; + imageViewCreateInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; + imageViewCreateInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; + imageViewCreateInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; + imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + imageViewCreateInfo.subresourceRange.baseMipLevel = 0; + imageViewCreateInfo.subresourceRange.levelCount = 1; + imageViewCreateInfo.subresourceRange.baseArrayLayer = 0; + imageViewCreateInfo.subresourceRange.layerCount = 1; + + // Create an image view for each swapchain image + for (std::size_t i = 0; i < swapchainImages.size(); i++) + { + imageViewCreateInfo.image = swapchainImages[i]; + + if (vkCreateImageView(device, &imageViewCreateInfo, 0, &swapchainImageViews[i]) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + } + + // Load vertex and fragment shader modules + void setupShaders() + { + VkShaderModuleCreateInfo shaderModuleCreateInfo = VkShaderModuleCreateInfo(); + shaderModuleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + + // Use the vertex shader SPIR-V code to create a vertex shader module + { + sf::FileInputStream file; + + if (!file.open("resources/shader.vert.spv")) + { + vulkanAvailable = false; + return; + } + + std::vector buffer(static_cast(file.getSize()) / sizeof(uint32_t)); + + if (file.read(&buffer[0], file.getSize()) != file.getSize()) + { + vulkanAvailable = false; + return; + } + + shaderModuleCreateInfo.codeSize = buffer.size() * sizeof(uint32_t); + shaderModuleCreateInfo.pCode = &buffer[0]; + + if (vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &vertexShaderModule) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Use the fragment shader SPIR-V code to create a fragment shader module + { + sf::FileInputStream file; + + if (!file.open("resources/shader.frag.spv")) + { + vulkanAvailable = false; + return; + } + + std::vector buffer(static_cast(file.getSize()) / sizeof(uint32_t)); + + if (file.read(&buffer[0], file.getSize()) != file.getSize()) + { + vulkanAvailable = false; + return; + } + + shaderModuleCreateInfo.codeSize = buffer.size() * sizeof(uint32_t); + shaderModuleCreateInfo.pCode = &buffer[0]; + + if (vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &fragmentShaderModule) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Prepare the shader stage information for later pipeline creation + shaderStages[0]= VkPipelineShaderStageCreateInfo(); + shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT; + shaderStages[0].module = vertexShaderModule; + shaderStages[0].pName = "main"; + + shaderStages[1]= VkPipelineShaderStageCreateInfo(); + shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT; + shaderStages[1].module = fragmentShaderModule; + shaderStages[1].pName = "main"; + } + + // Setup renderpass and its subpass dependencies + void setupRenderpass() + { + VkAttachmentDescription attachmentDescriptions[2]; + + // Color attachment + attachmentDescriptions[0] = VkAttachmentDescription(); + attachmentDescriptions[0].format = swapchainFormat.format; + attachmentDescriptions[0].samples = VK_SAMPLE_COUNT_1_BIT; + attachmentDescriptions[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + attachmentDescriptions[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE; + attachmentDescriptions[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + attachmentDescriptions[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + attachmentDescriptions[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + attachmentDescriptions[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; + + // Depth attachment + attachmentDescriptions[1] = VkAttachmentDescription(); + attachmentDescriptions[1].format = depthFormat; + attachmentDescriptions[1].samples = VK_SAMPLE_COUNT_1_BIT; + attachmentDescriptions[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + attachmentDescriptions[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + attachmentDescriptions[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + attachmentDescriptions[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + attachmentDescriptions[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + attachmentDescriptions[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + VkAttachmentReference attachmentReferences[2]; + + attachmentReferences[0] = VkAttachmentReference(); + attachmentReferences[0].attachment = 0; + attachmentReferences[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + + attachmentReferences[1] = VkAttachmentReference(); + attachmentReferences[1].attachment = 1; + attachmentReferences[1].layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + // Set up the renderpass to depend on commands that execute before the renderpass begins + VkSubpassDescription subpassDescription = VkSubpassDescription(); + subpassDescription.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + subpassDescription.colorAttachmentCount = 1; + subpassDescription.pColorAttachments = &attachmentReferences[0]; + subpassDescription.pDepthStencilAttachment = &attachmentReferences[1]; + + VkSubpassDependency subpassDependency = VkSubpassDependency(); + subpassDependency.srcSubpass = VK_SUBPASS_EXTERNAL; + subpassDependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + subpassDependency.srcAccessMask = 0; + subpassDependency.dstSubpass = 0; + subpassDependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + subpassDependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + + VkRenderPassCreateInfo renderPassCreateInfo = VkRenderPassCreateInfo(); + renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + renderPassCreateInfo.attachmentCount = 2; + renderPassCreateInfo.pAttachments = attachmentDescriptions; + renderPassCreateInfo.subpassCount = 1; + renderPassCreateInfo.pSubpasses = &subpassDescription; + renderPassCreateInfo.dependencyCount = 1; + renderPassCreateInfo.pDependencies = &subpassDependency; + + // Create the renderpass + if (vkCreateRenderPass(device, &renderPassCreateInfo, 0, &renderPass) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Set up uniform buffer and texture sampler descriptor set layouts + void setupDescriptorSetLayout() + { + VkDescriptorSetLayoutBinding descriptorSetLayoutBindings[2]; + + // Layout binding for uniform buffer + descriptorSetLayoutBindings[0] = VkDescriptorSetLayoutBinding(); + descriptorSetLayoutBindings[0].binding = 0; + descriptorSetLayoutBindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptorSetLayoutBindings[0].descriptorCount = 1; + descriptorSetLayoutBindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + + // Layout binding for texture sampler + descriptorSetLayoutBindings[1] = VkDescriptorSetLayoutBinding(); + descriptorSetLayoutBindings[1].binding = 1; + descriptorSetLayoutBindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + descriptorSetLayoutBindings[1].descriptorCount = 1; + descriptorSetLayoutBindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + + VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = VkDescriptorSetLayoutCreateInfo(); + descriptorSetLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + descriptorSetLayoutCreateInfo.bindingCount = 2; + descriptorSetLayoutCreateInfo.pBindings = descriptorSetLayoutBindings; + + // Create descriptor set layout + if (vkCreateDescriptorSetLayout(device, &descriptorSetLayoutCreateInfo, 0, &descriptorSetLayout) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Set up pipeline layout + void setupPipelineLayout() + { + VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = VkPipelineLayoutCreateInfo(); + pipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + pipelineLayoutCreateInfo.setLayoutCount = 1; + pipelineLayoutCreateInfo.pSetLayouts = &descriptorSetLayout; + + // Create pipeline layout + if (vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, 0, &pipelineLayout) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Set up rendering pipeline + void setupPipeline() + { + // Set up how the vertex shader pulls data out of our vertex buffer + VkVertexInputBindingDescription vertexInputBindingDescription = VkVertexInputBindingDescription(); + vertexInputBindingDescription.binding = 0; + vertexInputBindingDescription.stride = sizeof(float) * 9; + vertexInputBindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + + // Set up how the vertex buffer data is interpreted as attributes by the vertex shader + VkVertexInputAttributeDescription vertexInputAttributeDescriptions[3]; + + // Position attribute + vertexInputAttributeDescriptions[0] = VkVertexInputAttributeDescription(); + vertexInputAttributeDescriptions[0].binding = 0; + vertexInputAttributeDescriptions[0].location = 0; + vertexInputAttributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT; + vertexInputAttributeDescriptions[0].offset = sizeof(float) * 0; + + // Color attribute + vertexInputAttributeDescriptions[1] = VkVertexInputAttributeDescription(); + vertexInputAttributeDescriptions[1].binding = 0; + vertexInputAttributeDescriptions[1].location = 1; + vertexInputAttributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; + vertexInputAttributeDescriptions[1].offset = sizeof(float) * 3; + + // Texture coordinate attribute + vertexInputAttributeDescriptions[2] = VkVertexInputAttributeDescription(); + vertexInputAttributeDescriptions[2].binding = 0; + vertexInputAttributeDescriptions[2].location = 2; + vertexInputAttributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT; + vertexInputAttributeDescriptions[2].offset = sizeof(float) * 7; + + VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo = VkPipelineVertexInputStateCreateInfo(); + vertexInputStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + vertexInputStateCreateInfo.vertexBindingDescriptionCount = 1; + vertexInputStateCreateInfo.pVertexBindingDescriptions = &vertexInputBindingDescription; + vertexInputStateCreateInfo.vertexAttributeDescriptionCount = 3; + vertexInputStateCreateInfo.pVertexAttributeDescriptions = vertexInputAttributeDescriptions; + + // We want to generate a triangle list with our vertex data + VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo = VkPipelineInputAssemblyStateCreateInfo(); + inputAssemblyStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + inputAssemblyStateCreateInfo.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + inputAssemblyStateCreateInfo.primitiveRestartEnable = VK_FALSE; + + // Set up the viewport + VkViewport viewport = VkViewport(); + viewport.x = 0.0f; + viewport.y = 0.0f; + viewport.width = static_cast(swapchainExtent.width); + viewport.height = static_cast(swapchainExtent.height); + viewport.minDepth = 0.0f; + viewport.maxDepth = 1.f; + + // Set up the scissor region + VkRect2D scissor = VkRect2D(); + scissor.offset.x = 0; + scissor.offset.y = 0; + scissor.extent = swapchainExtent; + + VkPipelineViewportStateCreateInfo pipelineViewportStateCreateInfo = VkPipelineViewportStateCreateInfo(); + pipelineViewportStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + pipelineViewportStateCreateInfo.viewportCount = 1; + pipelineViewportStateCreateInfo.pViewports = &viewport; + pipelineViewportStateCreateInfo.scissorCount = 1; + pipelineViewportStateCreateInfo.pScissors = &scissor; + + // Set up rasterization parameters: fill polygons, no backface culling, front face is counter-clockwise + VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateCreateInfo = VkPipelineRasterizationStateCreateInfo(); + pipelineRasterizationStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + pipelineRasterizationStateCreateInfo.depthClampEnable = VK_FALSE; + pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable = VK_FALSE; + pipelineRasterizationStateCreateInfo.polygonMode = VK_POLYGON_MODE_FILL; + pipelineRasterizationStateCreateInfo.lineWidth = 1.0f; + pipelineRasterizationStateCreateInfo.cullMode = VK_CULL_MODE_NONE; + pipelineRasterizationStateCreateInfo.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; + pipelineRasterizationStateCreateInfo.depthBiasEnable = VK_FALSE; + + // Enable depth testing and disable scissor testing + VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateCreateInfo = VkPipelineDepthStencilStateCreateInfo(); + pipelineDepthStencilStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + pipelineDepthStencilStateCreateInfo.depthTestEnable = VK_TRUE; + pipelineDepthStencilStateCreateInfo.depthWriteEnable = VK_TRUE; + pipelineDepthStencilStateCreateInfo.depthCompareOp = VK_COMPARE_OP_LESS; + pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable = VK_FALSE; + pipelineDepthStencilStateCreateInfo.stencilTestEnable = VK_FALSE; + + // Enable multi-sampling + VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo = VkPipelineMultisampleStateCreateInfo(); + pipelineMultisampleStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + pipelineMultisampleStateCreateInfo.sampleShadingEnable = VK_FALSE; + pipelineMultisampleStateCreateInfo.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; + + // Set up blending parameters + VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState = VkPipelineColorBlendAttachmentState(); + pipelineColorBlendAttachmentState.blendEnable = VK_TRUE; + pipelineColorBlendAttachmentState.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA; + pipelineColorBlendAttachmentState.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; + pipelineColorBlendAttachmentState.colorBlendOp = VK_BLEND_OP_ADD; + pipelineColorBlendAttachmentState.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; + pipelineColorBlendAttachmentState.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; + pipelineColorBlendAttachmentState.alphaBlendOp = VK_BLEND_OP_ADD; + pipelineColorBlendAttachmentState.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; + + VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateCreateInfo = VkPipelineColorBlendStateCreateInfo(); + pipelineColorBlendStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + pipelineColorBlendStateCreateInfo.logicOpEnable = VK_FALSE; + pipelineColorBlendStateCreateInfo.attachmentCount = 1; + pipelineColorBlendStateCreateInfo.pAttachments = &pipelineColorBlendAttachmentState; + + VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo = VkGraphicsPipelineCreateInfo(); + graphicsPipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + graphicsPipelineCreateInfo.stageCount = 2; + graphicsPipelineCreateInfo.pStages = shaderStages; + graphicsPipelineCreateInfo.pVertexInputState = &vertexInputStateCreateInfo; + graphicsPipelineCreateInfo.pInputAssemblyState = &inputAssemblyStateCreateInfo; + graphicsPipelineCreateInfo.pViewportState = &pipelineViewportStateCreateInfo; + graphicsPipelineCreateInfo.pRasterizationState = &pipelineRasterizationStateCreateInfo; + graphicsPipelineCreateInfo.pDepthStencilState = &pipelineDepthStencilStateCreateInfo; + graphicsPipelineCreateInfo.pMultisampleState = &pipelineMultisampleStateCreateInfo; + graphicsPipelineCreateInfo.pColorBlendState = &pipelineColorBlendStateCreateInfo; + graphicsPipelineCreateInfo.layout = pipelineLayout; + graphicsPipelineCreateInfo.renderPass = renderPass; + graphicsPipelineCreateInfo.subpass = 0; + + // Create our graphics pipeline + if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &graphicsPipelineCreateInfo, 0, &graphicsPipeline) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Use our renderpass and swapchain images to create the corresponding framebuffers + void setupFramebuffers() + { + swapchainFramebuffers.resize(swapchainImageViews.size()); + + VkFramebufferCreateInfo framebufferCreateInfo = VkFramebufferCreateInfo(); + framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + framebufferCreateInfo.renderPass = renderPass; + framebufferCreateInfo.attachmentCount = 2; + framebufferCreateInfo.width = swapchainExtent.width; + framebufferCreateInfo.height = swapchainExtent.height; + framebufferCreateInfo.layers = 1; + + for (std::size_t i = 0; i < swapchainFramebuffers.size(); i++) + { + // Each framebuffer consists of a corresponding swapchain image and the shared depth image + VkImageView attachments[] = {swapchainImageViews[i], depthImageView}; + + framebufferCreateInfo.pAttachments = attachments; + + // Create the framebuffer + if (vkCreateFramebuffer(device, &framebufferCreateInfo, 0, &swapchainFramebuffers[i]) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + } + + // Set up our command pool + void setupCommandPool() + { + // We want to be able to reset command buffers after submitting them + VkCommandPoolCreateInfo commandPoolCreateInfo = VkCommandPoolCreateInfo(); + commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + commandPoolCreateInfo.queueFamilyIndex = static_cast(queueFamilyIndex); + commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + + // Create our command pool + if (vkCreateCommandPool(device, &commandPoolCreateInfo, 0, &commandPool) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Helper to create a generic buffer with the specified size, usage and memory flags + bool createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& memory) + { + // We only have a single queue so we can request exclusive access + VkBufferCreateInfo bufferCreateInfo = VkBufferCreateInfo(); + bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; + bufferCreateInfo.size = size; + bufferCreateInfo.usage = usage; + bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + + // Create the buffer, this does not allocate any memory for it yet + if (vkCreateBuffer(device, &bufferCreateInfo, 0, &buffer) != VK_SUCCESS) + return false; + + // Check what kind of memory we need to request from the GPU + VkMemoryRequirements memoryRequirements = VkMemoryRequirements(); + vkGetBufferMemoryRequirements(device, buffer, &memoryRequirements); + + // Check what GPU memory type is available for us to allocate out of + VkPhysicalDeviceMemoryProperties memoryProperties = VkPhysicalDeviceMemoryProperties(); + vkGetPhysicalDeviceMemoryProperties(gpu, &memoryProperties); + + uint32_t memoryType = 0; + + for (; memoryType < memoryProperties.memoryTypeCount; memoryType++) + { + if ((memoryRequirements.memoryTypeBits & static_cast(1 << memoryType)) && + ((memoryProperties.memoryTypes[memoryType].propertyFlags & properties) == properties)) + break; + } + + if (memoryType == memoryProperties.memoryTypeCount) + return false; + + VkMemoryAllocateInfo memoryAllocateInfo = VkMemoryAllocateInfo(); + memoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + memoryAllocateInfo.allocationSize = memoryRequirements.size; + memoryAllocateInfo.memoryTypeIndex = memoryType; + + // Allocate the memory out of the GPU pool for the required memory type + if (vkAllocateMemory(device, &memoryAllocateInfo, 0, &memory) != VK_SUCCESS) + return false; + + // Bind the allocated memory to our buffer object + if (vkBindBufferMemory(device, buffer, memory, 0) != VK_SUCCESS) + return false; + + return true; + } + + // Helper to copy the contents of one buffer to another buffer + bool copyBuffer(VkBuffer dst, VkBuffer src, VkDeviceSize size) + { + // Allocate a primary command buffer out of our command pool + VkCommandBufferAllocateInfo commandBufferAllocateInfo = VkCommandBufferAllocateInfo(); + commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + commandBufferAllocateInfo.commandPool = commandPool; + commandBufferAllocateInfo.commandBufferCount = 1; + + VkCommandBuffer commandBuffer; + + if (vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, &commandBuffer) != VK_SUCCESS) + return false; + + // Begin the command buffer + VkCommandBufferBeginInfo commandBufferBeginInfo = VkCommandBufferBeginInfo(); + commandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + commandBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + + if (vkBeginCommandBuffer(commandBuffer, &commandBufferBeginInfo) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + return false; + } + + // Add our buffer copy command + VkBufferCopy bufferCopy = VkBufferCopy(); + bufferCopy.srcOffset = 0; + bufferCopy.dstOffset = 0; + bufferCopy.size = size; + + vkCmdCopyBuffer(commandBuffer, src, dst, 1, &bufferCopy); + + // End and submit the command buffer + vkEndCommandBuffer(commandBuffer); + + VkSubmitInfo submitInfo = VkSubmitInfo(); + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffer; + + if (vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + return false; + } + + // Ensure the command buffer has been processed + if (vkQueueWaitIdle(queue) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + return false; + } + + // Free the command buffer + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + return true; + } + + // Create our vertex buffer and upload its data + void setupVertexBuffer() + { + float vertexData[] = { + // X Y Z R G B A U V + -0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, + -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + + -0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, + 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, + -0.5f, 0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, + + 0.5f, -0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, + 0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, + + -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, + -0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, + + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, + + -0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, + 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f + }; + + // Create a staging buffer that is writable by the CPU + VkBuffer stagingBuffer = 0; + VkDeviceMemory stagingBufferMemory = 0; + + if (!createBuffer( + sizeof(vertexData), + VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + stagingBuffer, + stagingBufferMemory + )) + { + vulkanAvailable = false; + return; + } + + void* ptr; + + // Map the buffer into our address space + if (vkMapMemory(device, stagingBufferMemory, 0, sizeof(vertexData), 0, &ptr) != VK_SUCCESS) + { + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Copy the vertex data into the buffer + std::memcpy(ptr, vertexData, sizeof(vertexData)); + + // Unmap the buffer + vkUnmapMemory(device, stagingBufferMemory); + + // Create the GPU local vertex buffer + if (!createBuffer( + sizeof(vertexData), + VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + vertexBuffer, + vertexBufferMemory + )) + { + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Copy the contents of the staging buffer into the GPU vertex buffer + vulkanAvailable = copyBuffer(vertexBuffer, stagingBuffer, sizeof(vertexData)); + + // Free the staging buffer and its memory + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + } + + // Create our index buffer and upload its data + void setupIndexBuffer() + { + uint16_t indexData[] = { + 0, 1, 2, + 2, 3, 0, + + 4, 5, 6, + 6, 7, 4, + + 8, 9, 10, + 10, 11, 8, + + 12, 13, 14, + 14, 15, 12, + + 16, 17, 18, + 18, 19, 16, + + 20, 21, 22, + 22, 23, 20 + }; + + // Create a staging buffer that is writable by the CPU + VkBuffer stagingBuffer = 0; + VkDeviceMemory stagingBufferMemory = 0; + + if (!createBuffer( + sizeof(indexData), + VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + stagingBuffer, + stagingBufferMemory + )) + { + vulkanAvailable = false; + return; + } + + void* ptr; + + // Map the buffer into our address space + if (vkMapMemory(device, stagingBufferMemory, 0, sizeof(indexData), 0, &ptr) != VK_SUCCESS) + { + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Copy the index data into the buffer + std::memcpy(ptr, indexData, sizeof(indexData)); + + // Unmap the buffer + vkUnmapMemory(device, stagingBufferMemory); + + // Create the GPU local index buffer + if (!createBuffer( + sizeof(indexData), + VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + indexBuffer, + indexBufferMemory + )) + { + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Copy the contents of the staging buffer into the GPU index buffer + vulkanAvailable = copyBuffer(indexBuffer, stagingBuffer, sizeof(indexData)); + + // Free the staging buffer and its memory + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + } + + // Create our uniform buffer but don't upload any data yet + void setupUniformBuffers() + { + // Create a uniform buffer for every frame that might be in flight to prevent clobbering + for (size_t i = 0; i < swapchainImages.size(); i++) + { + uniformBuffers.push_back(0); + uniformBuffersMemory.push_back(0); + + // The uniform buffer will be host visible and coherent since we use it for streaming data every frame + if (!createBuffer( + sizeof(Matrix) * 3, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + uniformBuffers[i], + uniformBuffersMemory[i] + )) + { + vulkanAvailable = false; + return; + } + } + } + + // Helper to create a generic image with the specified size, format, usage and memory flags + bool createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage& image, VkDeviceMemory& imageMemory) + { + // We only have a single queue so we can request exclusive access + VkImageCreateInfo imageCreateInfo = VkImageCreateInfo(); + imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + imageCreateInfo.imageType = VK_IMAGE_TYPE_2D; + imageCreateInfo.extent.width = width; + imageCreateInfo.extent.height = height; + imageCreateInfo.extent.depth = 1; + imageCreateInfo.mipLevels = 1; + imageCreateInfo.arrayLayers = 1; + imageCreateInfo.format = format; + imageCreateInfo.tiling = tiling; + imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + imageCreateInfo.usage = usage; + imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT; + imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + + // Create the image, this does not allocate any memory for it yet + if (vkCreateImage(device, &imageCreateInfo, 0, &image) != VK_SUCCESS) + return false; + + // Check what kind of memory we need to request from the GPU + VkMemoryRequirements memoryRequirements = VkMemoryRequirements(); + vkGetImageMemoryRequirements(device, image, &memoryRequirements); + + // Check what GPU memory type is available for us to allocate out of + VkPhysicalDeviceMemoryProperties memoryProperties = VkPhysicalDeviceMemoryProperties(); + vkGetPhysicalDeviceMemoryProperties(gpu, &memoryProperties); + + uint32_t memoryType = 0; + + for (; memoryType < memoryProperties.memoryTypeCount; memoryType++) + { + if ((memoryRequirements.memoryTypeBits & static_cast(1 << memoryType)) && + ((memoryProperties.memoryTypes[memoryType].propertyFlags & properties) == properties)) + break; + } + + if (memoryType == memoryProperties.memoryTypeCount) + return false; + + VkMemoryAllocateInfo memoryAllocateInfo = VkMemoryAllocateInfo(); + memoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + memoryAllocateInfo.allocationSize = memoryRequirements.size; + memoryAllocateInfo.memoryTypeIndex = memoryType; + + // Allocate the memory out of the GPU pool for the required memory type + if (vkAllocateMemory(device, &memoryAllocateInfo, 0, &imageMemory) != VK_SUCCESS) + return false; + + // Bind the allocated memory to our image object + if (vkBindImageMemory(device, image, imageMemory, 0) != VK_SUCCESS) + return false; + + return true; + } + + // Create our depth image and transition it into the proper layout + void setupDepthImage() + { + // Create our depth image + if (!createImage( + swapchainExtent.width, + swapchainExtent.height, + depthFormat, + VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + depthImage, + depthImageMemory + )) + { + vulkanAvailable = false; + return; + } + + // Allocate a command buffer + VkCommandBufferAllocateInfo commandBufferAllocateInfo = VkCommandBufferAllocateInfo(); + commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + commandBufferAllocateInfo.commandPool = commandPool; + commandBufferAllocateInfo.commandBufferCount = 1; + + VkCommandBuffer commandBuffer; + + if (vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, &commandBuffer) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + // Begin the command buffer + VkCommandBufferBeginInfo commandBufferBeginInfo = VkCommandBufferBeginInfo(); + commandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + commandBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + + VkSubmitInfo submitInfo = VkSubmitInfo(); + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffer; + + if (vkBeginCommandBuffer(commandBuffer, &commandBufferBeginInfo) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vulkanAvailable = false; + return; + } + + // Submit a barrier to transition the image layout to depth stencil optimal + VkImageMemoryBarrier barrier = VkImageMemoryBarrier(); + barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; + barrier.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = depthImage; + barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | ((depthFormat == VK_FORMAT_D32_SFLOAT) ? 0 : VK_IMAGE_ASPECT_STENCIL_BIT); + barrier.subresourceRange.baseMipLevel = 0; + barrier.subresourceRange.levelCount = 1; + barrier.subresourceRange.baseArrayLayer = 0; + barrier.subresourceRange.layerCount = 1; + barrier.srcAccessMask = 0; + barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + + vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, 0, 0, 0, 0, 0, 1, &barrier); + + // End and submit the command buffer + if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vulkanAvailable = false; + return; + } + + if (vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vulkanAvailable = false; + return; + } + + // Ensure the command buffer has been processed + if (vkQueueWaitIdle(queue) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vulkanAvailable = false; + return; + } + + // Free the command buffer + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + } + + // Create an image view for our depth image + void setupDepthImageView() + { + VkImageViewCreateInfo imageViewCreateInfo = VkImageViewCreateInfo(); + imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + imageViewCreateInfo.image = depthImage; + imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; + imageViewCreateInfo.format = depthFormat; + imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | ((depthFormat == VK_FORMAT_D32_SFLOAT) ? 0 : VK_IMAGE_ASPECT_STENCIL_BIT); + imageViewCreateInfo.subresourceRange.baseMipLevel = 0; + imageViewCreateInfo.subresourceRange.levelCount = 1; + imageViewCreateInfo.subresourceRange.baseArrayLayer = 0; + imageViewCreateInfo.subresourceRange.layerCount = 1; + + // Create the depth image view + if (vkCreateImageView(device, &imageViewCreateInfo, 0, &depthImageView) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Create an image for our texture data + void setupTextureImage() + { + // Load the image data + sf::Image imageData; + + if (!imageData.loadFromFile("resources/logo.png")) + { + vulkanAvailable = false; + return; + } + + // Create a staging buffer to transfer the data with + VkDeviceSize imageSize = imageData.getSize().x * imageData.getSize().y * 4; + + VkBuffer stagingBuffer; + VkDeviceMemory stagingBufferMemory; + createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory); + + void* ptr; + + // Map the buffer into our address space + if (vkMapMemory(device, stagingBufferMemory, 0, imageSize, 0, &ptr) != VK_SUCCESS) + { + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Copy the image data into the buffer + std::memcpy(ptr, imageData.getPixelsPtr(), static_cast(imageSize)); + + // Unmap the buffer + vkUnmapMemory(device, stagingBufferMemory); + + // Create a GPU local image + if (!createImage( + imageData.getSize().x, + imageData.getSize().y, + VK_FORMAT_R8G8B8A8_UNORM, + VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + textureImage, + textureImageMemory + )) + { + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Create a command buffer + VkCommandBufferAllocateInfo commandBufferAllocateInfo = VkCommandBufferAllocateInfo(); + commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + commandBufferAllocateInfo.commandPool = commandPool; + commandBufferAllocateInfo.commandBufferCount = 1; + + VkCommandBuffer commandBuffer; + + if (vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, &commandBuffer) != VK_SUCCESS) + { + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Begin the command buffer + VkCommandBufferBeginInfo commandBufferBeginInfo = VkCommandBufferBeginInfo(); + commandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + commandBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + + VkSubmitInfo submitInfo = VkSubmitInfo(); + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffer; + + if (vkBeginCommandBuffer(commandBuffer, &commandBufferBeginInfo) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Submit a barrier to transition the image layout to transfer destionation optimal + VkImageMemoryBarrier barrier = VkImageMemoryBarrier(); + barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; + barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = textureImage; + barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + barrier.subresourceRange.baseMipLevel = 0; + barrier.subresourceRange.levelCount = 1; + barrier.subresourceRange.baseArrayLayer = 0; + barrier.subresourceRange.layerCount = 1; + barrier.srcAccessMask = 0; + barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + + vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, 0, 0, 0, 1, &barrier); + + if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + if (vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Ensure the command buffer has been processed + if (vkQueueWaitIdle(queue) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Begin the command buffer + if (vkBeginCommandBuffer(commandBuffer, &commandBufferBeginInfo) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Copy the staging buffer contents into the image + VkBufferImageCopy bufferImageCopy = VkBufferImageCopy(); + bufferImageCopy.bufferOffset = 0; + bufferImageCopy.bufferRowLength = 0; + bufferImageCopy.bufferImageHeight = 0; + bufferImageCopy.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + bufferImageCopy.imageSubresource.mipLevel = 0; + bufferImageCopy.imageSubresource.baseArrayLayer = 0; + bufferImageCopy.imageSubresource.layerCount = 1; + bufferImageCopy.imageOffset.x = 0; + bufferImageCopy.imageOffset.y = 0; + bufferImageCopy.imageOffset.z = 0; + bufferImageCopy.imageExtent.width = imageData.getSize().x; + bufferImageCopy.imageExtent.height = imageData.getSize().y; + bufferImageCopy.imageExtent.depth = 1; + + vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, textureImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &bufferImageCopy); + + // End and submit the command buffer + if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + if (vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Ensure the command buffer has been processed + if (vkQueueWaitIdle(queue) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Begin the command buffer + if (vkBeginCommandBuffer(commandBuffer, &commandBufferBeginInfo) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Submit a barrier to transition the image layout from transfer destionation optimal to shader read-only optimal + barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; + + vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, 0, 0, 0, 1, &barrier); + + // End and submit the command buffer + if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + if (vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Ensure the command buffer has been processed + if (vkQueueWaitIdle(queue) != VK_SUCCESS) + { + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + + vulkanAvailable = false; + return; + } + + // Free the command buffer + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); + + vkFreeMemory(device, stagingBufferMemory, 0); + vkDestroyBuffer(device, stagingBuffer, 0); + } + + // Create an image view for our texture + void setupTextureImageView() + { + VkImageViewCreateInfo imageViewCreateInfo = VkImageViewCreateInfo(); + imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + imageViewCreateInfo.image = textureImage; + imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; + imageViewCreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM; + imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + imageViewCreateInfo.subresourceRange.baseMipLevel = 0; + imageViewCreateInfo.subresourceRange.levelCount = 1; + imageViewCreateInfo.subresourceRange.baseArrayLayer = 0; + imageViewCreateInfo.subresourceRange.layerCount = 1; + + // Create our texture image view + if (vkCreateImageView(device, &imageViewCreateInfo, 0, &textureImageView) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Create a sampler for our texture + void setupTextureSampler() + { + // Sampler parameters: linear min/mag filtering, 4x anisotropic + VkSamplerCreateInfo samplerCreateInfo = VkSamplerCreateInfo(); + samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + samplerCreateInfo.magFilter = VK_FILTER_LINEAR; + samplerCreateInfo.minFilter = VK_FILTER_LINEAR; + samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerCreateInfo.anisotropyEnable = VK_TRUE; + samplerCreateInfo.maxAnisotropy = 4; + samplerCreateInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK; + samplerCreateInfo.unnormalizedCoordinates = VK_FALSE; + samplerCreateInfo.compareEnable = VK_FALSE; + samplerCreateInfo.compareOp = VK_COMPARE_OP_ALWAYS; + samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; + samplerCreateInfo.mipLodBias = 0.0f; + samplerCreateInfo.minLod = 0.0f; + samplerCreateInfo.maxLod = 0.0f; + + // Create our sampler + if (vkCreateSampler(device, &samplerCreateInfo, 0, &textureSampler) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Set up our descriptor pool + void setupDescriptorPool() + { + // We need to allocate as many descriptor sets as we have frames in flight + VkDescriptorPoolSize descriptorPoolSizes[2]; + + descriptorPoolSizes[0] = VkDescriptorPoolSize(); + descriptorPoolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + descriptorPoolSizes[0].descriptorCount = static_cast(swapchainImages.size()); + + descriptorPoolSizes[1] = VkDescriptorPoolSize(); + descriptorPoolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + descriptorPoolSizes[1].descriptorCount = static_cast(swapchainImages.size()); + + VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = VkDescriptorPoolCreateInfo(); + descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + descriptorPoolCreateInfo.poolSizeCount = 2; + descriptorPoolCreateInfo.pPoolSizes = descriptorPoolSizes; + descriptorPoolCreateInfo.maxSets = static_cast(swapchainImages.size()); + + // Create the descriptor pool + if (vkCreateDescriptorPool(device, &descriptorPoolCreateInfo, 0, &descriptorPool) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Set up our descriptor sets + void setupDescriptorSets() + { + // Allocate a descriptor set for each frame in flight + std::vector descriptorSetLayouts(swapchainImages.size(), descriptorSetLayout); + + VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = VkDescriptorSetAllocateInfo(); + descriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + descriptorSetAllocateInfo.descriptorPool = descriptorPool; + descriptorSetAllocateInfo.descriptorSetCount = static_cast(swapchainImages.size()); + descriptorSetAllocateInfo.pSetLayouts = &descriptorSetLayouts[0]; + + descriptorSets.resize(swapchainImages.size()); + + if (vkAllocateDescriptorSets(device, &descriptorSetAllocateInfo, &descriptorSets[0]) != VK_SUCCESS) + { + descriptorSets.clear(); + + vulkanAvailable = false; + return; + } + + // For every descriptor set, set up the bindings to our uniform buffer and texture sampler + for (std::size_t i = 0; i < descriptorSets.size(); i++) + { + VkWriteDescriptorSet writeDescriptorSets[2]; + + // Uniform buffer binding information + VkDescriptorBufferInfo descriptorBufferInfo = VkDescriptorBufferInfo(); + descriptorBufferInfo.buffer = uniformBuffers[i]; + descriptorBufferInfo.offset = 0; + descriptorBufferInfo.range = sizeof(Matrix) * 3; + + writeDescriptorSets[0] = VkWriteDescriptorSet(); + writeDescriptorSets[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + writeDescriptorSets[0].dstSet = descriptorSets[i]; + writeDescriptorSets[0].dstBinding = 0; + writeDescriptorSets[0].dstArrayElement = 0; + writeDescriptorSets[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + writeDescriptorSets[0].descriptorCount = 1; + writeDescriptorSets[0].pBufferInfo = &descriptorBufferInfo; + + // Texture sampler binding information + VkDescriptorImageInfo descriptorImageInfo = VkDescriptorImageInfo(); + descriptorImageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + descriptorImageInfo.imageView = textureImageView; + descriptorImageInfo.sampler = textureSampler; + + writeDescriptorSets[1] = VkWriteDescriptorSet(); + writeDescriptorSets[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + writeDescriptorSets[1].dstSet = descriptorSets[i]; + writeDescriptorSets[1].dstBinding = 1; + writeDescriptorSets[1].dstArrayElement = 0; + writeDescriptorSets[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + writeDescriptorSets[1].descriptorCount = 1; + writeDescriptorSets[1].pImageInfo = &descriptorImageInfo; + + // Update the desciptor set + vkUpdateDescriptorSets(device, 2, writeDescriptorSets, 0, 0); + } + } + + // Set up the command buffers we use for drawing each frame + void setupCommandBuffers() + { + // We need a command buffer for every frame in flight + commandBuffers.resize(swapchainFramebuffers.size()); + + // These are primary command buffers + VkCommandBufferAllocateInfo commandBufferAllocateInfo = VkCommandBufferAllocateInfo(); + commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + commandBufferAllocateInfo.commandPool = commandPool; + commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + commandBufferAllocateInfo.commandBufferCount = static_cast(commandBuffers.size()); + + // Allocate the command buffers from our command pool + if (vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, &commandBuffers[0]) != VK_SUCCESS) + { + commandBuffers.clear(); + vulkanAvailable = false; + return; + } + } + + // Set up the commands we need to issue to draw a frame + void setupDraw() + { + // Set up our clear colors + VkClearValue clearColors[2]; + + // Clear color buffer to opaque black + clearColors[0] = VkClearValue(); + clearColors[0].color.float32[0] = 0.0f; + clearColors[0].color.float32[1] = 0.0f; + clearColors[0].color.float32[2] = 0.0f; + clearColors[0].color.float32[3] = 0.0f; + + // Clear depth to 1.0f + clearColors[1] = VkClearValue(); + clearColors[1].depthStencil.depth = 1.0f; + clearColors[1].depthStencil.stencil = 0; + + VkRenderPassBeginInfo renderPassBeginInfo = VkRenderPassBeginInfo(); + renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + renderPassBeginInfo.renderPass = renderPass; + renderPassBeginInfo.renderArea.offset.x = 0; + renderPassBeginInfo.renderArea.offset.y = 0; + renderPassBeginInfo.renderArea.extent = swapchainExtent; + renderPassBeginInfo.clearValueCount = 2; + renderPassBeginInfo.pClearValues = clearColors; + + // Simultaneous use: this command buffer can be resubmitted to a queue before a previous submission is completed + VkCommandBufferBeginInfo commandBufferBeginInfo = VkCommandBufferBeginInfo(); + commandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + commandBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; + + // Set up the command buffers for each frame in flight + for (std::size_t i = 0; i < commandBuffers.size(); i++) + { + // Begin the command buffer + if (vkBeginCommandBuffer(commandBuffers[i], &commandBufferBeginInfo) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + // Begin the renderpass + renderPassBeginInfo.framebuffer = swapchainFramebuffers[i]; + + vkCmdBeginRenderPass(commandBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); + + // Bind our graphics pipeline + vkCmdBindPipeline(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline); + + // Bind our vertex buffer + VkDeviceSize offset = 0; + + vkCmdBindVertexBuffers(commandBuffers[i], 0, 1, &vertexBuffer, &offset); + + // Bind our index buffer + vkCmdBindIndexBuffer(commandBuffers[i], indexBuffer, 0, VK_INDEX_TYPE_UINT16); + + // Bind our descriptor sets + vkCmdBindDescriptorSets(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets[i], 0, 0); + + // Draw our primitives + vkCmdDrawIndexed(commandBuffers[i], 36, 1, 0, 0, 0); + + // End the renderpass + vkCmdEndRenderPass(commandBuffers[i]); + + // End the command buffer + if (vkEndCommandBuffer(commandBuffers[i]) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + } + + // Set up the semaphores we use to synchronize frames among each other + void setupSemaphores() + { + VkSemaphoreCreateInfo semaphoreCreateInfo = VkSemaphoreCreateInfo(); + semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + + // Create a semaphore to track when an swapchain image is available for each frame in flight + for (std::size_t i = 0; i < maxFramesInFlight; i++) + { + imageAvailableSemaphores.push_back(0); + + if (vkCreateSemaphore(device, &semaphoreCreateInfo, 0, &imageAvailableSemaphores[i]) != VK_SUCCESS) + { + imageAvailableSemaphores.pop_back(); + vulkanAvailable = false; + return; + } + } + + // Create a semaphore to track when rendering is complete for each frame in flight + for (std::size_t i = 0; i < maxFramesInFlight; i++) + { + renderFinishedSemaphores.push_back(0); + + if (vkCreateSemaphore(device, &semaphoreCreateInfo, 0, &renderFinishedSemaphores[i]) != VK_SUCCESS) + { + renderFinishedSemaphores.pop_back(); + vulkanAvailable = false; + return; + } + } + } + + // Set up the fences we use to synchronize frames among each other + void setupFences() + { + // Create the fences in the signaled state + VkFenceCreateInfo fenceCreateInfo = VkFenceCreateInfo(); + fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT; + + // Create a fence to track when queue submission is complete for each frame in flight + for (std::size_t i = 0; i < maxFramesInFlight; i++) + { + fences.push_back(0); + + if (vkCreateFence(device, &fenceCreateInfo, 0, &fences[i]) != VK_SUCCESS) + { + fences.pop_back(); + vulkanAvailable = false; + return; + } + } + } + + // Update the matrices in our uniform buffer every frame + void updateUniformBuffer(float elapsed) + { + const float pi = 3.14159265359f; + + // Construct the model matrix + Matrix model = { + { 1.0f, 0.0f, 0.0f, 0.0f }, + { 0.0f, 1.0f, 0.0f, 0.0f }, + { 0.0f, 0.0f, 1.0f, 0.0f }, + { 0.0f, 0.0f, 0.0f, 1.0f } + }; + + matrixRotateX(model, elapsed * 59.0f * pi / 180.f); + matrixRotateY(model, elapsed * 83.0f * pi / 180.f); + matrixRotateZ(model, elapsed * 109.0f * pi / 180.f); + + // Translate the model based on the mouse position + sf::Vector2f mousePosition = sf::Vector2f(sf::Mouse::getPosition(window)); + sf::Vector2f windowSize = sf::Vector2f(window.getSize()); + float x = clamp( mousePosition.x * 2.f / windowSize.x - 1.f, -1.0f, 1.0f) * 2.0f; + float y = clamp(-mousePosition.y * 2.f / windowSize.y + 1.f, -1.0f, 1.0f) * 1.5f; + + model[3][0] -= x; + model[3][2] += y; + + // Construct the view matrix + const Vec3 eye = {0.0f, 4.0f, 0.0f}; + const Vec3 center = {0.0f, 0.0f, 0.0f}; + const Vec3 up = {0.0f, 0.0f, 1.0f}; + + Matrix view; + + matrixLookAt(view, eye, center, up); + + // Construct the projection matrix + const float fov = 45.0f; + const float aspect = static_cast(swapchainExtent.width) / static_cast(swapchainExtent.height); + const float nearPlane = 0.1f; + const float farPlane = 10.0f; + + Matrix projection; + + matrixPerspective(projection, fov * pi / 180.f, aspect, nearPlane, farPlane); + + char* ptr; + + // Map the current frame's uniform buffer into our address space + if (vkMapMemory(device, uniformBuffersMemory[currentFrame], 0, sizeof(Matrix) * 3, 0, reinterpret_cast(&ptr)) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + // Copy the matrix data into the current frame's uniform buffer + std::memcpy(ptr + sizeof(Matrix) * 0, model, sizeof(Matrix)); + std::memcpy(ptr + sizeof(Matrix) * 1, view, sizeof(Matrix)); + std::memcpy(ptr + sizeof(Matrix) * 2, projection, sizeof(Matrix)); + + // Unmap the buffer + vkUnmapMemory(device, uniformBuffersMemory[currentFrame]); + } + + void draw() + { + uint32_t imageIndex = 0; + + // If the objects we need to submit this frame are still pending, wait here + vkWaitForFences(device, 1, &fences[currentFrame], VK_TRUE, std::numeric_limits::max()); + + { + // Get the next image in the swapchain + VkResult result = vkAcquireNextImageKHR(device, swapchain, std::numeric_limits::max(), imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex); + + // Check if we need to re-create the swapchain (e.g. if the window was resized) + if (result == VK_ERROR_OUT_OF_DATE_KHR) + { + recreateSwapchain(); + swapchainOutOfDate = false; + return; + } + + if ((result != VK_SUCCESS) && (result != VK_TIMEOUT) && (result != VK_NOT_READY) && (result != VK_SUBOPTIMAL_KHR)) + { + vulkanAvailable = false; + return; + } + } + + // Wait for the swapchain image to be available in the color attachment stage before submitting the queue + VkPipelineStageFlags waitStages = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + + // Signal the render finished semaphore once the queue has been processed + VkSubmitInfo submitInfo = VkSubmitInfo(); + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.waitSemaphoreCount = 1; + submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame]; + submitInfo.pWaitDstStageMask = &waitStages; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffers[imageIndex]; + submitInfo.signalSemaphoreCount = 1; + submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame]; + + vkResetFences(device, 1, &fences[currentFrame]); + + if (vkQueueSubmit(queue, 1, &submitInfo, fences[currentFrame]) != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + + // Wait for rendering to complete before presenting + VkPresentInfoKHR presentInfo = VkPresentInfoKHR(); + presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; + presentInfo.waitSemaphoreCount = 1; + presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame]; + presentInfo.swapchainCount = 1; + presentInfo.pSwapchains = &swapchain; + presentInfo.pImageIndices = &imageIndex; + + { + // Queue presentation + VkResult result = vkQueuePresentKHR(queue, &presentInfo); + + // Check if we need to re-create the swapchain (e.g. if the window was resized) + if ((result == VK_ERROR_OUT_OF_DATE_KHR) || (result == VK_SUBOPTIMAL_KHR) || swapchainOutOfDate) + { + recreateSwapchain(); + swapchainOutOfDate = false; + } + else if (result != VK_SUCCESS) + { + vulkanAvailable = false; + return; + } + } + + // Make sure to use the next frame's objects next frame + currentFrame = (currentFrame + 1) % maxFramesInFlight; + } + + void run() + { + sf::Clock clock; + + // Start game loop + while (window.isOpen()) + { + // 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(); + + // Re-create the swapchain when the window is resized + if (event.type == sf::Event::Resized) + swapchainOutOfDate = true; + } + + if (vulkanAvailable) + { + // Update the uniform buffer (matrices) + updateUniformBuffer(clock.getElapsedTime().asSeconds()); + + // Render the frame + draw(); + } + } + } + +private: + sf::WindowBase window; + + bool vulkanAvailable; + + const unsigned int maxFramesInFlight; + unsigned int currentFrame; + bool swapchainOutOfDate; + + VkInstance instance; + VkDebugReportCallbackEXT debugReportCallback; + VkSurfaceKHR surface; + VkPhysicalDevice gpu; + int queueFamilyIndex; + VkDevice device; + VkQueue queue; + VkSurfaceFormatKHR swapchainFormat; + VkExtent2D swapchainExtent; + VkSwapchainKHR swapchain; + std::vector swapchainImages; + std::vector swapchainImageViews; + VkFormat depthFormat; + VkImage depthImage; + VkDeviceMemory depthImageMemory; + VkImageView depthImageView; + VkShaderModule vertexShaderModule; + VkShaderModule fragmentShaderModule; + VkPipelineShaderStageCreateInfo shaderStages[2]; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineLayout pipelineLayout; + VkRenderPass renderPass; + VkPipeline graphicsPipeline; + std::vector swapchainFramebuffers; + VkCommandPool commandPool; + VkBuffer vertexBuffer; + VkDeviceMemory vertexBufferMemory; + VkBuffer indexBuffer; + VkDeviceMemory indexBufferMemory; + std::vector uniformBuffers; + std::vector uniformBuffersMemory; + VkImage textureImage; + VkDeviceMemory textureImageMemory; + VkImageView textureImageView; + VkSampler textureSampler; + VkDescriptorPool descriptorPool; + std::vector descriptorSets; + std::vector commandBuffers; + std::vector imageAvailableSemaphores; + std::vector renderFinishedSemaphores; + std::vector fences; +}; + + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + VulkanExample example; + + example.run(); + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/examples/vulkan/resources/logo.png b/Space-Invaders/sfml/examples/vulkan/resources/logo.png new file mode 100644 index 000000000..10aa70b45 Binary files /dev/null and b/Space-Invaders/sfml/examples/vulkan/resources/logo.png differ diff --git a/Space-Invaders/sfml/examples/vulkan/resources/shader.frag b/Space-Invaders/sfml/examples/vulkan/resources/shader.frag new file mode 100644 index 000000000..7273a05a3 --- /dev/null +++ b/Space-Invaders/sfml/examples/vulkan/resources/shader.frag @@ -0,0 +1,16 @@ +#version 450 +#extension GL_ARB_separate_shader_objects : enable + +layout(binding = 1) uniform sampler2D texSampler; + +layout(location = 0) in vec4 fragColor; +layout(location = 1) in vec2 fragTexCoord; + +layout(location = 0) out vec4 outColor; + +void main() { + outColor = fragColor * texture(texSampler, fragTexCoord); + + if (outColor.a < 0.5) + discard; +} \ No newline at end of file diff --git a/Space-Invaders/sfml/examples/vulkan/resources/shader.frag.spv b/Space-Invaders/sfml/examples/vulkan/resources/shader.frag.spv new file mode 100644 index 000000000..00fd6f463 Binary files /dev/null and b/Space-Invaders/sfml/examples/vulkan/resources/shader.frag.spv differ diff --git a/Space-Invaders/sfml/examples/vulkan/resources/shader.vert b/Space-Invaders/sfml/examples/vulkan/resources/shader.vert new file mode 100644 index 000000000..1f6b00917 --- /dev/null +++ b/Space-Invaders/sfml/examples/vulkan/resources/shader.vert @@ -0,0 +1,25 @@ +#version 450 +#extension GL_ARB_separate_shader_objects : enable + +layout(binding = 0) uniform UniformBufferObject { + mat4 model; + mat4 view; + mat4 proj; +} ubo; + +layout(location = 0) in vec3 inPosition; +layout(location = 1) in vec4 inColor; +layout(location = 2) in vec2 inTexCoord; + +layout(location = 0) out vec4 fragColor; +layout(location = 1) out vec2 fragTexCoord; + +out gl_PerVertex { + vec4 gl_Position; +}; + +void main() { + gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0); + fragColor = inColor; + fragTexCoord = inTexCoord; +} \ No newline at end of file diff --git a/Space-Invaders/sfml/examples/vulkan/resources/shader.vert.spv b/Space-Invaders/sfml/examples/vulkan/resources/shader.vert.spv new file mode 100644 index 000000000..9095b6943 Binary files /dev/null and b/Space-Invaders/sfml/examples/vulkan/resources/shader.vert.spv differ diff --git a/Space-Invaders/sfml/examples/win32/Win32.cpp b/Space-Invaders/sfml/examples/win32/Win32.cpp new file mode 100644 index 000000000..9b696c2c1 --- /dev/null +++ b/Space-Invaders/sfml/examples/win32/Win32.cpp @@ -0,0 +1,136 @@ + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include + +HWND button; + + +//////////////////////////////////////////////////////////// +/// Function called whenever one of our windows receives a message +/// +//////////////////////////////////////////////////////////// +LRESULT CALLBACK onEvent(HWND handle, UINT message, WPARAM wParam, LPARAM lParam) +{ + switch (message) + { + // Quit when we close the main window + case WM_CLOSE: + { + PostQuitMessage(0); + return 0; + } + + // Quit when we click the "quit" button + case WM_COMMAND: + { + if (reinterpret_cast(lParam) == button) + { + PostQuitMessage(0); + return 0; + } + } + } + + return DefWindowProc(handle, message, wParam, lParam); +} + + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \param Instance: Instance of the application +/// +/// \return Error code +/// +//////////////////////////////////////////////////////////// +int main() +{ + HINSTANCE instance = GetModuleHandle(NULL); + + // Define a class for our main window + WNDCLASS windowClass; + windowClass.style = 0; + windowClass.lpfnWndProc = &onEvent; + windowClass.cbClsExtra = 0; + windowClass.cbWndExtra = 0; + windowClass.hInstance = instance; + windowClass.hIcon = NULL; + windowClass.hCursor = 0; + windowClass.hbrBackground = reinterpret_cast(COLOR_BACKGROUND); + windowClass.lpszMenuName = NULL; + windowClass.lpszClassName = TEXT("SFML App"); + RegisterClass(&windowClass); + + // Let's create the main window + HWND window = CreateWindow(TEXT("SFML App"), TEXT("SFML Win32"), WS_SYSMENU | WS_VISIBLE, 200, 200, 660, 520, NULL, NULL, instance, NULL); + + // Add a button for exiting + button = CreateWindow(TEXT("BUTTON"), TEXT("Quit"), WS_CHILD | WS_VISIBLE, 560, 440, 80, 40, window, NULL, instance, NULL); + + // Let's create two SFML views + HWND view1 = CreateWindow(TEXT("STATIC"), NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS, 20, 20, 300, 400, window, NULL, instance, NULL); + HWND view2 = CreateWindow(TEXT("STATIC"), NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS, 340, 20, 300, 400, window, NULL, instance, NULL); + sf::RenderWindow SFMLView1(view1); + sf::RenderWindow SFMLView2(view2); + + // Load some textures to display + sf::Texture texture1, texture2; + if (!texture1.loadFromFile("resources/image1.jpg") || !texture2.loadFromFile("resources/image2.jpg")) + return EXIT_FAILURE; + sf::Sprite sprite1(texture1); + sf::Sprite sprite2(texture2); + sprite1.setOrigin(sf::Vector2f(texture1.getSize()) / 2.f); + sprite1.setPosition(sprite1.getOrigin()); + + // Create a clock for measuring elapsed time + sf::Clock clock; + + // Loop until a WM_QUIT message is received + MSG message; + message.message = static_cast(~WM_QUIT); + while (message.message != WM_QUIT) + { + if (PeekMessage(&message, NULL, 0, 0, PM_REMOVE)) + { + // If a message was waiting in the message queue, process it + TranslateMessage(&message); + DispatchMessage(&message); + } + else + { + float time = clock.getElapsedTime().asSeconds(); + + // Clear views + SFMLView1.clear(); + SFMLView2.clear(); + + // Draw sprite 1 on view 1 + sprite1.setRotation(time * 100); + SFMLView1.draw(sprite1); + + // Draw sprite 2 on view 2 + sprite2.setPosition(std::cos(time) * 100.f, 0.f); + SFMLView2.draw(sprite2); + + // Display each view on screen + SFMLView1.display(); + SFMLView2.display(); + } + } + + // Close our SFML views before destroying the underlying window + SFMLView1.close(); + SFMLView2.close(); + + // Destroy the main window (all its child controls will be destroyed) + DestroyWindow(window); + + // Don't forget to unregister the window class + UnregisterClass(TEXT("SFML App"), instance); + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/examples/win32/resources/image1.jpg b/Space-Invaders/sfml/examples/win32/resources/image1.jpg new file mode 100644 index 000000000..8e734e2d1 Binary files /dev/null and b/Space-Invaders/sfml/examples/win32/resources/image1.jpg differ diff --git a/Space-Invaders/sfml/examples/win32/resources/image2.jpg b/Space-Invaders/sfml/examples/win32/resources/image2.jpg new file mode 100644 index 000000000..f4f7e8216 Binary files /dev/null and b/Space-Invaders/sfml/examples/win32/resources/image2.jpg differ diff --git a/Space-Invaders/sfml/examples/window/Window.cpp b/Space-Invaders/sfml/examples/window/Window.cpp new file mode 100644 index 000000000..7bdaa3999 --- /dev/null +++ b/Space-Invaders/sfml/examples/window/Window.cpp @@ -0,0 +1,176 @@ +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include + +#define GLAD_GL_IMPLEMENTATION +#include + +#ifdef SFML_SYSTEM_IOS +#include +#endif + +//////////////////////////////////////////////////////////// +/// Entry point of application +/// +/// \return Application exit code +/// +//////////////////////////////////////////////////////////// +int main() +{ + // Request a 24-bits depth buffer when creating the window + sf::ContextSettings contextSettings; + contextSettings.depthBits = 24; + + // Create the main window + sf::Window window(sf::VideoMode(640, 480), "SFML window with OpenGL", sf::Style::Default, contextSettings); + + // Make it the active window for OpenGL calls + window.setActive(); + + // Load OpenGL or OpenGL ES entry points using glad +#ifdef SFML_OPENGL_ES + gladLoadGLES1(reinterpret_cast(sf::Context::getFunction)); +#else + gladLoadGL(reinterpret_cast(sf::Context::getFunction)); +#endif + + // Set the color and depth clear values +#ifdef SFML_OPENGL_ES + glClearDepthf(1.f); +#else + glClearDepth(1.f); +#endif + glClearColor(0.f, 0.f, 0.f, 1.f); + + // Enable Z-buffer read and write + glEnable(GL_DEPTH_TEST); + glDepthMask(GL_TRUE); + + // Disable lighting and texturing + glDisable(GL_LIGHTING); + glDisable(GL_TEXTURE_2D); + + // Configure the viewport (the same size as the window) + glViewport(0, 0, static_cast(window.getSize().x), static_cast(window.getSize().y)); + + // Setup a perspective projection + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + GLfloat ratio = static_cast(window.getSize().x) / static_cast(window.getSize().y); +#ifdef SFML_OPENGL_ES + glFrustumf(-ratio, ratio, -1.f, 1.f, 1.f, 500.f); +#else + glFrustum(-ratio, ratio, -1.f, 1.f, 1.f, 500.f); +#endif + + // Define a 3D cube (6 faces made of 2 triangles composed by 3 vertices) + GLfloat cube[] = + { + // positions // colors (r, g, b, a) + -50, -50, -50, 0, 0, 1, 1, + -50, 50, -50, 0, 0, 1, 1, + -50, -50, 50, 0, 0, 1, 1, + -50, -50, 50, 0, 0, 1, 1, + -50, 50, -50, 0, 0, 1, 1, + -50, 50, 50, 0, 0, 1, 1, + + 50, -50, -50, 0, 1, 0, 1, + 50, 50, -50, 0, 1, 0, 1, + 50, -50, 50, 0, 1, 0, 1, + 50, -50, 50, 0, 1, 0, 1, + 50, 50, -50, 0, 1, 0, 1, + 50, 50, 50, 0, 1, 0, 1, + + -50, -50, -50, 1, 0, 0, 1, + 50, -50, -50, 1, 0, 0, 1, + -50, -50, 50, 1, 0, 0, 1, + -50, -50, 50, 1, 0, 0, 1, + 50, -50, -50, 1, 0, 0, 1, + 50, -50, 50, 1, 0, 0, 1, + + -50, 50, -50, 0, 1, 1, 1, + 50, 50, -50, 0, 1, 1, 1, + -50, 50, 50, 0, 1, 1, 1, + -50, 50, 50, 0, 1, 1, 1, + 50, 50, -50, 0, 1, 1, 1, + 50, 50, 50, 0, 1, 1, 1, + + -50, -50, -50, 1, 0, 1, 1, + 50, -50, -50, 1, 0, 1, 1, + -50, 50, -50, 1, 0, 1, 1, + -50, 50, -50, 1, 0, 1, 1, + 50, -50, -50, 1, 0, 1, 1, + 50, 50, -50, 1, 0, 1, 1, + + -50, -50, 50, 1, 1, 0, 1, + 50, -50, 50, 1, 1, 0, 1, + -50, 50, 50, 1, 1, 0, 1, + -50, 50, 50, 1, 1, 0, 1, + 50, -50, 50, 1, 1, 0, 1, + 50, 50, 50, 1, 1, 0, 1, + }; + + // Enable position and color vertex components + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + glVertexPointer(3, GL_FLOAT, 7 * sizeof(GLfloat), cube); + glColorPointer(4, GL_FLOAT, 7 * sizeof(GLfloat), cube + 3); + + // Disable normal and texture coordinates vertex components + glDisableClientState(GL_NORMAL_ARRAY); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + + // Create a clock for measuring the time elapsed + sf::Clock clock; + + // Start the game loop + while (window.isOpen()) + { + // 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(); + + // Resize event: adjust the viewport + if (event.type == sf::Event::Resized) + { + glViewport(0, 0, static_cast(event.size.width), static_cast(event.size.height)); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + GLfloat newRatio = static_cast(event.size.width) / static_cast(event.size.height); +#ifdef SFML_OPENGL_ES + glFrustumf(-newRatio, newRatio, -1.f, 1.f, 1.f, 500.f); +#else + glFrustum(-newRatio, newRatio, -1.f, 1.f, 1.f, 500.f); +#endif + } + } + + // Clear the color and depth buffers + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + // Apply some transformations to rotate the cube + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.f, 0.f, -200.f); + glRotatef(clock.getElapsedTime().asSeconds() * 50, 1.f, 0.f, 0.f); + glRotatef(clock.getElapsedTime().asSeconds() * 30, 0.f, 1.f, 0.f); + glRotatef(clock.getElapsedTime().asSeconds() * 90, 0.f, 0.f, 1.f); + + // Draw the cube + glDrawArrays(GL_TRIANGLES, 0, 36); + + // Finally, display the rendered frame on screen + window.display(); + } + + return EXIT_SUCCESS; +} diff --git a/Space-Invaders/sfml/include/SFML/Config.hpp b/Space-Invaders/sfml/include/SFML/Config.hpp index f4ea4ef3e..3093a7a51 100644 --- a/Space-Invaders/sfml/include/SFML/Config.hpp +++ b/Space-Invaders/sfml/include/SFML/Config.hpp @@ -31,7 +31,7 @@ //////////////////////////////////////////////////////////// #define SFML_VERSION_MAJOR 2 #define SFML_VERSION_MINOR 6 -#define SFML_VERSION_PATCH 0 +#define SFML_VERSION_PATCH 1 //////////////////////////////////////////////////////////// diff --git a/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb index 9371818c4..bbd97a4b6 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb index 9371818c4..bbd97a4b6 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb b/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb index eec00db20..e0cd93576 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb index c0bed6ba8..d187d9728 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb index c0bed6ba8..d187d9728 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb b/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb index c516163a0..310a084ae 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb index 3e17d4a22..432660dd8 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb index 3e17d4a22..432660dd8 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb index 7afce5265..446f1fb80 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb index 7afce5265..446f1fb80 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-network.pdb b/Space-Invaders/sfml/lib/Debug/sfml-network.pdb index 93ec6553c..fa073311f 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-network.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-network.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb index 2ba28522a..aa448263a 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb index 2ba28522a..aa448263a 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-system.pdb b/Space-Invaders/sfml/lib/Debug/sfml-system.pdb index 59b5195a4..ea487f4f0 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-system.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-system.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb index 4a11994b0..98a4c966e 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb index 4a11994b0..98a4c966e 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-window.pdb b/Space-Invaders/sfml/lib/Debug/sfml-window.pdb index 332a83ca4..1e2442bd4 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-window.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-window.pdb differ diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake index f8b915b60..f28497b6c 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake @@ -144,5 +144,5 @@ if (NOT SFML_FOUND) endif() if (SFML_FOUND AND NOT SFML_FIND_QUIETLY) - message(STATUS "Found SFML 2.6.0 in ${CMAKE_CURRENT_LIST_DIR}") + message(STATUS "Found SFML 2.6.1 in ${CMAKE_CURRENT_LIST_DIR}") endif() diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake index b2208ca9f..25db87605 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake @@ -9,19 +9,19 @@ # The variable CVF_VERSION must be set before calling configure_file(). -set(PACKAGE_VERSION "2.6.0") +set(PACKAGE_VERSION "2.6.1") if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) set(PACKAGE_VERSION_COMPATIBLE FALSE) else() - if("2.6.0" MATCHES "^([0-9]+)\\.") + if("2.6.1" MATCHES "^([0-9]+)\\.") set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") endif() else() - set(CVF_VERSION_MAJOR "2.6.0") + set(CVF_VERSION_MAJOR "2.6.1") endif() if(PACKAGE_FIND_VERSION_RANGE) diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake index 1c1c3c062..852e1a8d4 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake @@ -7,7 +7,7 @@ if(CMAKE_VERSION VERSION_LESS "2.8.3") message(FATAL_ERROR "CMake >= 2.8.3 required") endif() cmake_policy(PUSH) -cmake_policy(VERSION 2.8.3...3.24) +cmake_policy(VERSION 2.8.3...3.25) #---------------------------------------------------------------- # Generated CMake target import file. #---------------------------------------------------------------- diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake index 7257de655..419bb1b85 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake @@ -7,7 +7,7 @@ if(CMAKE_VERSION VERSION_LESS "2.8.3") message(FATAL_ERROR "CMake >= 2.8.3 required") endif() cmake_policy(PUSH) -cmake_policy(VERSION 2.8.3...3.24) +cmake_policy(VERSION 2.8.3...3.25) #---------------------------------------------------------------- # Generated CMake target import file. #---------------------------------------------------------------- diff --git a/Space-Invaders/sfml/license.md b/Space-Invaders/sfml/license.md new file mode 100644 index 000000000..7752b9dd1 --- /dev/null +++ b/Space-Invaders/sfml/license.md @@ -0,0 +1,21 @@ +# SFML + +SFML - Copyright (C) 2007-2023 Laurent Gomila - laurent@sfml-dev.org + +This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + +## External libraries used by SFML + + * _OpenAL-Soft_ is under the LGPL license + * _stb_image_ and _stb_image_write_ are public domain + * _freetype_ is under the FreeType license or the GPL license + * _libogg_ is under the BSD license + * _libvorbis_ is under the BSD license + * _libflac_ is under the BSD license + * _minimp3_ is under the CC0 license diff --git a/Space-Invaders/sfml/readme.md b/Space-Invaders/sfml/readme.md new file mode 100644 index 000000000..b6f9de018 --- /dev/null +++ b/Space-Invaders/sfml/readme.md @@ -0,0 +1,39 @@ +[![SFML logo](https://www.sfml-dev.org/images/logo.png)](https://www.sfml-dev.org) + +# SFML — Simple and Fast Multimedia Library + +SFML is a simple, fast, cross-platform and object-oriented multimedia API. It provides access to windowing, graphics, audio and network. It is written in C++, and has bindings for various languages such as C, .Net, Ruby, Python. + +## Authors + + - Laurent Gomila — main developer (laurent@sfml-dev.org) + - Marco Antognini — OS X developer (hiura@sfml-dev.org) + - Jonathan De Wachter — Android developer (dewachter.jonathan@gmail.com) + - Jan Haller (bromeon@sfml-dev.org) + - Stefan Schindler (tank@sfml-dev.org) + - Lukas Dürrenberger (eXpl0it3r@sfml-dev.org) + - binary1248 (binary1248@hotmail.com) + - Artur Moreira (artturmoreira@gmail.com) + - Mario Liebisch (mario@sfml-dev.org) + - And many other members of the SFML community + +## Download + +You can get the latest official release on [SFML's website](https://www.sfml-dev.org/download.php). You can also get the current development version from the [Git repository](https://github.com/SFML/SFML). + +## Install + +Follow the instructions of the [tutorials](https://www.sfml-dev.org/tutorials/), there is one for each platform/compiler that SFML supports. + +## Learn + +There are several places to learn SFML: + + * The [official tutorials](https://www.sfml-dev.org/tutorials/) + * The [online API documentation](https://www.sfml-dev.org/documentation/) + * The [community wiki](https://github.com/SFML/SFML/wiki/) + * The [community forum](https://en.sfml-dev.org/forums/) ([French](https://fr.sfml-dev.org/forums/)) + +## Contribute + +SFML is an open-source project, and it needs your help to go on growing and improving. If you want to get involved and suggest some additional features, file a bug report or submit a patch, please have a look at the [contribution guidelines](https://www.sfml-dev.org/contribute.php).