#ifndef INCLUDED_RENDERER
	#define INCLUDED_RENDERER
	
	class Texture {
	    public:
	        virtual ~Texture() {}
	        virtual void makeCurrent()=0;
	};
	
	class Renderer {
	    public:
	        virtual Texture * loadTexture(const char * name);
	};
	
	#endif
	
	Figure 1. renderer.h 

	#ifndef INCLUDED_RENDERER_TEMPLATES
	#define INCLUDED_RENDERER_TEMPLATES
	
	#include "renderer.h"
	
	template <class Baseclass, class Renderer> class TextureTemplate : public Baseclass {
	    private:
	        Renderer * m_renderer;
	    public:
	        TextureTemplate(Renderer & rend, const char * name) : m_renderer(&rend), Baseclass(name) { }
	        ~TextureTemplate() { 
	            m_renderer->unregisterTexture(this);
	        }
	        void makeCurrent() { 
	            m_renderer->makeCurrent(this);
	        }
	};
	
	template <class Baseclass, class TextureBase> class RendererTemplate : public Baseclass {
	    public:
	        typedef TextureTemplate<TextureBase> MyTexture;
	
	        Texture * loadTexture(const char * name) {
	            return new MyTexture(this,name)
	        }
	};
	
	#endif
	
	Figure 2. renderer_templates.h 

	#ifndef INCLUDED_GLRENDERER
	#define INCLUDED_GLRENDERER
	
	#include "renderer_templates.h"
	
	class GLTextureImpl : public Texture {
	    public:
	        GLTextureImpl(const char * name, blah blah blah) {
	            load up texture using opengl...
	        }
	        virtual ~GLTextureImpl() {}
	};
	
	class GLRendererImpl : public Renderer { 
	    public:
	        void makeCurrent(GLTextureImpl & texture) {
	            ... do gl texture stuff here ...
	        }
		void unregisterTexture(GLTextureImpl & texture) { 
		    ... do gl texture stuff here ...
	        }
	
	};
	
	typedef TextureTemplate<GLTextureImpl,GLRendererImpl> GLTexture;
	typedef RendererTemplate<GLRendererImpl,GLTextureImpl> GLRenderer;
	
	#endif
	
	Figure 3. glrenderer.h

	Interface 
		Implementation : public Interface
			TemplateWrapper<Implementation> : public Implementation
	
	Figure 4. Hierarchy