Android Programjaim

Android, Flutter/Dart, Kotlin, Java, Unity, HarmonyOS

Android List performance test

2011. december 30. 10:24 - lacas8282

  1.                                 PerformanceTimer timer=new PerformanceTimer();
  2.                                 timer.start();
  3.                                
  4.                                 final int n=10000;
  5.                                
  6.                                 List<String> alist=new ArrayList<String>(n);
  7.                                 for (int i=0; i<n; i++) {
  8.                                         alist.add("asd");
  9.                                 }
  10.                                 timer.getValue("ArrayList " +n+" items took ");
  11.                                
  12.                                 timer.start();
  13.                                 List<String> blist=new LinkedList<String>();
  14.                                 for (int i=0; i<n; i++) {
  15.                                         blist.add("asd");
  16.                                 }
  17.                                 timer.getValue("LinkedList " +n+" items took ");
  18.                                
  19.  
  20.                                 timer.start();
  21.                                 String[] clist=new String[n];
  22.                                 for (int i=0; i<n; i++) {
  23.                                         clist[i]="asd";
  24.                                 }
  25.                                 timer.getValue("Array " +n+" items took ");
  26.  
  27.  
  28. //eredmények
  29.  
  30. 12-30 10:17:20.433: E/PerformanceTimer(2069): 3 ms : ArrayList 1000 items took
  31. 12-30 10:17:20.433: E/PerformanceTimer(2069): 1 ms : LinkedList 1000 items took
  32. 12-30 10:17:20.433: E/PerformanceTimer(2069): 0 ms : Array 1000 items took
  33.  
  34. 12-30 10:16:29.683: E/PerformanceTimer(1999): 2 ms : ArrayList 10000 items took
  35. 12-30 10:16:29.703: E/PerformanceTimer(1999): 19 ms : LinkedList 10000 items took
  36. 12-30 10:16:29.707: E/PerformanceTimer(1999): 0 ms : Array 10000 items took
  37.  
  38. 12-30 10:17:54.152: E/PerformanceTimer(2106): 34 ms : ArrayList 100000 items took
  39. 12-30 10:17:54.437: E/PerformanceTimer(2106): 286 ms : LinkedList 100000 items took
  40. 12-30 10:17:54.507: E/PerformanceTimer(2106): 66 ms : Array 100000 items took
Android/Java hangsúlyozom: samu galaxy s1

ArrayList, LinkedList vagy a sima Array a gyorsabb?

Végeredményben:

nagyon randomak az eredmények:

összeségében nagyobb elemszámokra a fixed ArrayList teljesít jobban, utána jön az Array
kisebb elemszámokra általában az Array gyorsabb bár néha az ArrayList kerekedik sebességben felül.

 

komment

Parser, parser, parser - keyframe animation opengl-es

2011. december 22. 13:27 - lacas8282

Az engine bővült!!!

-normálisabb/gyorsabb .obj parser
-.3ds parser
-.md2 parser (animációk)

Tervek:
-esetleg md3, md5 parser
-esetleg egy ASE parser
-egy csontváz alapú file parser
-egy MS3D bináris parser

Tapasztalatok:
-.3ds file betöltése kicsivel gyorsabb, mint a .obj-é, és 2-szer annyi vertex van benne, mint obj-ban ugyanakkora méretben (3-4-szeres gyorsulás néha)
-.3ds file is tartalmaz elvileg keyframe animation-t
-.obj file nem tartalmaz semmilyen animációt, és text alapú, tehát lassú
-.md2 file (köszi Carmack) egész gyorsan betölt viszonylag sok animációs fázis
 --viszont: memóriahegyeket zabál, a folyamatos interpolációk miatt
 
UPDATE: videó!



Egy kis leírás a keyframe alapú animációkról (.3ds, .md2, stb)

Hogy működik kb.?
1, parse
-Az animátor/modellező letárol keyframe-eket, a megadott mozgásokból.
-ebből ugye lesz egy vertex array, egy normal array (vagy mi számítjuk ki), és textcoord array
-a szokásos parse után, felvesszük a frame-eket (hány db van?), majd a vertex arrayeket, normal arrayeket, és a textcoordokat, a face-eket
-a face-ek alapján sorrendbe állítjuk a koordinátákat, textcoordokat, normálokat

2, fps, frame-ek
-beállítunk egy fps-t, ha ez az érték nagyon kicsi akkor az interpoláció lassabban hajtódik végre, azaz lassabb mozgatás lesz az eredmény: (Matrix lassítás effect)
-ha ez az érték magas, akkor gyors lesz a mozgatás

-beállíthatjuk, hogy melyik legyen a kezdő frame, és a vég frame, ilyenkor ezek között végez a program interpolációt

példa: setState("walk", 20, 1, 10);

// ilyenkor létrehozunk a keyframe-ekből egy olyan frame groupot, amit "walk" néven nevezünk el. a 20= fps , az 1 a kezdő frame, a 10 pedig a vég frame

Ez esetben lehet, hogy a fileunkban van 200 frame is, de a többit figyelmen kívűl hagyjuk.

3, folyamatos interpoláció/rajzolás
Röviden:

A keyframe-ek tárolják az adott időpillanatban a vertexeket (egy statikus mozgásállapotot), ebből kell nekünk folyamatos *draw update alatt kiszámolnunk interpolációval a köztes rétegeket.

Azaz: az 1. és a 2. frame között pl lehet nekünk az interpoláció miatt az fps miatt 100 fázisunk. Ez annyit takar, hogy a mostani keyframe és a következő keyframe között számolunk vertexeket, és normalokat. A textúra koordináták ugyanazok maradnak!

Röviden ennyi!

Végszó:
-Sok memóriát zabál ez a fajta animáció, nem véletlen nem alkalmazzák olyan helyen, ahol számít! Inkább a bone/skeleton animációt használják ott, és az dinamikusabb is, mint ez a fajta animáció. Ezért csínján ezzel!

BOLDOG KARÁCSONYT GYEREKEK!

UI.: legközelebb egy kis csontváz animációról írok. Ez már keményebb lesz, mint az eddigiek.

komment

Helyzetjelentés 8.0? OpenGL ES kedvencek

2011. december 16. 15:23 - lacas8282

Végre megjöttek az én kis könyveim, így használatukkal végre tovább tudok haladni a kis 3d engine-em írásával. A 2 könyv nagyon frankó, az elsőből azért sok új dolgot ténylegesen nem tanultam, de kezdőknek elég jó ez is. Van benne 2D android programozás/full játék source code-okkal, gyakorlatilag a libgdx-re épül az egész. Kis 3D és openGL azért ebben is van, igaz a több része 2D-s játékfejlesztés. A második könyv: opengl ES 2.0 na ez már elsőre kicsit bonyolultabb részeket is tartalmaz egy olyannak, aki eddig még csak az 1.0-1.1-el játszadozott. Viszont ebből is sok érdekes dolgot ki lehet ragadni, nem kell feltétlen 2.0-ra fejlesztenünk ehhez. Az első könyv sok segítséget ad a játékok írásának elkezdéséhez, illetve az optimalizáláshoz is. Ennek köszönhetően pár dolgot módosítottam is a "lacroix3d" engine-emen. Igen ez lett a neve végülis. (mind3d engine nevéből vettem, tartalmaz min3d elemeket, de libgdx elemeket is maga az engine minimális szinten. ) Végre működik az alphatest is, a modell betöltés elég gyors (már amennyire ez az lehet androidban /a JNI-s C-s parser írásával egyelőre felhagytam/ )

komment
süti beállítások módosítása