'Slow' performance - what am I doing wrong?

[hayer]

So I am trying to make SFML integrate nicely with Artemis-C++ port(Entity component system).
At the moment it is using about 0.39-0.5sec to draw a frame when drawing 713 "meshes" as a tiled background.

This is obviously something I'm doing wrong so if anyone can point me in the right direction that would be great!

Edit
Meant to press preview, not save.

I know that I am calculating the transform every frame.
/Edit

Here is my current code;

Renderer

class Renderer
{
public:
   void addToQueue(MeshCollection* mc, Transform* t) {
      m_meshCollections.push_back(mc);
      m_transforms.push_back(t);
      m_count++;
   }

   void render(sf::RenderTarget* target) {
      sf::RenderStates rs = sf::RenderStates::Default;
      sf::Transform original = rs.transform;
      clock.restart();
      for (int i = 0; i < m_count; i++) {
         rs.transform = original;
         rs.transform *= Renderer::getTransform(m_transforms);;
         target->draw(*m_meshCollections, rs);
      }
      std::cout << m_count << " mesh collections drawn in " << clock.getElapsedTime().asSeconds() << "sec" << std::endl;
         
      m_meshCollections.clear();
      m_transforms.clear();

      m_count = 0;
   }

private:
   static inline sf::Transform getTransform(Transform* t) {
      float angle = -t->rotation * 3.141592654f / 180.f;
      float cosine = static_cast<float>(std::cos(angle));
      float sine = static_cast<float>(std::sin(angle));
      float sxc = cosine;
      float syc = cosine;
      float sxs = sine;
      float sys = sine;
      float tx = -0 * sxc - 0 * sys + t->position.x;
      float ty = 0 * sxs - 0 * syc + t->position.y;

      return sf::Transform(sxc, sys, tx, -sxs, syc, ty, 0.f, 0.f, 1.f);
   }

private:
   std::vector<MeshCollection*> m_meshCollections;
   std::vector<Transform*> m_transforms;
   int m_count;
   sf::Clock clock;
};

Mesh

class Mesh
{
   friend class MeshCollection;
public:
   sf::Vector2f offset;
   sf::Texture texture;
   sf::Vector2f size;
   float rotation;

private:
   sf::Vertex m_vertices[4];
   sf::Vector2f m_origin = sf::Vector2f(0, 0);

   void updateVertices() {
      sf::Vector2u size = texture.getSize();
      m_vertices[0].position = sf::Vector2f(0.0f, 0.0f);
      m_vertices[1].position = sf::Vector2f(0, size.y);
      m_vertices[2].position = sf::Vector2f(size.x, size.y);
      m_vertices[3].position = sf::Vector2f(size.x, 0);
   }

   sf::Transform getTransform() {
      float angle = -rotation * 3.141592654f / 180.f;
      float cosine = static_cast<float>(std::cos(angle));
      float sine = static_cast<float>(std::sin(angle));
      float sxc = size.x * cosine;
      float syc = size.y * cosine;
      float sxs = size.x * sine;
      float sys = size.y * sine;
      float tx = -m_origin.x * sxc - m_origin.y * sys + offset.x;
      float ty = m_origin.x * sxs - m_origin.y * syc + offset.y;

      return sf::Transform(sxc, sys, tx, -sxs, syc, ty, 0.f, 0.f, 1.f);
   }
};

MeshCollection

class MeshCollection : public sf::Drawable
{
public:
   void add(sf::Vector2f offset, sf::Texture texture, float rotation = 0.0f, sf::Vector2f size = sf::Vector2f(1.0f, 1.0f)) {
      Mesh m;
      m.offset = offset;
      m.texture = texture;
      m.rotation = rotation;
      m.size = size;
      m.updateVertices();
      m_meshes.push_back(m);
   }

   virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const {
      // sf::Transform originalTransform = states.transform;
      for (auto m : m_meshes) {
         // states.transform = states.transform.scale(m.size).rotate(m.rotation).translate(m.offset);
         states.transform *= m.getTransform();
         states.texture = &m.texture;
         target.draw((sf::Vertex*)&m.m_vertices, 4, sf::PrimitiveType::Quads, states);
         // states.transform = originalTransform;
      }
   }

private:
   std::vector<Mesh> m_meshes;
};

Transform

class Transform : public artemis::Component
   {
   public:
      sf::Vector2f position;
      float rotation;
      // size ?

      Transform() {

      }
   };

And here is my test.

int main() {

   sf::RenderWindow window(sf::VideoMode(1024, 768), "");
   Renderer r;

   sf::Texture texture;
   texture.loadFromFile("Assets\\32x32_red.png");

   const int debugsize = 50;
   MeshCollection mcArray[debugsize * debugsize];
   Transform tArray[debugsize * debugsize];
   int c = 0;
   for (int x = 0; x < debugsize; x++)
   {
      for (int y = 0; y < debugsize; y++)
      {
         MeshCollection m;
         m.add(sf::Vector2f(0, 0), texture);
         mcArray[c] = m;
         tArray[c].position = sf::Vector2f(x * 32, y * 32);
         tArray[c].rotation = 0.0f;
         c++;
      }
   }


   while (window.isOpen())
   {
      sf::Event event;
      while (window.pollEvent(event))
      {
         if (event.type == sf::Event::Closed || sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
            window.close();
      }

      window.clear(sf::Color::Black);
      
      int c = 0;
      for (int x = 0; x < debugsize; x++)
      {
         for (int y = 0; y < debugsize; y++)
         {
            if (tArray[c].position.x > 0 && tArray[c].position.x < 1024 &&
               tArray[c].position.y > 0 && tArray[c].position.y < 768)
               r.addToQueue(&mcArray[c], &tArray[c]);

            c++;
         }
      }
      /*
      for (int i = 0; i < debugsize * debugsize; i++)
      {
         
         r.addToQueue(&mcArray, &tArray);
      }
      */
      r.render(&window);

      window.display();
   }

   return 0;
}

[kingcools]

have you used valgrind to profile your code?
did you use releasemode?
have you turned your debugger off?
are all optimizations turned on in your compiler?

what is this loop doing:

for (int x = 0; x < debugsize; x++)
   {
      for (int y = 0; y < debugsize; y++)
      {
         MeshCollection m;
         m.add(sf::Vector2f(0, 0), texture);
         mcArray[c] = m;
         tArray[c].position = sf::Vector2f(x * 32, y * 32);
         tArray[c].rotation = 0.0f;
         c++;
      }
   }

the add() method probably forces the internal vector to reallocate memory every single time you are using the function which is rather slow.
your code looks rather akward, why do you add new elements on each run that on first sight never seem to change? lots and lots of wasted performance.

[hayer]

have you used valgrind to profile your code?
did you use releasemode?
have you turned your debugger off?
are all optimizations turned on in your compiler?

what is this loop doing:

for (int x = 0; x < debugsize; x++)
   {
      for (int y = 0; y < debugsize; y++)
      {
         MeshCollection m;
         m.add(sf::Vector2f(0, 0), texture);
         mcArray[c] = m;
         tArray[c].position = sf::Vector2f(x * 32, y * 32);
         tArray[c].rotation = 0.0f;
         c++;
      }
   }

the add() method probably forces the internal vector to reallocate memory every single time you are using the function which is rather slow.
your code looks rather akward, why do you add new elements on each run that on first sight never seem to change? lots and lots of wasted performance.

¨

The code is ran once for creating a array of objects to draw. Can see how that will impact performance anything more than long load time?

No profiling yet.

Release mode, no debuggers attached. Yes, artemis and SFML was compiled in release mode with /O2.



Edit:
After a quick session with the VS2013 performance analyzer it seems that Renderer::render is the snail.. Pointing to this line; "target->draw(*m_meshCollections, rs);" -- any tips on how to optimize that?


Edit2:
@kingcools: My respons to you might seem a bit offsense. That was not intended, sorry. Thanks for a fast reply

[Laurent]

MeshCollection.add copies the texture argument. Then you copy it again when you store it inside the Mesh. That's a terrible idea, especially since it's all the same texture data in the end. And it would not only help to improve the loading time, but also the drawing performances because you would not make OpenGL switch to a different texture at every draw call.

[hayer]

MeshCollection.add copies the texture argument. Then you copy it again when you store it inside the Mesh. That's a terrible idea, especially since it's all the same texture data in the end. And it would not only help to improve the loading time, but also the drawing performances because you would not make OpenGL switch to a different texture at every draw call.

So I should implement some sort of resources loader  that will;

1. User askes for "Assets\32x32_red.png"
2a. If not loaded, load it
2b. Its loaded, do nothing
3. Return a shared pointer to it

?

[kingcools]

The code is ran once for creating a array of objects to draw. Can see how that will impact performance anything more than long load time?

my bad, i thought it was the loop inside your renderloop because those two look similiar due to the "< debugsize" condition^^

well, i second laurent

[Nexus]

@hayer: Or simply pass a reference to the texture and make sure that it remains alive while it's used.

The other use case you're talking about can also be meaningful, but you should have a good reasons, because things are a bit more complicated. I've written a resource module in Thor for exactly such situations, so you don't have to write it yourself. thor::ResourceCache allows you to load resources on-demand, automatically recognizing if a resource has already been loaded and if it's not used anymore, everything through shared ownership.

[hayer]

Jeez, Nexus.. I was looking at Thor and was about to edit my post with; "Or I could grab Thor and use that. Well, guess I'll try out Thor then.

The main reason I asked was because I don't know how well the transformations should be handled. Like, I can figure it out, but I'm not always sure I get it a 100 per-cent correct.

Well, I guess I'll try looking at resource caching and see if that improves performance.


Thank you all for fast and very useful replies 




Edit: Just for testing; changed the sf::Texture to sf::Texture* in the Mesh class.. Now it uses 0.0002 sec per frame, in debug. Btw; how is SFML for drawing on a terminal server to clients? Like Windows Server 2008? I suddenly got the idea of implementing a renderer for work that uses SFML and the other one uses.. GDI+   

[Nexus]

As Laurent mentioned, the reason for your bad performance are the texture copies. You can easily solve that by thinking about ownership and passing references or pointers instead of copies.

Resource management systems like the one in Thor have a different purpose: to have a centralized place where resources are stored and accessed, and to do the boilerplate work (checking whether resource is already loaded, handling and reporting errors appropriately, cleaning up automatically, etc.). thor::ResourceCache comes with some complexity and requires you to use shared pointers, so it may not be ideal for every situation.

Sometimes, something more lightweight like the ResourceHolder class we made for the SFML book is more appropriate. By the way, this class is likely to be part of a future version of Thor.