Défilement du fond de parallaxe, répété à l'infini dans libgdx

Je suis en train de faire un all 2D tireur de l'espace type de jeu, où j'ai besoin d'un arrière-plan que vous pouvez faire défiler infintely (il est en carrelage ou enveloppé à plusieurs reprises). Je tiens également à mettre en œuvre la parallaxe défilement, donc peut-être avoir un plus bas fond de la nébuleuse de la texture qui bouge presque pas, plus un contenant de loin étoiles qui bouge presque pas et le plus élevé de fond contenant des étoiles proches qui se déplace beaucoup.

Je vois de google que j'avais chaque couche de déplacer 50% de moins que la couche au-dessus, mais comment puis-je mettre en libgdx? J'ai un Appareil photo qui peut être agrandie dans et à l'extérieur, et dans la physique d'écran 800x480 pourrait montrer quoi que ce soit à partir de 128x128 pixels (d'un navire) à une vaste zone de l'espace mettant en vedette les textures enroulé plusieurs fois sur leurs bords.

Comment puis-je continuellement envelopper une petite texture (dire 512x512) comme si elle était infiniment carrelé (lorsque l'appareil photo est à droite), et puis, comment puis-je disposer de plusieurs textures comme le ces, gardez-les ensemble dans une structure adaptée (est-il un dans le libgdx api?) et les déplacer comme le joueur coords changement? J'ai regardé la documentation javadoc et les exemples, mais ne peut pas trouver quelque chose comme ce problème, toutes mes excuses si c'est évident!

source d'informationauteur fundead

3

Je n'ai pas beaucoup plus à dire au sujet de la Parallaxe Défilement de PFG déjà fait. Il est en effet un exemple dans le référentiel, sous le dossier test et plusieurs explications à travers le web. J'ai aimé cette une.
De la question avec l'arrière-plan est vraiment facile à résoudre. Cela et d'autres problèmes connexes peut être abordé en utilisant modulaire de l'algèbre. Je n'entrerai pas dans les détails car une fois montré est très facile à comprendre.

Imaginez que vous voulez afficher une boussole dans votre écran. Vous avez une texture 1024x16 représentant les points cardinaux. Fondamentalement, tout ce que vous avez est une bande. Laissant de côté les considérations sur le réel de l'orientation et de ces, vous devez vous rendre.

Votre fenêtre est 300x400 par exemple, et que vous voulez 200px de la texture sur l'écran (pour le rendre plus intéressant). Vous pouvez la rendre parfaitement avec une seule région jusqu'à ce que vous atteignez la position (1024-200) = 824. Une fois que vous êtes dans cette position, clairement il n'y a plus de texture. Mais puisque c'est une boussole, il est évident qu'une fois que vous atteignez la fin de celui-ci, il a recommencer. C'est donc la réponse. Une autre texture de la région fera l'affaire. La gamme 825-1023 doit être représentée par une autre région. La deuxième région aura une taille de (1024-pos) pour chaque valeur de pos - >824 && pos<1024

Ce code est destiné à fonctionner comme un exemple réel d'une boussole. C'est très sale car il fonctionne avec des positions relatives de tous les temps en raison de la conversion entre la plage (0-3.6) à (0-1024).
```
spriteBatch.begin();
    if (compassorientation<0)
        compassorientation = (float) (3.6 - compassorientation%3.6);
    else
        compassorientation = (float) (compassorientation %  3.6);
    if ( compassorientation < ((float)(1024-200)/1024*3.6)){
        compass1.setRegion((int)(compassorientation/3.6*1024), 0, 200, 16);
        spriteBatch.draw(compass1, 0, (Gdx.graphics.getHeight()/2) -(-250 + compass1.getTexture().getHeight()* (float)1.2), Gdx.graphics.getWidth(), 32 * (float)1.2);

    }
    else if (compassorientation > ((float)(1024-200)/1024*3.6)) {
        compass1.setRegion((int)(compassorientation/3.6*1024), 0, 1024 - (int)(compassorientation/3.6*1024), 16);
        spriteBatch.draw(compass1, 0, (Gdx.graphics.getHeight()/2) -(-250 + compass1.getTexture().getHeight()* (float)1.2), compass1.getRegionWidth()/200f * Gdx.graphics.getWidth() , 32 * (float)1.2);
        compass2.setRegion(0, 0, 200 - compass1.getRegionWidth(), 16);
        spriteBatch.draw(compass2, compass1.getRegionWidth()/200f * Gdx.graphics.getWidth() , (Gdx.graphics.getHeight()/2) -(-250 + compass1.getTexture().getHeight()* (float)1.2), Gdx.graphics.getWidth() - (compass1.getRegionWidth()/200f * Gdx.graphics.getWidth())  , 32 * (float)1.2);
    } 


    spriteBatch.end();
```
10

Hey, je suis aussi un parrallax de fond et essayer de l'obtenir pour les faire défiler.

Il y a un ParallaxTest.java dans le référentiel, il peut être trouvé ici.

ce fichier est une classe autonome, de sorte que vous devez intégrer dans votre jeu, la façon dont vous le souhaitez. et vous aurez besoin de changer l'entrée de commande depuis son accroché à l'utilisation de l'écran tactile ou de la souris.

cela a fonctionné pour moi. que de répéter les bg, je n'ai pas eu encore là, mais je pense que vous avez juste besoin de la logique de base, comme, ok, un écran loin de la fin, de modifier les premiers écrans d'encaissement à la ligne jusqu'à la fin.

Vous pouvez utiliser setWrap fonction comme ci-dessous:

Texture texture = new Texture(Gdx.files.internal("images/background.png"));
texture.setWrap(Texture.TextureWrap.Repeat, Texture.TextureWrap.Repeat);

Il tirera de fond à plusieurs reprises! Espérons que cette aide!

1

Dessous où vous initialisez votre Texture de l'objet. Ensuite, en-dessous de ce type dans ce
```
YourTexture.setWrap(Texture.TextureWrap.Repeat, Texture.TextureWrap.Repeat);
```
Où YourTexture est la texture que vous voulez de parallaxe défilement.

Dans Votre rendu type de fichier dans le présent code.
```
batch.draw(YourTexture,0, 0, 0 , srcy, Gdx.graphics.getWidth(),     
           Gdx.graphics.getHeight());  
srcy +=10;
```
Il va vous donner une erreur donc, faire une variable appelée srcy. Il n'en est rien, trop de fantaisie.
```
Int srcy
```

Vous devez vous connecter pour publier un commentaire.