|
glRotatef(74.38, 28.48, 82.74, 129.9) glColor3f(74.38, 28.48, 82.74) glTranslatef(74.38, 28.48, 82.74) glLoadIdentity() glEnd() glBegin(GL_TRIANGLES) glBlendFunc(GL_DST_COLOR, GL_ZERO) | 2.116780 1.245937 1.233421 0.988515 0.986884 0.923384 0.156373 |
The rotate function takes the most processing power as you would expect since it's the only function listed that does any calculations. The next two do some calculations but either shifting or initializing so not as much time is used. glLoadIdentity loads a matrix so it will take time and the glEnd/glBegin functions pretty much start/end the rendering state. glBlendFunc just sets the blending state so does not use up as much time.
Even though these calls may be seem slow such as glRotatef - it's usually faster using the hardware accelerated functions on the graphics card then writing your own functions. Since the cards specific goal is graphics, it can spit out the values quicker than a general processor like the CPU. This is the same with buffering, clipping, culling, etc.
for loop while loop if (x == y) | 0.432281 0.311844 0.316098 |
Here the while loop and the two if statements take around the same time. The for loop takes longer which is likely due to the creation of the loop itself (assigning the values and incrementing of the loop) and then the comparisons thereafter. To optimize, the best advice is just to make sure whatever is in the loop is really needed.
Test_1(float, float, ..., float) Test_2(&float3, &float3) | 0.339573 0.153631 |
Test_1 has 6 float functions passed, whereas Test_2 has only two addresses of float3 (which is just .x .y .z - three floats). Test_1 does take longer since it has two create the copy when passed and then delete it when returning. Creating a copy may be good if you want to make sure nothing is being overwritten since any value changed in Test_2 will remain changed. This though as shown above will take longer, which can be further shown by this class with the constructor, destructor and the copy constructor which copies the passed variables.
class Test_Copy {public:
Test_Copy::Test_Copy() {}
Test_Copy::~Test_Copy() { printf("Exiting\n"); }
Test_Copy::Test_Copy(const Test_Copy& rhs) { printf("Copying\n"); }
float3 data;
};
Then by calling the function Test_3(Test_Copy tmp_1, Test_Copy tmp_2) {} the following is printed to the screen:
Copying
Copying
Exiting
Exiting
Even though nothing is done in the function, it still has to create the copy and then destroy it. If we would have called Test_4(Test_Copy *tmp_1, Test_Copy *tmp_2) {} and just pass the pointers, no copy will have to be made and later destroyed. Also take into account the structure itself - an address to any structure will still only be the address but if a whole animation class is copied - every variable within the class is also brought with it and copied.