Texture Manager and OpenGLGraphic description - Revision history

Marie.o: beautification

2010-05-17T20:55:58Z

beautification

←Older revision		Revision as of 20:55, 17 May 2010
Line 3:		Line 3:

	Texturing mechanism in OpenGL is next:		Texturing mechanism in OpenGL is next:
			* read the data in a buffer where you know the format (for instance RGB or RGBA)
	- read the data in a buffer where you know the format (for instance RGB or RGBA)		* convert it from pixel surface to a texture
			* get an index that may be used to "paint the geometry" using glEnable(GL_TEXTURE_2D) call using different parameters, as current color, transparency, etc.
	- convert it from pixel surface to a texture

	- get an index that may be used to "paint the geometry" using glEnable(GL_TEXTURE_2D) call using different parameters, as current color, transparency, etc.


	Restrictions of OpenGL implementation:		Restrictions of OpenGL implementation:
	- OpenGL should be implemented in it's own thread, else the convert textures will not appear to the drawing.		* OpenGL should be implemented in it's own thread, else the convert textures will not appear to the drawing.
			* the textures should be sized as power of two, etc. and the scaling may take time to complete
	- the textures should be sized as power of two, etc. and the scaling may take time to complete

	The conclusion is simple,		The conclusion is simple,

	The flow is next:		The flow is next:
	- OpenGLEngine creates an TextureManager		* OpenGLEngine creates an TextureManager
	- at every frame at start we should		* at every frame at start we should

	Manages multiple graphics and geometry lists:		Manages multiple graphics and geometry lists:

	- textures for pending for convert		* textures for pending for convert
	std::list <OpenGLGraphic*> WaitForConvert;		std::list <OpenGLGraphic*> WaitForConvert;
			* texture indexes which needs to be removed
	- texture indexes which needs to be removed		std::list <OpenGLTexture> WaitForRelease;
	std::list <OpenGLTexture> WaitForRelease;		* Geometry cache, it keeps all geometry with uniques IDs. It can be used for store local objects.
			std::map<std::string, MeshFrame*> Graphics;
	- Geometry cache, it keeps all geometry with uniques IDs. It can be used for store local objects.
	std::map<std::string, MeshFrame*> Graphics;
	[[Category: Programmer's Guide]]		[[Category: Programmer's Guide]]

Wierdbeard65 at 15:56, 5 May 2010

2010-05-05T15:56:26Z

←Older revision		Revision as of 15:56, 5 May 2010
Line 1:		Line 1:
			{{versioninfo}}
	TextureManager class		TextureManager class

Rwilson131 at 01:09, 6 September 2007

2007-09-06T01:09:19Z

←Older revision		Revision as of 01:09, 6 September 2007
Line 31:		Line 31:
	- Geometry cache, it keeps all geometry with uniques IDs. It can be used for store local objects.		- Geometry cache, it keeps all geometry with uniques IDs. It can be used for store local objects.
	std::map<std::string, MeshFrame*> Graphics;		std::map<std::string, MeshFrame*> Graphics;
			[[Category: Programmer's Guide]]

Jerry finn at 13:42, 16 March 2007

2007-03-16T13:42:00Z

←Older revision		Revision as of 13:42, 16 March 2007
Line 1:		Line 1:
	<table width="100%"> <tr><td bgcolor="#FFCFCF">This page was written by Pluto and imported with their permission when LinuxMCE branched off in February, 2007. In general any information should apply to LinuxMCE. However, this page should be edited to reflect changes to LinuxMCE and remove old references to Pluto.</td></tr> </table>TextureManager class		TextureManager class

	Texturing mechanism in OpenGL is next:		Texturing mechanism in OpenGL is next:
Line 13:		Line 13:
	- OpenGL should be implemented in it's own thread, else the convert textures will not appear to the drawing.		- OpenGL should be implemented in it's own thread, else the convert textures will not appear to the drawing.

	- the textures should be sized as power of two, etc. and the ~~scalling~~ may take time to complete		- the textures should be sized as power of two, etc. and the scaling may take time to complete

	The conclusion is simple,		The conclusion is simple,

Wikiadmin at 16:10, 14 September 2006

2006-09-14T16:10:10Z

←Older revision		Revision as of 16:10, 14 September 2006
Line 22:		Line 22:

	Manages multiple graphics and geometry lists:		Manages multiple graphics and geometry lists:

	- textures for pending for convert		- textures for pending for convert
	std::list <OpenGLGraphic*> WaitForConvert;		std::list <OpenGLGraphic*> WaitForConvert;

	- texture indexes which needs to be removed		- texture indexes which needs to be removed
	std::list <OpenGLTexture> WaitForRelease;		std::list <OpenGLTexture> WaitForRelease;

	- Geometry cache, it keeps all geometry with uniques IDs. It can be used for store local objects.		- Geometry cache, it keeps all geometry with uniques IDs. It can be used for store local objects.
	std::map<std::string, MeshFrame*> Graphics;		std::map<std::string, MeshFrame*> Graphics;

Wikiadmin at 16:09, 14 September 2006

2006-09-14T16:09:55Z

←Older revision		Revision as of 16:09, 14 September 2006
Line 22:		Line 22:

	Manages multiple graphics and geometry lists:		Manages multiple graphics and geometry lists:
	- ~~texture~~ for pending		- textures for pending for convert
	std::list <OpenGLGraphic*> WaitForConvert;		std::list <OpenGLGraphic*> WaitForConvert;
	std::list <OpenGLTexture> WaitForRelease;		- texture indexes which needs to be removed
	std::map<std::string, MeshFrame*> Graphics;		std::list <OpenGLTexture> WaitForRelease;
			- Geometry cache, it keeps all geometry with uniques IDs. It can be used for store local objects.
			std::map<std::string, MeshFrame*> Graphics;

Wikiadmin at 15:59, 14 September 2006

2006-09-14T15:59:17Z

←Older revision		Revision as of 15:59, 14 September 2006
Line 2:		Line 2:

	Texturing mechanism in OpenGL is next:		Texturing mechanism in OpenGL is next:

	- read the data in a buffer where you know the format (for instance RGB or RGBA)		- read the data in a buffer where you know the format (for instance RGB or RGBA)

	- convert it from pixel surface to a texture		- convert it from pixel surface to a texture

	- get an index that may be used to "paint the geometry" using glEnable(GL_TEXTURE_2D) call using different parameters, as current color, transparency, etc.		- get an index that may be used to "paint the geometry" using glEnable(GL_TEXTURE_2D) call using different parameters, as current color, transparency, etc.


	Restrictions of OpenGL implementation:		Restrictions of OpenGL implementation:
	- OpenGL should be implemented in it's own thread, else the convert textures will not appear to the drawing. ~~The conclusion is simple,~~		- OpenGL should be implemented in it's own thread, else the convert textures will not appear to the drawing.

	- the textures should be sized as power of two, etc. and the scalling may take time to complete		- the textures should be sized as power of two, etc. and the scalling may take time to complete

			The conclusion is simple,

	The flow is next:		The flow is next:

Wikiadmin at 15:58, 14 September 2006

2006-09-14T15:58:40Z

New page

<table width="100%"> <tr><td bgcolor="#FFCFCF">This page was written by Pluto and imported with their permission when LinuxMCE branched off in February, 2007. In general any information should apply to LinuxMCE. However, this page should be edited to reflect changes to LinuxMCE and remove old references to Pluto.</td></tr> </table>TextureManager class

Texturing mechanism in OpenGL is next:
- read the data in a buffer where you know the format (for instance RGB or RGBA)
- convert it from pixel surface to a texture
- get an index that may be used to "paint the geometry" using glEnable(GL_TEXTURE_2D) call using different parameters, as current color, transparency, etc.

Restrictions of OpenGL implementation:
- OpenGL should be implemented in it's own thread, else the convert textures will not appear to the drawing. The conclusion is simple,
- the textures should be sized as power of two, etc. and the scalling may take time to complete

The flow is next:
- OpenGLEngine creates an TextureManager
- at every frame at start we should

Manages multiple graphics and geometry lists:
- texture for pending
std::list <OpenGLGraphic*> WaitForConvert;
std::list <OpenGLTexture> WaitForRelease;
std::map<std::string, MeshFrame*> Graphics;