Merge lp:~3v1n0/nux/fallback-texture into lp:nux

[Marco Trevisan (Treviño)]

GLTextureResourceManager: always return an empty (but non-NULL) texture if env var is set

Specifically, if NUX_FALLBACK_TEXTURE env variable is set, then we always try to
generate a valid texture. This is nice for testing purposes

When generating new textures from a local file or a pixbuf, Nux returns a new (not-NULL) BaseTexture only if the pixbuf is valid or the file exists. This is generally ok, but for testing purposes we sometimes (such as in tests) we need to ignore this and try to return a non-NULL (but empty) texture.
So, now setting the NUX_FALLBACK_TEXTURE to any value, makes Nux to be less strict on this, and always return an empty BaseTexture.

New tests added. Improved logging as well.

[Andrea Azzarone (azzar1)]

review: Approve

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'NuxGraphics/GLTextureResourceManager.cpp'
--- NuxGraphics/GLTextureResourceManager.cpp	2013-04-07 18:03:50 +0000
+++ NuxGraphics/GLTextureResourceManager.cpp	2013-07-03 23:17:28 +0000
@@ -25,9 +25,11 @@
 #include "GpuDevice.h"
 #include "GraphicsEngine.h"
 #include "GLTextureResourceManager.h"
+#include "NuxCore/Logger.h"
 
 namespace nux
 {
+  DECLARE_LOGGER(logger, "nux.gltexture.resource.manager");
 
   NUX_IMPLEMENT_OBJECT_TYPE(BaseTexture);
   NUX_IMPLEMENT_OBJECT_TYPE(Texture2D);
@@ -43,6 +45,24 @@
   NUX_IMPLEMENT_OBJECT_TYPE(CachedTextureVolume);
   NUX_IMPLEMENT_OBJECT_TYPE(CachedTextureFrameAnimation);
 
+namespace
+{
+  nux::BaseTexture* get_null_texture(std::string const& extra_msg = "")
+  {
+    if (!g_getenv("NUX_FALLBACK_TEXTURE"))
+    {
+      LOG_ERROR(logger) << "Invalid target, impossible to generate a new texture."
+                        << " " << extra_msg;
+      return nullptr;
+    }
+
+    LOG_WARN(logger) << "Invalid target, impossible to generate a new valid texture."
+                     << " " << extra_msg << ". Using fallback mode...";
+
+    return GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableTexture();
+  }
+}
+
   /*! Up cast a Resource.
       The source must be derived from the destination type
       @param   T       Destination type.
@@ -60,6 +80,7 @@
 
   BaseTexture* CreateTexture2DFromPixbuf(GdkPixbuf* pixbuf, bool premultiply)
   {
+    NUX_RETURN_VALUE_IF_NULL(pixbuf, get_null_texture("Null Pixbuf"));
     const unsigned int rowstride = gdk_pixbuf_get_rowstride(pixbuf);
     const unsigned int width = gdk_pixbuf_get_width(pixbuf);
     const unsigned int height = gdk_pixbuf_get_height(pixbuf);
@@ -158,8 +179,10 @@
   }
 
   BaseTexture* CreateTexture2DFromFile(const char* filename, int max_size,
-                                        bool premultiply)
+                                       bool premultiply)
   {
+    NUX_RETURN_VALUE_IF_NULL(filename, get_null_texture("Empty filename"));
+
     GError* error = NULL;
     GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file_at_size(filename, max_size, max_size, &error);
     if (error == NULL)
@@ -170,16 +193,16 @@
     }
     else
     {
-      nuxDebugMsg("%s", error->message);
+      std::string error_msg = (error->message ? error->message : "Unknown error");
       g_error_free(error);
-      return NULL;
+      return get_null_texture("Impossible to generate a pixbuf: "+error_msg);
     }
   }
 
   BaseTexture* CreateTextureFromPixbuf(GdkPixbuf* pixbuf)
   {
     NBitmapData* BitmapData = LoadGdkPixbuf(pixbuf);
-    NUX_RETURN_VALUE_IF_NULL(BitmapData, 0);
+    NUX_RETURN_VALUE_IF_NULL(BitmapData, get_null_texture("Invalid Pixbuf"));
 
     if (BitmapData->IsTextureData())
     {
@@ -188,15 +211,14 @@
       return texture;
     }
     delete BitmapData;
-    return 0;
+    return get_null_texture("Invalid Pixbuf");
   }
 
   BaseTexture* CreateTextureFromFile(const char* TextureFilename)
   {
     BaseTexture* texture = NULL;
-
     NBitmapData* BitmapData = LoadImageFile(TextureFilename);
-    NUX_RETURN_VALUE_IF_NULL(BitmapData, 0);
+    NUX_RETURN_VALUE_IF_NULL(BitmapData, get_null_texture("No data for '"+(TextureFilename ? std::string(TextureFilename) : "<null>")+"'"));
 
     if (BitmapData->IsTextureData())
     {
@@ -222,6 +244,7 @@
     else
     {
       nuxDebugMsg("[CreateTextureFromFile] Invalid texture format type for file(%s)", TextureFilename);
+      texture = get_null_texture();
     }
 
     delete BitmapData;
@@ -230,8 +253,7 @@
 
   BaseTexture* CreateTextureFromBitmapData(const NBitmapData* BitmapData)
   {
-    if (BitmapData == 0)
-      return 0;
+    NUX_RETURN_VALUE_IF_NULL(BitmapData, get_null_texture("Invalid BitmapData"));
 
     if (BitmapData->IsTextureData())
     {
@@ -257,15 +279,13 @@
       texture->Update(BitmapData);
       return texture;
     }
-    return 0;
+    return get_null_texture();
   }
 
   BaseTexture* LoadTextureFromFile(const std::string& filename)
   {
     NBitmapData* bitmap = LoadImageFile(filename.c_str());
-
-    if (bitmap == NULL)
-      return NULL;
+    NUX_RETURN_VALUE_IF_NULL(bitmap, get_null_texture("No Data for '"+filename+"'"));
 
     BaseTexture* texture = CreateTextureFromBitmapData(bitmap);
     delete bitmap;

=== modified file 'NuxGraphics/ImageSurface.cpp'
--- NuxGraphics/ImageSurface.cpp	2013-04-08 00:04:18 +0000
+++ NuxGraphics/ImageSurface.cpp	2013-07-03 23:17:28 +0000
@@ -41,6 +41,7 @@
 
   NBitmapData *LoadGdkPixbuf(GdkPixbuf *pixbuf)
   {
+    NUX_RETURN_VALUE_IF_NULL(pixbuf, nullptr);
     unsigned int width = gdk_pixbuf_get_width(pixbuf);
     unsigned int height = gdk_pixbuf_get_height(pixbuf);
     unsigned int row_bytes = gdk_pixbuf_get_rowstride(pixbuf);

=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2013-04-18 13:28:09 +0000
+++ tests/Makefile.am	2013-07-03 23:17:28 +0000
@@ -189,10 +189,7 @@
   libgtest.a
 
 gtest_nuxgraphics_LDFLAGS = \
-  -lpthread -lgmock \
-  -lboost_filesystem -lboost_system
-
-
+  -lgmock
 
 TestFlags = -I$(srcdir) \
   -I$(top_srcdir) \

=== modified file 'tests/gtest-nuxgraphics-texture.cpp'
--- tests/gtest-nuxgraphics-texture.cpp	2012-12-03 11:44:26 +0000
+++ tests/gtest-nuxgraphics-texture.cpp	2013-07-03 23:17:28 +0000
@@ -15,15 +15,23 @@
 
 namespace {
 
+const char *FALLBACK_ENV = "NUX_FALLBACK_TEXTURE";
+
 class TestTextures : public ::testing::Test
 {
 public:
   virtual void SetUp()
-  { 
+  {
+    g_unsetenv(FALLBACK_ENV);
     nux::NuxInitialize(0);
     wnd_thread.reset(nux::CreateNuxWindow("nux::TestTextures", 300, 200, nux::WINDOWSTYLE_NORMAL, NULL, false, NULL, NULL));
   }
 
+  void EnableFallbackMode()
+  {
+    g_setenv(FALLBACK_ENV, "TRUE", TRUE);
+  }
+
   std::unique_ptr<nux::WindowThread> wnd_thread;
 };
 
@@ -52,4 +60,46 @@
   }
 }
 
+TEST_F(TestTextures, FallbackTexture2DFromFile)
+{
+  ASSERT_THAT(CreateTexture2DFromFile(nullptr, -1, false), IsNull());
+  EnableFallbackMode();
+  ASSERT_THAT(CreateTexture2DFromFile(nullptr, -1, false), NotNull());
+}
+
+TEST_F(TestTextures, FallbackTexture2DFromPixbuf)
+{
+  ASSERT_THAT(CreateTexture2DFromPixbuf(nullptr, false), IsNull());
+  EnableFallbackMode();
+  ASSERT_THAT(CreateTexture2DFromPixbuf(nullptr, false), NotNull());
+}
+
+TEST_F(TestTextures, FallbackTextureFromPixbuf)
+{
+  ASSERT_THAT(CreateTextureFromPixbuf(nullptr), IsNull());
+  EnableFallbackMode();
+  ASSERT_THAT(CreateTextureFromPixbuf(nullptr), NotNull());
+}
+
+TEST_F(TestTextures, FallbackTextureFromFile)
+{
+  ASSERT_THAT(CreateTextureFromFile(nullptr), IsNull());
+  EnableFallbackMode();
+  ASSERT_THAT(CreateTextureFromFile(nullptr), NotNull());
+}
+
+TEST_F(TestTextures, FallbackTextureFromBitmapData)
+{
+  ASSERT_THAT(CreateTextureFromBitmapData(nullptr), IsNull());
+  EnableFallbackMode();
+  ASSERT_THAT(CreateTextureFromBitmapData(nullptr), NotNull());
+}
+
+TEST_F(TestTextures, FallbackTextureLoadFromFile)
+{
+  ASSERT_THAT(LoadTextureFromFile(std::string()), IsNull());
+  EnableFallbackMode();
+  ASSERT_THAT(LoadTextureFromFile(std::string()), NotNull());
+}
+
 }
\ No newline at end of file