Global ofGetMaxTextureSize() and UseTexture Option in ofTrueTypeFont.

libs/openFrameworks/app/ofAppNoWindow.cpp

@@ -72,7 +72,9 @@ class ofNoopRenderer: public ofBaseRenderer{
 private:
 	static const std::string TYPE;
 	const std::string & getType(){return TYPE;}
-
+
+	int getMaxTextureSize() {return 0;}
+
 	void startRender(){}
 	void finishRender(){}
 	void update(){}

libs/openFrameworks/gl/ofGLProgrammableRenderer.cpp

@@ -93,6 +93,13 @@ ofGLProgrammableRenderer::ofGLProgrammableRenderer(const ofAppBaseWindow * _wind
 	currentEyePos = { 0.f, 0.f, 0.f };
 }
 
+//----------------------------------------------------------
+int ofGLProgrammableRenderer::getMaxTextureSize() {
+	int maxSize;
+	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
+	return maxSize;
+}
+
 //----------------------------------------------------------
 void ofGLProgrammableRenderer::startRender() {
 	currentFramebufferId = defaultFramebufferId;
@@ -2215,10 +2222,14 @@ void ofGLProgrammableRenderer::drawString(const ofTrueTypeFont & font, string te
 	ofBlendMode blendMode = currentStyle.blendingMode;
 
 	mutThis->setBlendMode(OF_BLENDMODE_ALPHA);
-
-	mutThis->bind(font.getFontTexture(), 0);
-	draw(font.getStringMesh(text, x, y, isVFlipped()), OF_MESH_FILL);
-	mutThis->unbind(font.getFontTexture(), 0);
+
+	if( font.getFontTexture().isAllocated() ) {
+		mutThis->bind(font.getFontTexture(), 0);
+		draw(font.getStringMesh(text, x, y, isVFlipped()), OF_MESH_FILL);
+		mutThis->unbind(font.getFontTexture(), 0);
+	} else {
+		ofLogWarning("ofGLProgrammableRenderer") << "drawString: font texture is not allocated. Make sure to call setUseTexture(true) before load().";
+	}
 
 	mutThis->setBlendMode(blendMode);
 }

libs/openFrameworks/gl/ofGLProgrammableRenderer.h

@@ -23,6 +23,8 @@ class ofGLProgrammableRenderer: public ofBaseGLRenderer{
 
     static const std::string TYPE;
 	const std::string & getType(){ return TYPE; }
+
+	int getMaxTextureSize();
 
     void startRender();
     void finishRender();

libs/openFrameworks/gl/ofGLRenderer.cpp

@@ -64,6 +64,14 @@ void ofGLRenderer::setup() {
 			<< "ES 1.1 FBOs work on real devices (GL_OES_framebuffer_object); use ES 2.0+ to test FBOs on the emulator.";
 	}
 }
+
+//----------------------------------------------------------
+int ofGLRenderer::getMaxTextureSize() {
+	int maxSize;
+	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
+	return maxSize;
+}
+
 void ofGLRenderer::startRender() {
 	currentFramebufferId = defaultFramebufferId;
 	framebufferIdStack.push_back(defaultFramebufferId);
@@ -1781,10 +1789,14 @@ void ofGLRenderer::drawString(const ofTrueTypeFont & font, std::string text, flo
 
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-	mutThis->bind(font.getFontTexture(), 0);
-	draw(font.getStringMesh(text, x, y, isVFlipped()), OF_MESH_FILL);
-	mutThis->unbind(font.getFontTexture(), 0);
+
+	if( font.getFontTexture().isAllocated() ) {
+		mutThis->bind(font.getFontTexture(), 0);
+		draw(font.getStringMesh(text, x, y, isVFlipped()), OF_MESH_FILL);
+		mutThis->unbind(font.getFontTexture(), 0);
+	} else {
+		ofLogWarning("ofGLRenderer") << "drawString: font texture is not allocated. Make sure to call setUseTexture(true) before font.load().";
+	}
 
 	if (!blendEnabled) {
 		glDisable(GL_BLEND);

libs/openFrameworks/gl/ofGLRenderer.h

@@ -21,6 +21,8 @@ class ofGLRenderer: public ofBaseGLRenderer{
 	const std::string & getType(){ return TYPE; }
 
     void setup();
+
+	int getMaxTextureSize();
 
 	void startRender();
 	void finishRender();

libs/openFrameworks/gl/ofTexture.cpp

@@ -104,6 +104,14 @@ void ofRestoreMinMagFilters(){
 	bUseCustomMinMagFilters = false;
 }
 
+//----------------------------------------------------------
+int ofGetMaxTextureSize() {
+	if( ofGetCurrentRenderer() ) {
+		return ofGetCurrentRenderer()->getMaxTextureSize();
+	}
+	return 0;
+}
+
 //***** global functions to override texture settings
 
 

libs/openFrameworks/gl/ofTexture.h

@@ -167,6 +167,9 @@ enum ofTexCompression {
 	OF_COMPRESS_ARB		///< ARB compression.
 };
 
+/// \brief Get the maximum size texture for the current renderer.
+int ofGetMaxTextureSize();
+
 
 /// \class ofTextureData
 /// \advanced

libs/openFrameworks/graphics/ofCairoRenderer.cpp

@@ -135,6 +135,15 @@ void ofCairoRenderer::close() {
 	}
 }
 
+int ofCairoRenderer::getMaxTextureSize() {
+	// From the cairo source: https://github.com/ImageMagick/cairo/blob/main/src/cairo-image-surface.c#L62
+	/* Limit on the width / height of an image surface in pixels.  This is
+	 * mainly determined by coordinates of things sent to pixman at the
+	 * moment being in 16.16 format. */
+//	#define MAX_IMAGE_SIZE 32767
+	return 32767;
+}
+
 void ofCairoRenderer::startRender() {
 	setStyle(currentStyle);
 	if (page == 0 || !multiPage) {

libs/openFrameworks/graphics/ofCairoRenderer.h

@@ -30,6 +30,8 @@ class ofCairoRenderer: public ofBaseRenderer{
 	void setupMemoryOnly(Type _type, bool multiPage=true, bool b3D=false, ofRectangle viewport = ofRectangle(0,0,0,0));
 	void close();
 	void flush();
+
+	int getMaxTextureSize();
 
 	void startRender();
 	void finishRender();

libs/openFrameworks/graphics/ofGraphicsBaseTypes.h

@@ -319,6 +319,10 @@ class ofBaseRenderer {
 	///
 	/// \returns The string representation of the renderer type.
 	virtual const std::string & getType() = 0;
+
+	/// \brief Get the max texture size supported by the renderer.
+	/// \returns The int value of the maximum texture size.
+	virtual int getMaxTextureSize() = 0;
 
 	/// \brief Starts using this renderer as the rendering surface.
 	virtual void startRender() = 0;

libs/openFrameworks/graphics/ofRendererCollection.cpp

@@ -26,6 +26,17 @@ std::shared_ptr<ofBaseGLRenderer> ofRendererCollection::getGLRenderer(){
 
 bool ofRendererCollection::rendersPathPrimitives(){return true;}
 
+
+int ofRendererCollection::getMaxTextureSize() {
+	// pull the value from the first renderer.
+	if (!renderers.empty()) {
+		return renderers.front()->getMaxTextureSize();
+	} else {
+		ofLogWarning() << "No renderer in renderer collection, max texture size requested. Returning 0.";
+		return 0;
+	}
+}
+
 void ofRendererCollection::startRender(){
 	for(auto renderer: renderers){
 		renderer->startRender();

libs/openFrameworks/graphics/ofRendererCollection.h

@@ -15,6 +15,8 @@ class ofRendererCollection: public ofBaseRenderer{
 	 std::shared_ptr<ofBaseGLRenderer> getGLRenderer();
 
 	 bool rendersPathPrimitives();
+
+	 int getMaxTextureSize();
 
 	 void startRender();
 

libs/openFrameworks/graphics/ofTrueTypeFont.cpp

@@ -455,6 +455,7 @@ bool ofTrueTypeFont::initLibraries(){
 ofTrueTypeFont::ofTrueTypeFont()
 :settings("",0){
 	bLoadedOk = false;
+	bUseTexture = true;
 	letterSpacing = 1;
 	spaceSize = 1;
 	fontUnitScale = 1;
@@ -502,6 +503,7 @@ ofTrueTypeFont::ofTrueTypeFont(const ofTrueTypeFont& mom)
 	texAtlas = mom.texAtlas;
 	atlasPixels = mom.atlasPixels;
 	face = mom.face;
+	bUseTexture = mom.bUseTexture;
 }
 
 //------------------------------------------------------------------
@@ -535,6 +537,7 @@ ofTrueTypeFont & ofTrueTypeFont::operator=(const ofTrueTypeFont& mom){
 	texAtlas = mom.texAtlas;
 	atlasPixels = mom.atlasPixels;
 	face = mom.face;
+	bUseTexture = mom.bUseTexture;
 
 	return *this;
 }
@@ -569,6 +572,7 @@ ofTrueTypeFont::ofTrueTypeFont(ofTrueTypeFont&& mom)
 	texAtlas = mom.texAtlas;
 	atlasPixels = std::move(mom.atlasPixels);
 	face = mom.face;
+	bUseTexture = mom.bUseTexture;
 }
 
 //------------------------------------------------------------------
@@ -601,6 +605,7 @@ ofTrueTypeFont & ofTrueTypeFont::operator=(ofTrueTypeFont&& mom){
 	texAtlas = mom.texAtlas;
 	atlasPixels = std::move(mom.atlasPixels);
 	face = mom.face;
+	bUseTexture = mom.bUseTexture;
 	return *this;
 }
 
@@ -871,32 +876,57 @@ bool ofTrueTypeFont::load(const ofTrueTypeFontSettings & _settings){
 		x+= glyph.tW + border*2.0;
 	}
 
-	int maxSize;
-	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
-	if(w > maxSize || h > maxSize){
-		ofLogError("ofTruetypeFont") << "Trying to allocate texture of " << w << "x" << h << " which is bigger than supported in current platform: " << maxSize;
-		return false;
-	}else{
-		texAtlas.allocate(atlasPixelsLuminanceAlpha,false);
-		texAtlas.setRGToRGBASwizzles(true);
-
-		if(settings.antialiased && settings.fontSize>20){
-			texAtlas.setTextureMinMagFilter(GL_LINEAR,GL_LINEAR);
-		}else{
-			texAtlas.setTextureMinMagFilter(GL_NEAREST,GL_NEAREST);
+	if (isUsingTexture()) {
+		const int maxSize = ofGetMaxTextureSize();
+		if (maxSize <= 0 || w > maxSize || h > maxSize) {
+			ofLogError("ofTrueTypeFont") << "Font atlas exceeds the current renderer's texture limit of " << maxSize;
+			return false;
 		}
-		texAtlas.loadData(atlasPixelsLuminanceAlpha);
-		atlasPixels = std::move(atlasPixelsLuminanceAlpha);
-		bLoadedOk = true;
-		return true;
 	}
+
+	atlasPixels = std::move(atlasPixelsLuminanceAlpha);
+
+	bLoadedOk = true;
+
+	texAtlas.clear(); 
+	setUseTexture(isUsingTexture());
+
+	return true;
+
 }
 
 //-----------------------------------------------------------
 bool ofTrueTypeFont::isLoaded() const{
 	return bLoadedOk;
 }
 
+//-----------------------------------------------------------
+void ofTrueTypeFont::setUseTexture(bool bUse) {
+	if(!bUse) {
+		if(texAtlas.isAllocated()) {
+			texAtlas.clear();
+		}
+	} else {
+		if(isLoaded() && !texAtlas.isAllocated() && atlasPixels.isAllocated() ) {
+			texAtlas.allocate(atlasPixels,false);
+			texAtlas.setRGToRGBASwizzles(true);
+
+			if(settings.antialiased && settings.fontSize>20){
+				texAtlas.setTextureMinMagFilter(GL_LINEAR,GL_LINEAR);
+			}else{
+				texAtlas.setTextureMinMagFilter(GL_NEAREST,GL_NEAREST);
+			}
+			texAtlas.loadData(atlasPixels);
+		}
+	}
+	bUseTexture = bUse;
+}
+
+//-----------------------------------------------------------
+bool ofTrueTypeFont::isUsingTexture() const {
+	return bUseTexture;
+}
+
 //-----------------------------------------------------------
 bool ofTrueTypeFont::isAntiAliased() const{
 	return settings.antialiased;
@@ -1255,6 +1285,9 @@ const ofMesh & ofTrueTypeFont::getStringMesh(const string& c, float x, float y,
 
 //-----------------------------------------------------------
 const ofTexture & ofTrueTypeFont::getFontTexture() const{
+	if( !isUsingTexture() ) {
+		ofLogWarning("ofTrueTypeFont") << "getFontTexture(): make sure to call setUseTexture(true) and then load().";
+	}
 	return texAtlas;
 }
 

libs/openFrameworks/graphics/ofTrueTypeFont.h

@@ -212,6 +212,17 @@ class ofTrueTypeFont {
 	/// \brief Has the font been loaded successfully?
 	/// \returns true if the font was loaded.
 	bool isLoaded() const;
+
+	/// \brief Turns on or off the allocation and use of a texture.
+	///
+	/// \param bUse Allocate and use a texture or not.
+	void setUseTexture(bool bUse);
+
+	/// \brief Returns whether the ofTrueTypeFont has a texture or not.
+	///
+	/// If the ofTrueTypeFont doesn't have a texture, nothing will be drawn to the screen.
+	/// \returns true if the ofTrueTypeFont is using a texture.
+	bool isUsingTexture() const;
 
 	/// \}
 	/// \name Font Settings
@@ -393,6 +404,7 @@ class ofTrueTypeFont {
 	/// \cond INTERNAL
 
 	bool bLoadedOk;
+	bool bUseTexture;
 
 	std::vector<ofPath> charOutlines;
 	std::vector<ofPath> charOutlinesNonVFlipped;