Resolusi Kemandirian dalam libGDX

22

Bagaimana cara membuat resolusi / kepadatan game libGDX saya mandiri? Apakah ada cara untuk menentukan ukuran gambar sebagai "mutlak" tanpa memperhatikan kepadatan yang mendasarinya?

Saya membuat permainan anak-anak yang sangat sederhana; hanya sekelompok sprite yang ditampilkan di layar, dan beberapa teks untuk menu (terutama menu opsi). Yang ingin saya ketahui adalah: bagaimana cara membuat resolusi sprite / font saya independen? (Saya telah membungkus mereka di kelas saya sendiri untuk membuat semuanya lebih mudah.)

Karena ini adalah permainan anak-anak yang sederhana, saya tidak perlu khawatir tentang "area yang bisa dimainkan" dari permainan; Saya ingin menggunakan ruang layar sebanyak mungkin.

Apa yang saya lakukan saat ini, yang tampaknya sangat salah, adalah membuat gambar yang cocok untuk resolusi besar, dan kemudian menurunkan (atau jarang, naik) agar sesuai dengan ukuran layar. Ini tampaknya berfungsi baik (dalam versi desktop), bahkan dengan pemetaan linear pada tekstur saya, tetapi resolusi yang lebih kecil terlihat jelek.

Juga, ini tampaknya terbang di hadapan "piksel independen perangkat" (DP) Android. Atau mungkin saya kehilangan sesuatu dan libGDX sudah menangani ini?

Apa cara terbaik untuk mengatasi ini? Saya menemukan tautan ini; apakah ini cara yang baik untuk menyelesaikan masalah ?: http://www.dandeliongamestudio.com/2011/09/12/android-fragmentation-density-independent-pixel-dip/

Ini menyebutkan cara mengontrol gambar, tetapi tidak menyebutkan cara menentukan ukuran font / gambar tanpa memperhatikan kepadatan.

ashes999
sumber
Mungkin terkait? gamedev.stackexchange.com/questions/34/…
thedaian
@thedaian tidak cukup. Itu tentang resolusi; Saya lebih peduli tentang interaksi antara kepadatan dan resolusi.
ashes999

Jawaban:

12

Karena Anda dapat membaca kerapatan perangkat dan merender font selama runtime di libgdx, saya menggunakan solusi ini untuk mencapai ukuran font yang independen kepadatan:

float densityIndependentSize = origFontSize * Gdx.graphics.getDensity();
int fontSize = Math.round(densityIndependentSize );
BitmapFont font = generator.generateFont(fontSize );
Pascalius
sumber
Diskusi saya adalah tentang gambar dan juga font. +1 untuk rendering font dinamis (saya sudah melakukannya).
ashes999
10

Untuk mencapai ini di libgdx, Anda dapat menggunakan "orthographicCamera" di sana Anda menentukan ukuran yang ingin Anda gunakan, dan dalam setiap resolusi Anda dapat melihat semua gambar Anda diskalakan ke ukuran itu (saya menggunakan 800X480 karena layarnya lebih besar di Android ) dan itu bekerja dengan baik :)

public class GameStage extends Stage 
{ 
     public GameStage(float width, float height, boolean stretch) 
     { 
          this.camera = new OrthographicCamera(800, 480);
          this.camera.position.set(800/2, 480/2, 0f); 
     } 
}
Rudy_TM
sumber
Bisakah saya mendapatkan sampel kode?
ashes999
Itulah kode, dan Anda membuat kelas yang mengimplementasikan antarmuka layar, di konstruktor Anda membangun panggung Anda, dan dalam metode render, Anda meletakkan stage.draw (). Jika Anda tidak ingin menggunakan Tahapan, Anda dapat mendeklarasikan variabel di kelas yang diimplementasikan layar jenis Kamera, dan melakukan hal yang sama seperti di Panggung, tetapi dalam metode render Anda menerapkan pembaruan ke kamera.
Rudy_TM
Ini sebenarnya bekerja cukup baik.
you786
4

Saya percaya "piksel independen perangkat" Android hanya merupakan tolok ukur untuk mengklasifikasikan perangkat, dan sebenarnya tidak tersedia sebagai piksel yang dapat di render. Jadi Anda tidak ketinggalan infrastruktur penyelesaian DPI ajaib. Sejauh yang saya mengerti keadaan seni di sini, Anda telah menemukan semua opsi. Ada dua pendekatan dasar untuk berurusan dengan perangkat yang berbeda:

  1. Skala gambar yang sudah ada sebelumnya agar sesuai dengan DPI perangkat yang sebenarnya.
  2. Pilih dari berbagai gambar yang telah diskalakan pada saat dijalankan berdasarkan DPI.

Tentu saja, Anda dapat melakukan campuran keduanya (memilih gambar yang kira-kira akurat dan kemudian menskalanya), atau menggunakan pendekatan berbeda untuk berbagai elemen UI Anda (misalnya, gambar yang sudah ada sebelumnya untuk font / teks, dan penskalaan dinamis untuk gameplay sprite).

Apa yang coba dilakukan permainan spesifik Anda dapat benar-benar membuat perbedaan di mana pendekatan lebih masuk akal. Misalnya, jika Anda memiliki menu di layar, Anda ingin memastikan bahwa tombolnya merupakan kelipatan yang masuk akal dari ukuran ujung jari (sehingga tombol selalu mudah dipukul, tetapi tidak lebih besar dari yang diperlukan pada perangkat besar seperti tablet). Sebagai alternatif, jika Anda mencoba membuat permainan puzzle di mana Anda ingin memastikan seluruh puzzle terlihat secara bersamaan, Anda perlu mengukur elemen-elemen agar sesuai di layar (misalnya, dengan tic-tac-toe) game mungkin Anda ingin setiap elemen menggunakan sekitar 1/3 layar).

Saya pikir untuk hal-hal seperti font yang memiliki banyak detail halus Anda pasti ingin memiliki berbagai gambar yang telah dirender dengan teks, dan kemudian memilih yang paling cocok. Jadi tombol mungkin mengubah bentuk / ukuran relatifnya dari satu perangkat ke perangkat lainnya, tetapi umumnya akan selalu terlihat bagus.

Lihat Permulaan Game Android Mario Zerchner untuk diskusi tentang masalah dan beberapa solusi. Perhatikan bahwa Mario adalah penulis libGDX, jadi pendekatan buku ini mencerminkan libGDX satu (perhatikan bahwa mereka bukan satu-ke-satu, buku ini mencakup penulisan perpustakaan yang mirip dengan libGDX, tetapi bukan libGDX itu sendiri).

PT
sumber
Bahkan jika saya memilih dari koleksi gambar pra-dibuat berdasarkan DPI, saya tidak melihat bagaimana saya dapat menjamin bahwa "sprite ini HARUS ditampilkan sebagai 64x64."
ashes999
1
Saya berasumsi Anda mengatur kamera OpenGL Anda agar sesuai dengan tampilan fisik, jadi 1 piksel OpenGL memetakan menjadi 1 piksel tampilan. Pada saat itu gambar 64x64 akan muncul sebagai 64x64 di layar. Seperti yang ditunjukkan Rudy_TM, Anda dapat mengacaukan pemetaan kamera untuk mendapatkan penskalaan seluruh layar.
PT
Oke, ini seperti "saus rahasia" yang saya kejar. Saya akan memeriksa dan memberi tahu Anda, terima kasih.
ashes999
0

Salah satu cara untuk melakukannya adalah menentukan rasio aspek minimum dan rasio aspek maksimum untuk gim Anda. Ini akan menjadi rasio yang ingin Anda dukung. Maka Anda perlu menggunakan Viewport yang sekarang disediakan di libGdx. Area pandang akan menskalakan dunia Anda sesuai dengan pengaturan yang Anda berikan.

Ada beberapa jenis viewports dan Anda harus memilih salah satu yang paling sesuai untuk gim Anda.

Anda dapat menggunakan ExtendViewport misalnya dan memperbaiki tinggi atau lebar Anda dan menghitung yang lain. Maka Anda perlu memastikan bahwa semua gambar dapat dilihat dalam rasio aspek minimum Anda. Memperluas viewport akan menskala grafik Anda ke rasio aspek yang benar tanpa merusak gambar. Namun ExtendViewport bekerja dengan menambahkan ruang tambahan ke dunia Anda sehingga Anda juga harus menyediakan gambar untuk latar belakang misalnya yang mencakup seluruh perluasan rasio aspek yang dicakup, ketika dunia lebih kecil dari rasio aspek maksimum Anda, bagian tambahan dari gambar tidak akan ditampilkan.

dilom
sumber