1st gen iPods

I'm making a game that focuses on visuals. Personally I think it looks great, but at a cost. 1st gen iPod runs a little choppy on some levels. I know you can choose what devices can buy you're app but is the 1st gen still a big part of the market? Or is it worth it to release it to all devices? Just wondering.

Thanks,
-Mike Berger

 

I just got a 1st gen iPhone to test my game on, and it gets choppy at times but is still playable. Then I downloaded some other 3d games from the app store, and they were all choppy. Many of the games were still playable, but some were absolutely not.

I would say if your game is playable on a 1st gen, then go ahead and release it for 1st gen. I don't think people who have a 1st gen iPhone are going to complain about it being a little choppy, since that will be their experience with any graphically intense game on the app store.

I have no idea how big the market for 1st gen iphones is though, it would be great to know. At least we know its getting smaller (relative to the later models)

 

I bought a 1st gen iPod Touch as well to be able to test my games on it... and I am affraid that any Unity game on it may be choppy...

For example, for our new game, we installed a really early beta: just player (no animations), terrain and controls, with less than 2000 triangles in total and 4 textures: the framerate drops sometimes to 20. So we don't expect the game to run smooth on it.

 

Yeah, I've been using my iPod 1st gen from back in the day when they new and the coolest thing ever, ha. Because testing on a 3gs only got me into trouble before.

The problems i am having is just in two scenes, is there a way to detect what device it is and maybe I can shut off some lights on the 1st gen because it gets veryyy slow.

Thanks,
-Mike

 

iPhoneSettings.generation returns an enumerated value of what type of iDevice it's running on.

 

I use this code to get different result depending of the device version.

Code (csharp):

1.  
2. //device gen check
3.  
4.     if( iPhoneSettings.generation == iPhoneGeneration.iPhone )
5. {
6.     //Its a first generation iPhone
7.        
8.    
9. }
10. else if( iPhoneSettings.generation == iPhoneGeneration.iPhone3G )
11. {
12.     //Its a second generation iPhone
13.        
14. }
15. else if( iPhoneSettings.generation == iPhoneGeneration.iPhone3GS )
16. {
17.     //Its a third generation iPhone
18.        
19. }
20. else if( iPhoneSettings.generation == iPhoneGeneration.iPodTouch1Gen )
21. {
22.     //Its an iPod Touch, first generation
23.    
24. }
25. else if( iPhoneSettings.generation == iPhoneGeneration.iPodTouch2Gen )
26. {
27.     //Its an iPod Touch, second generation
28.         ;
29. }
30. else if( iPhoneSettings.generation == iPhoneGeneration.iPodTouch3Gen )
31. {
32.     //Its an iPod Touch, third generation
33.        
34. }
35. else
36. {
37.     //Unknown device or are you in the editor?
38.        
39. }
40.  

 

if you prefer cleaner structured code, switch( iPhoneSettings.generation) is your friend

 

I've been doing a lot of generation specific optimations lately while getting ready for the release of the iPad. I've been using this script to have different texture resolutions for different device generations:

Code (csharp):

1.  
2. #pragma strict
3.  
4. // This script makes use of Resources.Load(...) and expects a preset folder structure:
5. //
6. // Resources/
7. //          Textures/
8. //                  32/
9. //                  64/
10. //                  128/
11. //                  256/
12. //                  512/
13. //                  1024/
14. //                  2048/
15. //                  4096/
16. //
17. // Your textures should be placed in the proper folder and their 'path' should be given
18. // based name or location under the resolution folder.
19. //
20. // Example Paths:
21. //     Resources/Textures/512/glass -> glass
22. //     Resources/Textures/128/decals/sticker -> decals/sticker
23. //
24. // The generation setting trickle down. This means that you dont have to set all of them,
25. // you only need to set the first one and any others you want to override. The rest of them
26. // will inherit their setting from the generation before.
27.  
28. enum TextureResolutions {None, _32_, _64_, _128_, _256_, _512_, _1024_, _2048_, _4096_} // Can't have numbers in an enum?
29. private var TextureResolutionStrings : String[] = ["None", "32", "64", "128", "256", "512", "1024", "2048", "4096"];
30.  
31. // Order based on speed
32. var iPhoneResolution : TextureResolutions = TextureResolutions._512_;
33. var iPodTouch1GenResolution : TextureResolutions;
34. var iPhone3gResolution : TextureResolutions;
35. var iPodTouch2GenResolution : TextureResolutions;
36. var iPhone3gsResolution : TextureResolutions;
37. var iPodTouch3GenResolution : TextureResolutions;
38. var iPadResolution : TextureResolutions;
39.  
40. var path : String;
41. var property : String = "_MainTex";
42. var sharedMaterial : boolean;
43. var dontDestroyMaterialOnLoad : boolean;
44.  
45. var unitySimulatedAs : iPhoneGeneration = iPhoneGeneration.iPhone3GS;
46.  
47. private var material : Material;
48. private var texture : Texture;
49. private var generation : iPhoneGeneration;
50. private var basepath : String = "Textures"; // Change this if your folder structure is different
51. private var resourcepath : String;
52.  
53. function Start(){
54.     // Auto-fill the generations based on their previous generation
55.     if( iPhoneResolution == TextureResolutions.None ){
56.         Debug.LogError("You need to at least set the resolution for iPhone");
57.     }
58.     if( iPodTouch1GenResolution == TextureResolutions.None ){
59.         iPodTouch1GenResolution = iPhoneResolution;
60.     }
61.     if( iPhone3gResolution == TextureResolutions.None ){
62.         iPhone3gResolution = iPodTouch1GenResolution;
63.     }
64.     if( iPodTouch2GenResolution == TextureResolutions.None ){
65.         iPodTouch2GenResolution = iPhone3gResolution;
66.     }
67.     if( iPhone3gsResolution == TextureResolutions.None ){
68.         iPhone3gsResolution = iPodTouch2GenResolution;
69.     }
70.     if( iPodTouch3GenResolution == TextureResolutions.None ){
71.         iPodTouch3GenResolution = iPhone3gsResolution;
72.     }
73.     if( iPadResolution == TextureResolutions.None ){
74.         iPadResolution = iPodTouch3GenResolution;
75.     }
76. }
77.  
78. function Update(){
79.     // Since some renderers are created at runtime, we need to
80.     // check for the renderer in the update loop and when we find
81.     // it set the texture and then disable ourselves
82.     if(renderer  path.length){
83.         if(sharedMaterial){
84.             material = renderer.sharedMaterial;
85.         } else {
86.             // This makes a new copy of the material
87.             material = renderer.material;
88.            
89.             // Which won't follow the don't destroy on load set
90.             // by any other script before it
91.             if(dontDestroyMaterialOnLoad){
92.                 DontDestroyOnLoad(material);
93.             }
94.         }
95.        
96.         // Grab the generation
97.         generation = iPhoneSettings.generation;
98.        
99.         // Since we are going to be testing this script inside unity
100.         // we need a way to override the given unknown generation
101.         if(generation == iPhoneGeneration.Unknown){
102.             generation = unitySimulatedAs;
103.         }
104.        
105.         // Now create a full path to the texture based on the generation
106.         switch(generation){
107.             case iPhoneGeneration.iPodTouch1Gen:
108.                 resourcepath = basepath + "/" + TextureResolutionStrings[iPodTouch1GenResolution] + "/" + path;
109.                 break;
110.             case iPhoneGeneration.iPodTouch2Gen:
111.                 resourcepath = basepath + "/" + TextureResolutionStrings[iPodTouch2GenResolution] + "/" + path;
112.                 break;
113.             case iPhoneGeneration.iPodTouch3Gen:
114.                 resourcepath = basepath + "/" + TextureResolutionStrings[iPodTouch3GenResolution] + "/" + path;
115.                 break;
116.             case iPhoneGeneration.iPhone:
117.                 resourcepath = basepath + "/" + TextureResolutionStrings[iPhoneResolution] + "/" + path;
118.                 break;
119.             case iPhoneGeneration.iPhone3G:
120.                 resourcepath = basepath + "/" + TextureResolutionStrings[iPhone3gResolution] + "/" + path;
121.                 break;
122.             case iPhoneGeneration.iPhone3GS:
123.                 resourcepath = basepath + "/" + TextureResolutionStrings[iPhone3gsResolution] + "/" + path;
124.                 break;
125.             // Support for ipad when it comes
126.             //case iPhoneGeneration.iPad:
127.                 //path = basepath + "/" + TextureResolutionStrings[iPadResolution] + "/" + path;
128.                 //break;
129.         }
130.        
131.        
132.         // Load the texture
133.         texture = Resources.Load(resourcepath, Texture2D);
134.         if(texture){
135.             // Set the texture
136.             material.SetTexture(property, texture);
137.         }else{
138.             Debug.LogError("Could not load the texture at the given path: " + gameObject.name + " - " + path + " - Check your 'Resources' folder and try again.");
139.         }
140.        
141.         // Make sure to shut this script off so we don't keep running
142.         enabled = false;
143.     }
144. }
145.  

This code requires you to have multiple versions of your textures in different folders, but allows you to have them load at runtime. Doing it this way give you the ability to say that an ipod 1st gen gets lower textures resolutions than other devices.

 

Wow, thanks guys! My game doesn't use textures so much but still really cool! You think that could be used on lower poly models? That'd be cool. I have been downloading 3d apps on my 1st gen and a lot of them do run a little choppy. I'm just gonna find whats slowing down these two scenes and probably use the detection code to delete it or something.

 

steamrollerstudios thank you for this nice piece of code.

I am wondering if lowering texture size will really help, since GL Benchmark say "same performance for all texture sizes". I still have my dubts about those benchs...

discussion:
http://forum.unity3d.com/viewtopic.php?t=37515&highlight=interesting

benchmark:
http://www.glbenchmark.com/phonedetails.jsp?benchmark=glpro11&D=Apple iPhone 2G&testgroup=lowlevel

 

@bergerbytes

Yeah it should be pretty easy to modify what i have done for texture but for meshes. I have did a quick conversion but have not really tested it in my game yet.

MeshGenerationController.js

Code (csharp):

1.  
2. #pragma strict
3.  
4. // This script makes use of Resources.Load(...) and expects a preset folder structure:
5. //
6. // Resources/
7. //          Meshes/
8. //                  Low/
9. //                  Medium/
10. //                  High/
11. //
12. // Your meshes should be placed in the proper folder and their 'path' should be given
13. // based name or location under the resolution folder.
14. //
15. // Example Paths:
16. //     Resources/Meshes/low/glass -> glass
17. //     Resources/Meshes/high/decals/sticker -> decals/sticker
18. //
19. // The generation setting trickle down. This means that you dont have to set all of them,
20. // you only need to set the first one and any others you want to override. The rest of them
21. // will inherit their setting from the generation before.
22.  
23. enum MeshResolutions {None, Low, Medium, High}
24. private var MeshResolutionStrings : String[] = ["None", "Low", "Medium", "High"];
25.  
26. // Order based on speed
27. var iPhoneResolution : MeshResolutions = MeshResolutions.Medium;
28. var iPodTouch1GenResolution : MeshResolutions;
29. var iPhone3gResolution : MeshResolutions;
30. var iPodTouch2GenResolution : MeshResolutions;
31. var iPhone3gsResolution : MeshResolutions;
32. var iPodTouch3GenResolution : MeshResolutions;
33. var iPadResolution : MeshResolutions;
34.  
35. var path : String;
36.  
37. var unitySimulatedAs : iPhoneGeneration = iPhoneGeneration.iPhone3GS;
38.  
39. private var meshFilter : MeshFilter;
40. private var mesh : Mesh;
41. private var generation : iPhoneGeneration;
42. private var basepath : String = "Meshes"; // Change this if your folder structure is different
43. private var resourcepath : String;
44.  
45. function Start(){
46.     // Auto-fill the generations based on their previous generation
47.     if( iPhoneResolution == MeshResolutions.None ){
48.         Debug.LogError("You need to at least set the resolution for iPhone");
49.     }
50.     if( iPodTouch1GenResolution == MeshResolutions.None ){
51.         iPodTouch1GenResolution = iPhoneResolution;
52.     }
53.     if( iPhone3gResolution == MeshResolutions.None ){
54.         iPhone3gResolution = iPodTouch1GenResolution;
55.     }
56.     if( iPodTouch2GenResolution == MeshResolutions.None ){
57.         iPodTouch2GenResolution = iPhone3gResolution;
58.     }
59.     if( iPhone3gsResolution == MeshResolutions.None ){
60.         iPhone3gsResolution = iPodTouch2GenResolution;
61.     }
62.     if( iPodTouch3GenResolution == MeshResolutions.None ){
63.         iPodTouch3GenResolution = iPhone3gsResolution;
64.     }
65.     if( iPadResolution == MeshResolutions.None ){
66.         iPadResolution = iPodTouch3GenResolution;
67.     }
68. }
69.  
70. function Update(){
71.     // Since some meshFilters are created at runtime, we need to
72.     // check for the meshFilter in the update loop and when we find
73.     // it set the mesh and then disable ourselves
74.     if(path.length){
75.         meshFilter = GetComponent(MeshFilter);
76.         if(meshFilter){
77.             // Grab the generation
78.             generation = iPhoneSettings.generation;
79.        
80.             // Since we are going to be testing this script inside unity
81.             // we need a way to override the given unknown generation
82.             if(generation == iPhoneGeneration.Unknown){
83.                 generation = unitySimulatedAs;
84.             }
85.        
86.             // Now create a full path to the mesh based on the generation
87.             switch(generation){
88.                 case iPhoneGeneration.iPodTouch1Gen:
89.                     resourcepath = basepath + "/" + MeshResolutionStrings[iPodTouch1GenResolution] + "/" + path;
90.                     break;
91.                 case iPhoneGeneration.iPodTouch2Gen:
92.                     resourcepath = basepath + "/" + MeshResolutionStrings[iPodTouch2GenResolution] + "/" + path;
93.                     break;
94.                 case iPhoneGeneration.iPodTouch3Gen:
95.                     resourcepath = basepath + "/" + MeshResolutionStrings[iPodTouch3GenResolution] + "/" + path;
96.                     break;
97.                 case iPhoneGeneration.iPhone:
98.                     resourcepath = basepath + "/" + MeshResolutionStrings[iPhoneResolution] + "/" + path;
99.                     break;
100.                 case iPhoneGeneration.iPhone3G:
101.                     resourcepath = basepath + "/" + MeshResolutionStrings[iPhone3gResolution] + "/" + path;
102.                     break;
103.                 case iPhoneGeneration.iPhone3GS:
104.                     resourcepath = basepath + "/" + MeshResolutionStrings[iPhone3gsResolution] + "/" + path;
105.                     break;
106.                 // Support for ipad when it comes
107.                 //case iPhoneGeneration.iPad:
108.                     //path = basepath + "/" + MeshResolutionStrings[iPadResolution] + "/" + path;
109.                     //break;
110.             }
111.        
112.        
113.             // Load the mesh
114.             mesh = Resources.Load(resourcepath, Mesh);
115.             if(mesh){
116.                 // Set the mesh
117.                 meshFilter.mesh = mesh;
118.             }else{
119.                 Debug.LogError("Could not load the mesh at the given path: " + gameObject.name + " - " + path + " - Check your 'Resources' folder and try again.");
120.             }
121.        
122.             // Make sure to shut this script off so we don't keep running
123.             enabled = false;
124.         }  
125.     }
126. }
127.  

I've only added support here for "High", "Medium", and "Low" but if you edit those two variables at the beginning you should be able to define your own way of splitting it up.


@moctezumagames
I don't really know the benchmarks but i can definitely see the difference in framerate when adding a bunch of 1024 textures verse a bunch of 512 textures.

 

I just did a test.

I have a scene with 6 helicopters, 2 helix animated and a terrain.
Each helicopter with his own texture vertex lit material, terrain with a lightmapped material with 2 textures, so no batching here.
The bench is made with no interaction with physics etc. Only rendertime.


First test:

6 copters with 512x512 texture 4bit compression
terrain 1024x1024 lightmap and 512 color map
the helix material is showing to difference on tests, so we ignore it.
The framerate shown in the iPod first gen is >29 .

Profiler:

iPhone Unity internal profiler stats:
cpu-player> min: 10.0 max: 18.8 avg: 14.9
cpu-ogles-drv> min: 5.7 max: 11.4 avg: 7.7
cpu-present> min: 1.4 max: 2.7 avg: 1.6
frametime> min: 32.3 max: 45.5 avg: 33.9
draw-call #> min: 9 max: 9 avg: 9 | batched: 2
tris #> min: 8955 max: 8955 avg: 8955 | batched: 68
verts #> min: 4568 max: 4568 avg: 4568 | batched: 48
player-detail> physx: 1.2 animation: 0.2 culling 0.2 skinning: 0.0 batching: 0.1 render: 10.6 fixed-update-count: 3 .. 4
mono-scripts> update: 0.5 fixedUpdate: 1.6 coroutines: 0.0
mono-memory> used heap: 356352 allocated heap: 356352 max number of collections: 0 collection total duration: 0.0





Second test:

6 copters with 64x64 texture 4bit compression
terrain 128x128 lightmap 2 bit and 512 color map 4 bit
the helix material is showing to difference on tests, so we ignore it.
The framerate shown in the iPod first gen is >29 a well

Profiler:


iPhone Unity internal profiler stats:
cpu-player> min: 11.8 max: 20.9 avg: 16.0
cpu-ogles-drv> min: 4.4 max: 9.8 avg: 6.5
cpu-present> min: 1.4 max: 3.7 avg: 1.9
frametime> min: 31.3 max: 43.0 avg: 33.8
draw-call #> min: 9 max: 9 avg: 9 | batched: 2
tris #> min: 8955 max: 8955 avg: 8955 | batched: 68
verts #> min: 4568 max: 4568 avg: 4568 | batched: 48
player-detail> physx: 1.4 animation: 0.3 culling 0.2 skinning: 0.0 batching: 0.1 render: 11.2 fixed-update-count: 3 .. 5
mono-scripts> update: 0.5 fixedUpdate: 1.9 coroutines: 0.0
mono-memory> used heap: 299008 allocated heap: 356352 max number of collections: 0 collection total duration: 0.0

I hardly see difference... I will try a crazy test with more stuff...

 

Last try:
with trilinear filtering and max anisotropic with no mip maps in all textures

6 copters with 512x512 texture 4bit compression.
terrain 1024x1024 lightmap and 512 color map 4 bit compression.
the helix material is showing to difference on tests, so we ignore it.
The framerate shown in the iPod first gen is >29, but with some drops to 27.

Profiler:

iPhone Unity internal profiler stats:
cpu-player> min: 9.6 max: 24.9 avg: 15.6
cpu-ogles-drv> min: 4.3 max: 9.7 avg: 6.8
cpu-present> min: 1.5 max: 3.7 avg: 1.9
frametime> min: 31.3 max: 76.5 avg: 35.0
draw-call #> min: 9 max: 9 avg: 9 | batched: 2
tris #> min: 8955 max: 8955 avg: 8955 | batched: 68
verts #> min: 4568 max: 4568 avg: 4568 | batched: 48
player-detail> physx: 1.4 animation: 0.3 culling 0.3 skinning: 0.0 batching: 0.1 render: 10.9 fixed-update-count: 3 .. 8
mono-scripts> update: 0.5 fixedUpdate: 1.7 coroutines: 0.0
mono-memory> used heap: 294912 allocated heap: 356352 max number of collections: 0 collection total duration: 0.0


I guess only 7 textures and no gameplay can't make suffer the iPhone because the GPU is powerful enough to manage this. May be the CPU what causes slow downs, unless you have 30 textures ingame... should I try this?

 

Added 2 more terrains, with a different 1024x1024 4 bit compression each one, in multitexture.
I enabled the controls as well, and there is a 64x64 4bit texture joystick to move around with the copters, so there are some physics running on now.

Now we see a drop, iPod displays 25 FPS with this Profiler:

iPhone Unity internal profiler stats:
cpu-player> min: 17.2 max: 27.1 avg: 22.5
cpu-ogles-drv> min: 6.2 max: 12.5 avg: 8.9
cpu-present> min: 1.9 max: 3.8 avg: 2.1
frametime> min: 33.4 max: 91.1 avg: 40.1
draw-call #> min: 12 max: 12 avg: 12 | batched: 2
tris #> min: 13379 max: 13379 avg: 13379 | batched: 68
verts #> min: 5936 max: 5936 avg: 5936 | batched: 48
player-detail> physx: 3.3 animation: 0.3 culling 0.3 skinning: 0.0 batching: 0.1 render: 12.3 fixed-update-count: 3 .. 9
mono-scripts> update: 2.1 fixedUpdate: 3.2 coroutines: 0.0
mono-memory> used heap: 331776 allocated heap: 356352 max number of collections: 0 collection total duration: 0.0

So I managed to get 5 FPS down the main 30 with:

6000 verts and 13000 triangles
3x 1024 textures 4 bit with no mipmaps and trilinear + anisotropic
7x 512 textures 4 bit with no mipmaps and trilinear + anisotropic
and 2 x 64 4 bit for the helix and the joystick

My conclusion is that the GPU is hard to stress, but the CPU is what makes iPod touch and old devices to be choppy sometimes.

 

That would be 0 then, because there is no anisotropic filtering on the iphone. Trilinear is the max.


And at 13k triangles you will likely not get that many differences on the first gen devices as you already have hit the whole triangle budget. basically it already runs at its worst, thats why your frametime on avery is below 30fps and at worst below 10fps

 

hum, true, the chip does not support anisotropic ¬¬

but the discussion here was textures, not so much triangles...

 

Thats true.
But you won't get much of a performance gain if the gpu is being swamped by the geometry and triangle rasterization. With a less taxing test environment, the direct impact of the texture size reduction could be measured as the texture would be have more than 1% performance impact.

That being said: the difference is primary of VRAM usage nature as long as you are able to use the batches usefull and don't have massive textures primarily (in which case the texture swap would become taxing)

 

well, my aim was to realize how much performance you get from decreasing the texture size from 512 to 64.
And what I met has been that from GPU performance point of view, iPod 1st Gen can manage more than I expected. A said, the problem may be more CPU stress than GPU stress...

but I may be wrong, and my benches be wrongly chosen. Those are of course very synthetic, they don't show how games run on it, just how much graphical power can be juiced from them.

 

Within given borders, but the rendering is also on 13ms at min

That depends on the interpretation.
If its all taken just numerically you are right.
But the problem is that the setup forces that much stress on the cpu that the actual thing we are interested in has no performance impact because the cpu wastes 10ms+ more per frame than the gpu on rendering. A barebone benchmark that just tests the direct impact would potentially give more information. Or at least a game that is more optimized on the code end than this. That being said: if it works it works, nobody cares about the numbers then

 

thank you for bringing some light :wink: