Il existe plusieurs classes d'utilitaires dans libGDX. Est-ce vraiment pratique? .. .. Je voudrais le résumer car c'est beaucoup, y compris le sondage.
1.9.5
com.balogic.gdx.utils
Pour le moment, je résumerai le système Utils.
Il effectue des conversions liées à la virgule flottante conformément à la norme IEEE 754. C'est proche d'un alias pour les méthodes statiques de Double et Float. J'ai essayé de le toucher, mais il semble difficile à utiliser. Il est utilisé dans la classe com.badlogic.gdx.graphics.Color.
Pour plus de détails, je pense qu'il est préférable de regarder le javadoc de Float et Double.
https://docs.oracle.com/javase/jp/8/docs/api/java/lang/Float.html https://docs.oracle.com/javase/jp/6/api/java/lang/Double.html#doubleToLongBits(double)
TimeUtils est une classe utilitaire pour la manipulation du temps de base. Si vous souhaitez implémenter instantanément une opération de temps commune, il semble préférable de l'implémenter après avoir vu la méthode de cette classe.
// System.currentTimeMillis()Pareil que
System.out.println("milliseconde: " + TimeUtils.millis()); // milliseconde: 1484574498965
//Convertir des millisecondes en nanosecondes
System.out.println("Convertir des millisecondes en nanosecondes: " + TimeUtils.millisToNanos(TimeUtils.millis())); // Convertir des millisecondes en nanosecondes: 1484574498965000000
//Convertir des nanosecondes en millisecondes
System.out.println("Convertir des nanosecondes en millisecondes: " + TimeUtils.nanosToMillis(TimeUtils.millisToNanos(TimeUtils.millis()))); // Convertir des nanosecondes en millisecondes: 1484574498965
//Temps écoulé depuis l'argument(milliseconde)
System.out.println("2011/12/5 11:Temps écoulé à partir de 11 (millisecondes)" + TimeUtils.timeSinceMillis(TimeUtils.nanosToMillis(LocalDateTime.of(2011, 12, 5, 11, 11).getNano()))); // 2011/12/5 11:Temps écoulé à partir de 11 (millisecondes)1484574498976
//Temps écoulé depuis l'argument(Nano secondes)
System.out.println("2011/12/5 11:Temps écoulé à partir de 11 (nanosecondes)" + TimeUtils.timeSinceNanos(LocalDateTime.of(2011, 12, 5, 11, 11).getNano())); // 2011/12/5 11:Temps écoulé à partir de 11 (nanosecondes)872694705378791
PropertiesUtils est un Util qui charge les informations de l'instance de Reader au format clé = valeur et les convertit en Map. Vous pouvez facilement le charger avec des informations dans le fichier de propriétés.
hoge.properties
hoge=fuga
piyo=piyo
age=28
ObjectMap<String, String> map = new ObjectMap<>();
PropertiesUtils.load(map, new FileReader(Gdx.files.internal("hoge.properties").file()));
map.forEach(System.out::println);
Résultat de sortie
piyo=piyo
hoge=fuga
age=28
ScreenUtils est une classe utilitaire qui utilise principalement des tampons d'image pour le traitement d'image.
Qu'est-ce que Farmbuffer?
A framebuffer (frame buffer, or sometimes framestore) is a portion of RAM containing a bitmap that is used to refresh a video display from a memory buffer containing a complete frame of data.
https://en.wikipedia.org/wiki/Framebuffer
Donc, si vous l'interprétez correctement, je pense que vous devriez y penser comme la zone de mémoire des informations de dessin du cadre!
//octet le tampon de trame par défaut[]Revenez avec. La longueur du tableau est la largeur de l'écran* height * 4。
byte[] bytes = ScreenUtils.getFrameBufferPixels(true);
//Lit la position spécifiée dans le tampon d'image et renvoie Pixmap
int x = 0;
int y = 0;
int width = 0;
int height = 0;
Pixmap pixmap = ScreenUtils.getFrameBufferPixmap(x, y, width, height);
//Générer une texture à partir du tampon de trame
TextureRegion region = ScreenUtils.getFrameBufferTexture();
Cette classe ne fonctionne que sur le moteur libGDX. Nullpo se produira s'il n'y a pas de source d'acquisition car il acquiert simplement les informations en cours.
BufferUtils est une classe utilitaire de traitement qui utilise la zone tampon, et ses principales méthodes sont la copie et la transformation. Des surcharges des méthodes de copie et de transformation pour divers types de données de tampon sont fournies. Il existe également une méthode d'usine. (BufferUtils.newByteBuffer etc.)
//Méthode d'usine
ByteBuffer src = BufferUtils.newByteBuffer(1024);
ByteBuffer dest = BufferUtils.newByteBuffer(1024);
//copie
BufferUtils.copy(src, dest, 1024);
Je l'ai essayé, mais cela ne fonctionne que sur le moteur libGDX. Par exemple, si vous essayez simplement de l'exécuter à partir de la méthode principale, une erreur se produira autour de BufferUtils.copy. Regarder la trace de la pile java.lang.UnsatisfiedLinkError: com.badlogic.gdx.utils.BufferUtils.copyJni(Ljava/nio/Buffer;ILjava/nio/Buffer;II)V ... Apparemment ...
Cette classe n'a actuellement que des méthodes yield à partir de 1.9.5, et cette implémentation Je ne pense pas qu'il y ait une scène d'utilisation car elle n'appelle que le rendement de java.lang.Thread. Au contraire, il est difficile de juger de la scène d'utilisation.
Selon javadoc dans java.lang.Thread https://docs.oracle.com/javase/jp/8/docs/api/java/lang/Thread.html
public static void yield() Un indice pour le planificateur que le thread actuel est prêt à générer l'utilisation actuelle du processeur. Le planificateur peut ignorer cette indication. Les concessions sont une tentative heuristique pour améliorer la progression relative entre les threads qui utiliseraient normalement le CPU. Lorsque vous l'utilisez, vous devez également combiner des profils détaillés et des repères pour vous assurer que vous obtenez réellement l'effet souhaité.
Il existe de rares occasions d'utiliser cette méthode. Cela peut être utile à des fins de débogage et de test (cela peut être utile pour reproduire des bogues dus à des conditions de conflit). Cela peut également être utile lors de la conception de composants de contrôle simultanés, tels que ceux du package java.util.concurrent.locks.
La méthode yield semble effectuer un appel natif et notifier le planificateur.
StreamUtils n'est pas une API Stream, mais une classe utilitaire pour manipuler l'interface Stream pour les E / S de fichiers.
Path tmpFile = Files.createTempFile(Paths.get("").toAbsolutePath(), "tmp", "file");
tmpFile.toFile().deleteOnExit();
StreamUtils.copyStream(Gdx.files.internal("hoge.properties").read(), new FileOutputStream(tmpFile.getFileName().toString()));
InputStream is = Gdx.files.internal("hoge.properties").read();
//Convertir en chaîne
String streamToString = StreamUtils.copyStreamToString(is);
System.out.println("streamToString" + streamToString);
//fermer le processus
StreamUtils.closeQuietly(is);
closeQuietly est également dans IOUtils d'Apache Commons. S'il s'agit de Java SE 7 ou version ultérieure, il ne sera pas très actif car il y a des try-with-resources, mais avant cela, c'est gentil de réduire la description du traitement redondant de fermeture.
Il semble que TimeUtils, PropertiesUtils et StreamUtils puissent être utilisés immédiatement. A part cela, les couches utilisées sont limitées, ou il semble qu'elle ne soit pas utilisée dans l'implémentation client.
Cette fois, j'ai limité mes recherches à XXXUtils, mais com.balogic.gdx.utils Il existe différents services tels que com.balogic.gdx.utils.async, API de collection, Json, opération XML, API de formatage de texte, etc., donc je pense que je vais essayer de les résumer si j'en ai envie dans un autre article. ..
Recommended Posts