My 3D engine relies on using al_draw_indexed_prim to draw the 3D models in my scene, but I have found that there is a severe performance bottleneck with this method. While my actual production code is immensely more complex, this simple example should demonstrate how I typically (and probably not ideally) use the pipeline:
In this example, I am drawing 10,000 "Models". Each model is just a 3-vertex triangle and is drawn through al_draw_indexed_prim. (You'll have to hard crash the running program yourself)
#SelectExpand
1
2
3#include <allegro5/allegro.h>
4#include <allegro5/allegro_primitives.h>
5
6#include <vector>
7
8
9
10float random_float
(float min,
float max
)
11{
12 return ((float) rand()/RAND_MAX
)*(max-min
) + min
;
13}
14
15
16// note: uncomment the commented lines of
17// code in this class to include the random
18// placement of objects (through ALLEGRO_TRANSFORM).
19
20class Model
21{
22public:
23 ALLEGRO_VERTEX vertex
[3];
24 //ALLEGRO_TRANSFORM placement;
25 Model
()
26 {
27 vertex
[0].x
= 0;
28 vertex
[0].y
= 0;
29 vertex
[0].z
= 0;
30 vertex
[0].color
= al_map_rgb(255,
255,
128);
31
32 vertex
[1].x
= 100;
33 vertex
[1].y
= 100;
34 vertex
[1].z
= 0;
35 vertex
[1].color
= al_map_rgb(128,
255,
255);
36
37 vertex
[2].x
= 100;
38 vertex
[2].y
= 0;
39 vertex
[2].z
= 0;
40 vertex
[2].color
= al_map_rgb(255,
128,
255);
41
42 //al_identity_transform(&placement);
43 //al_scale_transform(&placement, random_float(0.2, 1.5), random_float(0.2, 1.5));
44 //al_rotate_transform(&placement, random_float(0, 1));
45 //al_translate_transform(&placement, random_float(0, 800), random_float(0, 500));
46 }
47 void draw
()
48 {
49 int indices
[] = { 0,
1,
2 };
50
51 //ALLEGRO_STATE previous_state;
52 //al_store_state(&previous_state, ALLEGRO_STATE_TRANSFORM);
53
54 //al_use_transform(&placement);
55 al_draw_indexed_prim(&vertex
[0], NULL, NULL, indices,
3, ALLEGRO_PRIM_TRIANGLE_LIST
);
56
57 //al_restore_state(&previous_state);
58 }
59};
60
61
62
63
64int main
(int argc,
char *argv
[])
65{
66 al_init();
67 al_init_primitives_addon();
68 srand(time(NULL
));
69
70 ALLEGRO_DISPLAY *disp
= al_create_display(800,
500);
71
72 bool done
= false;
73 bool strobe
= false;
74
75 // create the models
76
77 std::vector
<Model> models
;
78 for (unsigned i
=0; i
<10000; i
++) // in this example, draw 10000 triangles
79 {
80 Model model
;
81 models.push_back
(model
);
82 }
83
84 // do the loop
85
86 while(!done
)
87 {
88 al_clear_to_color(al_map_rgb(0,
64,
0));
89
90 for (unsigned i
=0; i
<models.size
(); i
++)
91 models
[i
].draw
();
92
93 // a strobing circle, will alternate on/off between frames
94 // to demonstrate drawing speed
95 if (strobe
) al_draw_filled_circle(20,
20,
8,
al_map_rgb(255,
255,
255));
96 strobe
= !strobe
;
97
98 al_flip_display();
99 }
100}
In my real code, each model is more complex, is projected in 3D, and has textures.
Now, in the example program above, I am drawing 10,000 models with 3 vertexes each, so, 30,000 vertexes each loop. It's my understanding that a cheap modern graphics card can push ~500 million vertexes in a second, so what gives? Why is there already such a substantial lag at 30,000 vertexes? What should I be doing instead?
Here are some pretty screenshots:
example program from above (with transforms on)
{"name":"609131","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/d\/9\/d9d57232f36a88503323c2a0e5d79c20.png","w":819,"h":548,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/d\/9\/d9d57232f36a88503323c2a0e5d79c20"}
example from production (already laggy):
{"name":"609130","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/5\/8\/580f4973b673ba83e5acb7b75d2a48b3.png","w":1276,"h":711,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/5\/8\/580f4973b673ba83e5acb7b75d2a48b3"}
]]>
