Development/Tutorials/Graphics/Performance - Revision history

Neverendingo: Text replace - "" to ""

2011-06-29T20:51:47Z

Text replace - "</code>" to "</syntaxhighlight>"

Neverendingo: Text replace - "`" to ""`


2011-06-29T20:29:00Z
Text replace - "<code cppqt>" to "<syntaxhighlight lang="cpp-qt">"

				
				
				
				
			
			← Older revision
			Revision as of 20:29, 29 June 2011
			
Line 40:
Line 40:
  a line, a rectangle etc., the easiest and also the fastest solution is to just change the alpha value of the color you're using, like this:   a line, a rectangle etc., the easiest and also the fastest solution is to just change the alpha value of the color you're using, like this:
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QColor c = color;   QColor c = color;
  c.setAlphaF(c.alphaF() * opacity);   c.setAlphaF(c.alphaF() * opacity);
Line 50:
Line 50:
  on it with normal opacity. When you're done drawing on it, use the DestinationIn composition mode to reduce the alpha of the pixmap, and then draw the pixmap itself where you want the semi-transparent contents. If you need the same content again (for example when you're doing a fade out or fade in animation), it might pay off to cache the fully opaque version.   on it with normal opacity. When you're done drawing on it, use the DestinationIn composition mode to reduce the alpha of the pixmap, and then draw the pixmap itself where you want the semi-transparent contents. If you need the same content again (for example when you're doing a fade out or fade in animation), it might pay off to cache the fully opaque version.
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QPixmap pixmap(size);   QPixmap pixmap(size);
  pixmap.fill(Qt::transparent);   pixmap.fill(Qt::transparent);
Line 99:
Line 99:
  and copy the content of the original pixmap into it, like this:   and copy the content of the original pixmap into it, like this:
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QPixmap temp(pixmap.size());   QPixmap temp(pixmap.size());
  temp.fill(Qt::transparent);   temp.fill(Qt::transparent);



Tampakrap: Add a section about drawLine()
2008-09-05T18:25:25Z
Add a section about drawLine()

				
				
				
				
			
			← Older revision
			Revision as of 18:25, 5 September 2008
			
Line 69:
Line 69:
  painter->paintEngine()->hasFeature(QPaintEngine::ConstantOpacity),   painter->paintEngine()->hasFeature(QPaintEngine::ConstantOpacity),
  but my recommendation is to avoid it completely since it won't   but my recommendation is to avoid it completely since it won't
− be fast on our main platform with the current Qt version (4.4 beta). + be fast on our main platform with the current Qt version (4.4).
    
  + == QPainter::drawLine() ==
  + 
  + If you're drawing a fully horizontal or fully vertical opaque line, with a solid
  + cosmetic (zero width) pen, you should disable anti aliasing before calling this function.
  + 
  + In all other cases you should make sure anti-aliasing is enabled before calling
  + this function.
    
  == QPixmap::setAlphaChannel() ==   == QPixmap::setAlphaChannel() ==





Fredrik: Some cleanups of the text
2008-04-11T15:37:13Z
Some cleanups of the text

				
				
				
				
			
			← Older revision
			Revision as of 15:37, 11 April 2008
			
Line 1:
Line 1:
  == QPixmap vs. QImage ==   == QPixmap vs. QImage ==
    
− QPixmap and QImage both hold images, but there is a key difference between the two that's important to understand when writing graphics code. + QPixmap and QImage both contain images, but there is a key difference between the two that's important to understand when writing graphics code.
    
  === QImage ===   === QImage ===
    
− When you're using a QImage, the image data is stored your application's memory in a format of your choosing.  This has the advantage that you can easily get to and manipulate the pixel data directly.  Loading a QImage from a local image file is not an expensive operation. + When you're using a QImage, the image data is stored your application's memory in a format of your choosing.  This has the advantage that you can easily get to and manipulate the pixel data directly.
    
  The disadvantages are that QPainter can't take advantage of the graphics hardware when rendering to a QImage.  In other words, all rendering to a QImage is done without hardware acceleration.   The disadvantages are that QPainter can't take advantage of the graphics hardware when rendering to a QImage.  In other words, all rendering to a QImage is done without hardware acceleration.
Line 11:
Line 11:
  === QPixmap ===   === QPixmap ===
    
− When you're using a QPixmap, the image data is not stored in your application's memory, but in the X server process, and possibly in video RAM. The data stored in the QPixmap object itself is just a serial number that refers to the X server image (pixmap). + When you're using a QPixmap, the image data is not stored in your application's memory, but in the X server process, and possibly in video RAM. The data stored in the QPixmap object itself is just a serial number that refers to the image in the X server (the pixmap).
    
− The disadvantage of using a QPixmap is that you can't get to the pixel data directly, since it's out of process. QPainter can only manipulate a QPixmap indirectly, by sending requests to the X server asking it to do the actual rendering. + The disadvantage of using a QPixmap is that you can't get to the pixel data directly, since it's out of process. QPainter can only manipulate a QPixmap indirectly, by sending requests to the X server asking it to manipulate the pixmap.
    
− The advantage is that the X server is free to use the graphics hardware to do the rendering, which means that when drawing on a QPixmap, you get hardware acceleration. + The advantage is that the X server can use the graphics hardware to do this, which means that when drawing on a QPixmap, you get hardware acceleration.
    
  === Conversions are expensive ===   === Conversions are expensive ===
    
− Converting a QImage to a QPixmap is an expensive operation since the image data must first be converted to a format the X server expects. It must then be marshalled and sent over the socket to the X server. + Converting a QImage to a QPixmap is an expensive operation because the image data must first be converted to the appropriate format for pixmaps, and then be marshalled and sent over the socket to the X server.
    
− Converting a QPixmap to a QImage is an even more expensive operation, because in order to do so your application must first send a request to the X server asking it to send the pixmap data to your application.  It must then block and wait, first for the X server process to be scheduled in by the kernel, then while the X server pulls the pixmap data out of video RAM and marshalls and sends it over the socket.  When your application has received the data, it must then convert it to an appropriate QImage format. + Converting a QPixmap to a QImage is an even more expensive operation, because in order to do so your application must first send a request to the X server asking it to send the pixmap data to your application.  It must then block and wait, first for the X server process to be scheduled in by the kernel, then while the X server marshalls and sends the pixmap data over the socket.  When your application has received the data, it must then convert it to an appropriate QImage format.
    
− Converting a QImage to a QPixmap is a less expensive operation because it's a fire-and-forget operation. Your application doesn't have to wait for the X server to receive the image data after it has been written to the socket. It can simply continue executing. + Converting a QImage to a QPixmap is a less expensive operation because it's a fire-and-forget operation. Your application doesn't have to wait for the X server to receive the image data after the data has been written to the socket. It can simply continue executing.
    
− Keep in mind that a QImage can't be drawn on a QPixmap or a QWidget without first being converted to a QPixmap. QPainter does this implicitly when you call QPainter::drawImage() on a QPixmap or a QWidget. Likewise, a QPixmap can't be drawn on a QImage without first being converted to a QImage. + Keep in mind that a QImage can't be drawn on a QPixmap or a QWidget without first being converted to a QPixmap.  QPainter does this implicitly when you call QPainter::drawImage() on a QPixmap or a QWidget.  Likewise, a QPixmap can't be drawn on a QImage without first being converted to a QImage.
    
  == QPainter::setOpacity() ==   == QPainter::setOpacity() ==



Fredrik: Add a section about QImage and QPixmap
2008-03-31T20:55:17Z
Add a section about QImage and QPixmap

				
				
				
				
			
			← Older revision
			Revision as of 20:55, 31 March 2008
			
Line 1:
Line 1:
  + == QPixmap vs. QImage ==
  + 
  + QPixmap and QImage both hold images, but there is a key difference between the two that's important to understand when writing graphics code.
  + 
  + === QImage ===
  + 
  + When you're using a QImage, the image data is stored your application's memory in a format of your choosing.  This has the advantage that you can easily get to and manipulate the pixel data directly.  Loading a QImage from a local image file is not an expensive operation.
  + 
  + The disadvantages are that QPainter can't take advantage of the graphics hardware when rendering to a QImage.  In other words, all rendering to a QImage is done without hardware acceleration.
  + 
  + === QPixmap ===
  + 
  + When you're using a QPixmap, the image data is not stored in your application's memory, but in the X server process, and possibly in video RAM. The data stored in the QPixmap object itself is just a serial number that refers to the X server image (pixmap).
  + 
  + The disadvantage of using a QPixmap is that you can't get to the pixel data directly, since it's out of process. QPainter can only manipulate a QPixmap indirectly, by sending requests to the X server asking it to do the actual rendering.
  + 
  + The advantage is that the X server is free to use the graphics hardware to do the rendering, which means that when drawing on a QPixmap, you get hardware acceleration.
  + 
  + === Conversions are expensive ===
  + 
  + Converting a QImage to a QPixmap is an expensive operation since the image data must first be converted to a format the X server expects. It must then be marshalled and sent over the socket to the X server.
  + 
  + Converting a QPixmap to a QImage is an even more expensive operation, because in order to do so your application must first send a request to the X server asking it to send the pixmap data to your application.  It must then block and wait, first for the X server process to be scheduled in by the kernel, then while the X server pulls the pixmap data out of video RAM and marshalls and sends it over the socket.  When your application has received the data, it must then convert it to an appropriate QImage format.
  + 
  + Converting a QImage to a QPixmap is a less expensive operation because it's a fire-and-forget operation. Your application doesn't have to wait for the X server to receive the image data after it has been written to the socket. It can simply continue executing.
  + 
  + Keep in mind that a QImage can't be drawn on a QPixmap or a QWidget without first being converted to a QPixmap. QPainter does this implicitly when you call QPainter::drawImage() on a QPixmap or a QWidget. Likewise, a QPixmap can't be drawn on a QImage without first being converted to a QImage.
  + 
  == QPainter::setOpacity() ==   == QPainter::setOpacity() ==
    





Fredrik: Expand on setOpacity() a bit, and fix the headings.
2008-03-31T20:08:28Z
Expand on setOpacity() a bit, and fix the headings.

				
				
				
				
			
			← Older revision
			Revision as of 20:08, 31 March 2008
			
Line 7:
Line 7:
  path is the kiss of death.   path is the kiss of death.
    
− '''An alternative approach to the problem''' + === An alternative approach to the problem ===
  +  
  + If you're drawing something with a solid color, such as a QPainterPath,
  + a line, a rectangle etc., the easiest and also the fastest solution is to just change the alpha value of the color you're using, like this:
  +  
  + <code cppqt>
  + QColor c = color;
  + c.setAlphaF(c.alphaF() * opacity);
  + </code>
  +  
  + If you're using pixmaps, gradients or brushes that you can't easily change the opacity of, you should use the following method instead.
    
  Create a temporary pixmap, initialize it to fully transparent, and then draw   Create a temporary pixmap, initialize it to fully transparent, and then draw
Line 46:
Line 56:
  a very expensive operation).   a very expensive operation).
    
− '''The right way to do it''' + === The right way to do it ===
    
  Check if the pixmap has an alpha channel, using QPixmap::hasAlphaChannel().   Check if the pixmap has an alpha channel, using QPixmap::hasAlphaChannel().





Fredrik: New page: == QPainter::setOpacity() ==  Never call QPainter::setOpacity() when painting on a QPixmap or a QWidget. QPainter::setOpacity() effectively disables all hardware acceleration, causing all ...
2008-03-17T16:42:04Z
New page: == QPainter::setOpacity() ==  Never call QPainter::setOpacity() when painting on a QPixmap or a QWidget. QPainter::setOpacity() effectively disables all hardware acceleration, causing all ...
New page
== QPainter::setOpacity() ==



Never call QPainter::setOpacity() when painting on a QPixmap or a QWidget.

QPainter::setOpacity() effectively disables all hardware acceleration,

causing all subsequent rendering operations to be done in software.

This means that a call to QPainter::setOpacity() in a performance critical

path is the kiss of death.



'''An alternative approach to the problem'''



Create a temporary pixmap, initialize it to fully transparent, and then draw

on it with normal opacity. When you're done drawing on it, use the DestinationIn composition mode to reduce the alpha of the pixmap, and then draw the pixmap itself where you want the semi-transparent contents. If you need the same content again (for example when you're doing a fade out or fade in animation), it might pay off to cache the fully opaque version.



<code cppqt>

QPixmap pixmap(size);

pixmap.fill(Qt::transparent);



QPainter p;

p.begin(&pixmap);



// Do the rendering with full opacity



p.setCompositionMode(QPainter::CompositionMode_DestinationIn);

p.fillRect(pixmap.rect(), QColor(0, 0, 0, opacity));

p.end();



painter->drawPixmap(0, 0, pixmap);

</code>



Note that you can check if setOpacity() is fast by calling

painter->paintEngine()->hasFeature(QPaintEngine::ConstantOpacity),

but my recommendation is to avoid it completely since it won't

be fast on our main platform with the current Qt version (4.4 beta).





== QPixmap::setAlphaChannel() ==



Never use QPixmap::setAlphaChannel() to make a pixmap semi-transparent.

In fact you should never ever call QPixmap::setAlphaChannel() for any

reason if you can avoid it. This function will convert both pixmaps to

images (this involves two blocking synchronous calls to the X server,

plus expensive image transport over the socket for each call), expensive

format conversion of both images, copying the alpha channel one pixel at

a time from the alpha image to the other image, followed by a final

conversion of the resulting image back to a pixmap (which is also

a very expensive operation).



'''The right way to do it'''



Check if the pixmap has an alpha channel, using QPixmap::hasAlphaChannel().

If it has one, start a QPainter on the pixmap, and reduce the alpha

using the DestinationIn composition mode. If the pixmap doesn't have an

alpha channel, you're going to have to create a new pixmap that has one

and copy the content of the original pixmap into it, like this:



<code cppqt>

QPixmap temp(pixmap.size());

temp.fill(Qt::transparent);



QPainter p(&temp);

p.setCompositionMode(QPainter::CompositionMode_Source);

p.drawPixmap(0, 0, pixmap);

p.setCompositionMode(QPainter::CompositionMode_DestinationIn);

p.fillRect(temp.rect(), QColor(0, 0, 0, opacity));

p.end();



pixmap = temp;

</code>

← Older revision		Revision as of 20:55, 31 March 2008
Line 1:		Line 1:
		+	== QPixmap vs. QImage ==
		+
		+	QPixmap and QImage both hold images, but there is a key difference between the two that's important to understand when writing graphics code.
		+
		+	=== QImage ===
		+
		+	When you're using a QImage, the image data is stored your application's memory in a format of your choosing. This has the advantage that you can easily get to and manipulate the pixel data directly. Loading a QImage from a local image file is not an expensive operation.
		+
		+	The disadvantages are that QPainter can't take advantage of the graphics hardware when rendering to a QImage. In other words, all rendering to a QImage is done without hardware acceleration.
		+
		+	=== QPixmap ===
		+
		+	When you're using a QPixmap, the image data is not stored in your application's memory, but in the X server process, and possibly in video RAM. The data stored in the QPixmap object itself is just a serial number that refers to the X server image (pixmap).
		+
		+	The disadvantage of using a QPixmap is that you can't get to the pixel data directly, since it's out of process. QPainter can only manipulate a QPixmap indirectly, by sending requests to the X server asking it to do the actual rendering.
		+
		+	The advantage is that the X server is free to use the graphics hardware to do the rendering, which means that when drawing on a QPixmap, you get hardware acceleration.
		+
		+	=== Conversions are expensive ===
		+
		+	Converting a QImage to a QPixmap is an expensive operation since the image data must first be converted to a format the X server expects. It must then be marshalled and sent over the socket to the X server.
		+
		+	Converting a QPixmap to a QImage is an even more expensive operation, because in order to do so your application must first send a request to the X server asking it to send the pixmap data to your application. It must then block and wait, first for the X server process to be scheduled in by the kernel, then while the X server pulls the pixmap data out of video RAM and marshalls and sends it over the socket. When your application has received the data, it must then convert it to an appropriate QImage format.
		+
		+	Converting a QImage to a QPixmap is a less expensive operation because it's a fire-and-forget operation. Your application doesn't have to wait for the X server to receive the image data after it has been written to the socket. It can simply continue executing.
		+
		+	Keep in mind that a QImage can't be drawn on a QPixmap or a QWidget without first being converted to a QPixmap. QPainter does this implicitly when you call QPainter::drawImage() on a QPixmap or a QWidget. Likewise, a QPixmap can't be drawn on a QImage without first being converted to a QImage.
		+
	== QPainter::setOpacity() ==		== QPainter::setOpacity() ==