GEEKING

Rendering/GfxRender/TextureManager.h

@@ -0,0 +1,153 @@
+#pragma once
+
+#include "TextureRef.h"
+#include "util/ContentId.h"
+
+#include <boost/unordered_map.hpp>
+
+#include <rbx/threadsafe.h>
+
+namespace RBX
+{
+    class ThreadPool;
+}
+
+namespace RBX
+{
+namespace Graphics
+{
+
+class VisualEngine;
+class Image;
+
+struct TextureManagerStats
+{
+    unsigned int queuedCount;
+
+    unsigned int totalBudget;
+
+    unsigned int liveCount;
+    unsigned int liveSize;
+
+    unsigned int orphanedCount;
+    unsigned int orphanedSize;
+};
+
+class TextureManager
+{
+public:
+    enum Fallback
+	{
+        Fallback_None,
+
+        Fallback_White,
+        Fallback_Gray,
+        Fallback_Black,
+        Fallback_BlackTransparent,
+
+        Fallback_NormalMap,
+        Fallback_Reflection,
+
+        Fallback_Count
+	};
+
+    TextureManager(VisualEngine* visualEngine);
+    ~TextureManager();
+
+    void processPendingRequests();
+	void cancelPendingRequests();
+
+    void garbageCollectIncremental();
+    void garbageCollectFull();
+
+    void reloadImage(const ContentId& id, const std::string& context = "");
+    TextureRef load(const ContentId& id, Fallback fallback, const std::string& context = "");
+
+	const shared_ptr<Texture>& getFallbackTexture(Fallback fallback) { return fallbackTextures[fallback]; }
+    bool isFallbackTexture(const shared_ptr<Texture>& tex);
+
+	bool isQueueEmpty() const { return outstandingRequests == 0; }
+
+	TextureManagerStats getStatistics() const;
+
+private:
+    struct LoadedImage
+	{
+		std::string context;
+        ContentId id;
+
+        shared_ptr<Image> image;
+        ImageInfo info;
+
+		Time::Interval loadTime;
+	};
+
+    struct TextureData
+	{
+        ContentId id;
+
+        std::vector<TextureRef> external;
+        TextureRef object;
+
+        bool orphaned;
+        TextureData* orphanedPrev;
+        TextureData* orphanedNext;
+
+        TextureData();
+
+        TextureRef addExternalRef(const shared_ptr<Texture>& fallback);
+
+        void removeUnusedExternalRefs();
+
+        void updateAllRefsToLoaded(const shared_ptr<Texture>& texture, const ImageInfo& info);
+        void updateAllRefsToFailed();
+        void updateAllRefsToWaiting();
+	};
+
+    VisualEngine* visualEngine;
+
+    typedef boost::unordered_map<ContentId, TextureData> Textures;
+	Textures textures;
+
+    shared_ptr<Texture> fallbackTextures[Fallback_Count];
+
+    shared_ptr<rbx::safe_queue<LoadedImage> > pendingImages;
+    shared_ptr<ThreadPool> loadingPool;
+    boost::unordered_set<ContentId> pendingReloads;
+    unsigned int outstandingRequests;
+
+    unsigned int liveCount;
+    unsigned int liveSize;
+
+    unsigned int orphanedCount;
+    unsigned int orphanedSize;
+
+    TextureData* orphanedHead;
+    TextureData* orphanedTail;
+
+    size_t gcSizeLast;
+    ContentId gcKeyNext;
+
+    unsigned int totalSizeBudget;
+
+    bool loadAsync(const ContentId& id, const std::string& context);
+
+    void orphanUnusedTextures(size_t visitCount);
+    void collectOrphanedTextures(unsigned int maxOrphanedSize);
+
+    void addToOrphanedTail(TextureData* data);
+    void removeFromOrphaned(TextureData* data);
+
+    shared_ptr<Texture> createSingleColorTexture(unsigned char r, unsigned char g, unsigned char b, unsigned char a, bool cube = false);
+    shared_ptr<Texture> createTexture(const Image& image);
+
+	static void loadImageHttpCallback(const weak_ptr<ThreadPool>& loadingPool, const weak_ptr<rbx::safe_queue<LoadedImage> >& pendingImages, const shared_ptr<const std::string>& content, const ContentId& id, unsigned int maxTextureSize, unsigned int flags, const std::string& context);
+
+    static void loadImageFile(const shared_ptr<rbx::safe_queue<LoadedImage> >& pendingImages, const ContentId& id, const ContentId& loadId, unsigned int maxTextureSize, unsigned int flags, bool useRetina, const std::string& context = "");
+	static void loadImageHttp(const shared_ptr<rbx::safe_queue<LoadedImage> >& pendingImages, const ContentId& id, const shared_ptr<const std::string>& content, unsigned int maxTextureSize, unsigned int flags, const std::string& context = "");
+    static void loadImage(const shared_ptr<rbx::safe_queue<LoadedImage> >& pendingImages, const ContentId& id, std::istream& stream, unsigned int maxTextureSize, unsigned int flags, int scale, const std::string& context = "");
+    static void loadImageError(const shared_ptr<rbx::safe_queue<LoadedImage> >& pendingImages, const ContentId& id, const char* error, const std::string& context);
+};
+
+}
+}