Supposons que vous ayez une scène composée d'un monde , d'un joueur et d'un boss. Oh, et c'est un jeu à la troisième personne, vous avez donc aussi un appareil photo .
Votre scène ressemble donc à ceci:
class Scene {
World* world
Player* player
Enemy* boss
Camera* camera
}
(Au moins, ce sont les données de base . La façon dont vous contenez les données dépend de vous.)
Vous ne voulez mettre à jour et rendre la scène que lorsque vous jouez au jeu, pas en pause ou dans le menu principal ... donc vous l'attachez à l'état du jeu!
State* gameState = new State();
gameState->addScene(scene);
Maintenant, votre état de jeu a une scène. Ensuite, vous voulez exécuter la logique sur la scène et rendre la scène. Pour la logique, vous exécutez simplement une fonction de mise à jour.
State::update(double delta) {
scene->update(delta);
}
De cette façon, vous pouvez conserver toute la logique du jeu dans la Sceneclasse. Et juste à titre de référence, un système de composants d'entité pourrait le faire comme ceci à la place:
State::update(double delta) {
physicsSystem->applyPhysics(scene);
}
Quoi qu'il en soit, vous avez maintenant réussi à mettre à jour votre scène. Maintenant, vous voulez l'afficher! Pour lequel nous faisons quelque chose de similaire à ce qui précède:
State::render() {
renderSystem->render(scene);
}
Voilà. Le renderSystem lit les informations de la scène et affiche l'image appropriée. Simplifiée, la méthode de rendu de la scène pourrait ressembler à ceci:
RenderSystem::renderScene(Scene* scene) {
Camera* camera = scene->camera;
lookAt(camera); // Set up the appropriate viewing matrices based on
// the camera location and direction
renderHeightmap(scene->getWorld()->getHeightMap()); // Just as an example, you might
// use a height map as your world
// representation.
renderModel(scene->getPlayer()->getType()); // getType() will return, for example "orc"
// or "human"
renderModel(scene->getBoss()->getType());
}
Vraiment simplifié, vous auriez encore besoin, par exemple, d'appliquer une rotation et une traduction en fonction de l'endroit où se trouve votre joueur et où il regarde. (Mon exemple est un jeu en 3D, si vous optez pour la 2D, ce sera une promenade dans le parc).
J'espère que c'est ce que vous cherchiez? Comme vous pouvez vous en souvenir avec ce qui précède, le système de rendu ne se soucie pas de la logique du jeu . Il utilise uniquement l'état actuel de la scène pour le rendu, c'est-à-dire qu'il en extrait les informations nécessaires pour le rendu. Et la logique du jeu? Peu importe ce que fait le moteur de rendu. Heck, il ne se soucie pas du tout s'il est affiché!
Et vous n'avez pas non plus besoin d'attacher d'informations de rendu à la scène. Il devrait suffire que le moteur de rendu sache qu'il doit rendre un orc. Vous aurez déjà chargé un modèle orc, que le moteur de rendu sait alors afficher.
Cela devrait répondre à vos besoins. La représentation graphique et la logique sont couplées , car elles utilisent toutes deux les mêmes données. Pourtant, ils sont séparés , car aucun ne dépend de l'autre!
EDIT: Et juste pour répondre pourquoi on le ferait comme ça? Parce que c'est plus facile est la raison la plus simple. Vous n'avez pas besoin de penser à "tel ou tel est arrivé, je devrais maintenant mettre à jour les graphiques". Au lieu de cela, vous faites bouger les choses et chaque image du jeu examine ce qui se passe actuellement et l'interprète d'une manière ou d'une autre, vous donnant un résultat à l'écran.
