add gpu to the default makefile

move skia-gpu files into skia/src/gpu



git-svn-id: http://skia.googlecode.com/svn/trunk@653 2bbb7eff-a529-9590-31e7-b0007b416f81

5 files changed, 544 insertions, 57 deletions

diff --git a/include/gpu/SkGpuCanvas.h b/include/gpu/SkGpuCanvas.h
new file mode 100644
index 0000000000..e8e6e7ae10
--- /dev/null
+++ b/include/gpu/SkGpuCanvas.h
@@ -0,0 +1,72 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef SkGpuCanvas_DEFINED
+#define SkGpuCanvas_DEFINED
+
+#include "SkCanvas.h"
+
+class GrContext;
+
+/**
+ *  Subclass of canvas that creates devices compatible with the GrContext pass
+ *  to the canvas' constructor.
+ */
+class SkGpuCanvas : public SkCanvas {
+public:
+    /**
+     *  The GrContext object is reference counted. When passed to our 
+     *  constructor, its reference count is incremented. In our destructor, the 
+     *  GrGpu's reference count will be decremented.
+     */
+    explicit SkGpuCanvas(GrContext*);
+    virtual ~SkGpuCanvas();
+
+    /**
+     *  Return our GrContext instance
+     */
+    GrContext* context() const { return fContext; }
+
+    /**
+     *  Override from SkCanvas. Returns true, and if not-null, sets size to
+     *  be the width/height of our viewport.
+     */
+    virtual bool getViewport(SkIPoint* size) const;
+
+    /**
+     *  Override from SkCanvas. Returns a new device of the correct subclass,
+     *  as determined by the GrGpu passed to our constructor.
+     */
+    virtual SkDevice* createDevice(SkBitmap::Config, int width, int height,
+                                   bool isOpaque, bool isLayer);
+
+#if 0
+    virtual int saveLayer(const SkRect* bounds, const SkPaint* paint,
+                          SaveFlags flags = kARGB_ClipLayer_SaveFlag) {
+        return this->save(flags);
+    }
+#endif
+    
+private:
+    GrContext* fContext;
+
+    typedef SkCanvas INHERITED;
+};
+
+#endif
+
+
diff --git a/include/gpu/SkGpuDevice.h b/include/gpu/SkGpuDevice.h
new file mode 100644
index 0000000000..e42e99709d
--- /dev/null
+++ b/include/gpu/SkGpuDevice.h
@@ -0,0 +1,176 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef SkGpuDevice_DEFINED
+#define SkGpuDevice_DEFINED
+
+#include "SkGr.h"
+#include "SkDevice.h"
+#include "SkRegion.h"
+
+struct SkDrawProcs;
+class SkGpuCanvas;
+struct GrSkDrawProcs;
+class GrTextContext;
+
+/**
+ *  Subclass of SkDevice, which directs all drawing to the GrGpu owned by the
+ *  canvas.
+ */
+class SkGpuDevice : public SkDevice {
+public:
+    SkGpuDevice(SkGpuCanvas*, const SkBitmap& bitmap, bool isLayer);
+    virtual ~SkGpuDevice();
+ 
+    GrContext* context() const { return fContext; }
+
+    /**
+     *  If this device was built for rendering as a layer (i.e. offscreen),
+     *  then this will return the platform-specific handle to that GPU resource.
+     *  For example, in OpenGL, this will return the FBO's texture ID.
+     *  If this device was not built for rendering as a layer, then 0
+     *  is returned.
+     */
+    intptr_t getLayerTextureHandle() const;
+    
+    /**
+     * Attaches the device to a rendering surface. This device will then render
+     * to the surface.
+     * For example, in OpenGL, the device will interpret handle as an FBO ID
+     * and drawing to the device would direct GL to the FBO.
+     */
+    void bindDeviceToTargetHandle(intptr_t handle);
+
+    // call to set the clip to the specified rect
+    void scissor(const SkIRect&);
+
+    /**
+     *  Override from SkGpuDevice, so we can set our FBO to be the render target
+     *  The canvas parameter must be a SkGpuCanvas
+     */
+    virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&);
+
+    virtual SkGpuTexture* accessTexture() { return (SkGpuTexture*)fTexture; }
+
+    // overrides from SkDevice
+
+    virtual bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap);
+    virtual void writePixels(const SkBitmap& bitmap, int x, int y);
+    
+    virtual void setMatrixClip(const SkMatrix& matrix, const SkRegion& clip);
+
+    virtual void drawPaint(const SkDraw&, const SkPaint& paint);
+    virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
+                            const SkPoint[], const SkPaint& paint);
+    virtual void drawRect(const SkDraw&, const SkRect& r,
+                          const SkPaint& paint);
+    virtual void drawPath(const SkDraw&, const SkPath& path,
+                          const SkPaint& paint, const SkMatrix* prePathMatrix,
+                          bool pathIsMutable);
+    virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
+                            const SkIRect* srcRectOrNull,
+                            const SkMatrix& matrix, const SkPaint& paint);
+    virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
+                            int x, int y, const SkPaint& paint);
+    virtual void drawText(const SkDraw&, const void* text, size_t len,
+                          SkScalar x, SkScalar y, const SkPaint& paint);
+    virtual void drawPosText(const SkDraw&, const void* text, size_t len,
+                             const SkScalar pos[], SkScalar constY,
+                             int scalarsPerPos, const SkPaint& paint);
+    virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
+                                const SkPath& path, const SkMatrix* matrix,
+                                const SkPaint& paint);
+    virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
+                              const SkPoint verts[], const SkPoint texs[],
+                              const SkColor colors[], SkXfermode* xmode,
+                              const uint16_t indices[], int indexCount,
+                              const SkPaint& paint);
+    virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
+                            const SkPaint&);
+    
+    virtual void flush() { fContext->flush(false); }
+    
+    /** 
+     * Make's this device's rendertarget current in the underlying 3D API.
+     * Also implicitly flushes.
+     */
+    virtual void makeRenderTargetCurrent();
+
+protected:
+    class TexCache;
+    TexCache* lockCachedTexture(const SkBitmap& bitmap,
+                                const GrSamplerState& sampler,
+                                GrTexture** texture,
+                                bool forDeviceRenderTarget = false);
+    void unlockCachedTexture(TexCache*);
+
+    class SkAutoCachedTexture {
+    public:
+        SkAutoCachedTexture();
+        SkAutoCachedTexture(SkGpuDevice* device,
+                            const SkBitmap& bitmap,
+                            const GrSamplerState& sampler,
+                            GrTexture** texture);
+        ~SkAutoCachedTexture();
+
+        GrTexture* set(SkGpuDevice*, const SkBitmap&, const GrSamplerState&);
+
+    private:
+        SkGpuDevice*    fDevice;
+        TexCache*       fTex;
+    };
+    friend class SkAutoTexCache;
+
+private:
+    GrContext*      fContext;
+    GrSkDrawProcs*  fDrawProcs;
+
+    // state for our offscreen render-target
+    TexCache*       fCache;
+    GrTexture*      fTexture;
+    GrRenderTarget* fRenderTarget;
+    bool            fNeedClear;
+    bool            fNeedPrepareRenderTarget;
+    
+    SkDrawProcs* initDrawForText(const SkPaint&, GrTextContext*);
+    bool bindDeviceAsTexture(SkPoint* max);
+
+    void prepareRenderTarget(const SkDraw&);
+    void internalDrawBitmap(const SkDraw&, const SkBitmap&,
+                            const SkIRect&, const SkMatrix&, const SkPaint&);
+        
+    class AutoPaintShader {
+    public:
+        AutoPaintShader();
+        AutoPaintShader(SkGpuDevice*, const SkPaint& paint, const SkMatrix&);
+
+        void init(SkGpuDevice*, const SkPaint& paint, const SkMatrix&);
+
+        bool failed() const { return !fSuccess; }
+        bool useTex() const { return fTexture != 0; }
+    private:
+        GrTexture*              fTexture;
+        SkAutoCachedTexture     fCachedTexture;
+        bool                    fSuccess;
+    };
+    friend class AutoPaintShader;
+
+    typedef SkDevice INHERITED;
+};
+
+#endif
+
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
new file mode 100644
index 0000000000..4e9801f699
--- /dev/null
+++ b/include/gpu/SkGr.h
@@ -0,0 +1,238 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef SkGr_DEFINED
+#define SkGr_DEFINED
+
+#include <stddef.h>
+
+// tetrark headers
+#include "GrConfig.h"
+#include "GrContext.h"
+#include "GrFontScaler.h"
+#include "GrPathIter.h"
+#include "GrClipIterator.h"
+
+// skia headers
+#include "SkBitmap.h"
+#include "SkPath.h"
+#include "SkPoint.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+
+#if (GR_DEBUG && defined(SK_RELEASE)) || (GR_RELEASE && defined(SK_DEBUG))
+//    #error "inconsistent GR_DEBUG and SK_DEBUG"
+#endif
+
+#if GR_SCALAR_IS_FIXED
+    #ifdef SK_SCALAR_IS_FIXED
+        #define SK_SCALAR_IS_GR_SCALAR  1
+    #else
+        #define SK_SCALAR_IS_GR_SCALAR  0
+    #endif
+    #define SkScalarToGrScalar(x)       SkScalarToFixed(x)
+
+#elif GR_SCALAR_IS_FLOAT
+
+    #ifdef SK_SCALAR_IS_FLOAT
+        #define SK_SCALAR_IS_GR_SCALAR  1
+    #else
+        #define SK_SCALAR_IS_GR_SCALAR  0
+    #endif
+    #define SkScalarToGrScalar(x)       SkScalarToFloat(x)
+
+#else 
+    #error "Ganesh scalar type not defined"
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Sk to Gr Type conversions
+
+// Verify that SkPoint and GrPoint are compatible if using the same scalar type
+#if 0/*SK_SCALAR_IS_GR_SCALAR*/
+    GR_STATIC_ASSERT(sizeof(SkPoint) == sizeof(GrPoint));
+    GR_STATIC_ASSERT(offsetof(SkPoint,fX) == offsetof(GrPoint,fX)));
+    GR_STATIC_ASSERT(offsetof(SkPoint,fY) == offsetof(GrPoint,fY)));
+#endif
+
+GR_STATIC_ASSERT((int)GrSamplerState::kClamp_WrapMode == (int)SkShader::kClamp_TileMode);
+GR_STATIC_ASSERT((int)GrSamplerState::kRepeat_WrapMode ==(
+                 int)SkShader::kRepeat_TileMode);
+GR_STATIC_ASSERT((int)GrSamplerState::kMirror_WrapMode == 
+                 (int)SkShader::kMirror_TileMode);
+
+#define sk_tile_mode_to_grwrap(X) ((GrSamplerState::WrapMode)(X))
+
+GR_STATIC_ASSERT((int)GrGpu::kZero_BlendCoeff == (int)SkXfermode::kZero_Coeff);
+GR_STATIC_ASSERT((int)GrGpu::kOne_BlendCoeff  == (int)SkXfermode::kOne_Coeff);
+GR_STATIC_ASSERT((int)GrGpu::kSC_BlendCoeff   == (int)SkXfermode::kSC_Coeff);
+GR_STATIC_ASSERT((int)GrGpu::kISC_BlendCoeff  == (int)SkXfermode::kISC_Coeff);
+GR_STATIC_ASSERT((int)GrGpu::kDC_BlendCoeff   == (int)SkXfermode::kDC_Coeff);
+GR_STATIC_ASSERT((int)GrGpu::kIDC_BlendCoeff  == (int)SkXfermode::kIDC_Coeff);
+GR_STATIC_ASSERT((int)GrGpu::kSA_BlendCoeff   == (int)SkXfermode::kSA_Coeff);
+GR_STATIC_ASSERT((int)GrGpu::kISA_BlendCoeff  == (int)SkXfermode::kISA_Coeff);
+GR_STATIC_ASSERT((int)GrGpu::kDA_BlendCoeff   == (int)SkXfermode::kDA_Coeff);
+GR_STATIC_ASSERT((int)GrGpu::kIDA_BlendCoeff  == (int)SkXfermode::kIDA_Coeff);
+
+#define sk_blend_to_grblend(X) ((GrGpu::BlendCoeff)(X))
+
+GR_STATIC_ASSERT((int)SkPath::kMove_Verb  == (int)GrPathIter::kMove_Command);
+GR_STATIC_ASSERT((int)SkPath::kLine_Verb  == (int)GrPathIter::kLine_Command);
+GR_STATIC_ASSERT((int)SkPath::kQuad_Verb  == (int)GrPathIter::kQuadratic_Command);
+GR_STATIC_ASSERT((int)SkPath::kCubic_Verb == (int)GrPathIter::kCubic_Command);
+GR_STATIC_ASSERT((int)SkPath::kClose_Verb == (int)GrPathIter::kClose_Command);
+GR_STATIC_ASSERT((int)SkPath::kDone_Verb  == (int)GrPathIter::kEnd_Command);
+
+#define sk_path_verb_to_gr_path_command(X) ((GrPathIter::Command)(X))
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkColorPriv.h"
+
+static inline GrRect Sk2Gr(const SkRect& src) {
+    return GrRect(SkScalarToGrScalar(src.fLeft),
+                  SkScalarToGrScalar(src.fTop),
+                  SkScalarToGrScalar(src.fRight),
+                  SkScalarToGrScalar(src.fBottom));
+}
+
+class SkGr {
+public:
+    static inline SkIRect& SetIRect(SkIRect* dst, const GrIRect& src) {
+        GR_STATIC_ASSERT(sizeof(*dst) == sizeof(src));
+        memcpy(dst, &src, sizeof(*dst));
+        return *dst;
+    }
+    
+    static inline GrIRect& SetIRect(GrIRect* dst, const SkIRect& src) {
+        GR_STATIC_ASSERT(sizeof(*dst) == sizeof(src));
+        memcpy(dst, &src, sizeof(*dst));
+        return *dst;
+    }
+    
+    /**
+     *  Convert the SkBitmap::Config to the corresponding PixelConfig, or
+     *  kUnknown_PixelConfig if the conversion cannot be done.
+     */
+    static GrTexture::PixelConfig BitmapConfig2PixelConfig(SkBitmap::Config,
+                                                        bool isOpaque);
+
+    static GrTexture::PixelConfig Bitmap2PixelConfig(const SkBitmap& bm) {
+        return BitmapConfig2PixelConfig(bm.config(), bm.isOpaque());
+    }
+
+    static void SkMatrix2GrMatrix(const SkMatrix& m, GrMatrix* g) {
+        g->setAll(SkScalarToGrScalar(m[0]),
+                  SkScalarToGrScalar(m[1]),
+                  SkScalarToGrScalar(m[2]),
+                  SkScalarToGrScalar(m[3]),
+                  SkScalarToGrScalar(m[4]),
+                  SkScalarToGrScalar(m[5]),
+                  SkScalarToGrScalar(m[6]),
+                  SkScalarToGrScalar(m[7]),
+                  SkScalarToGrScalar(m[8]));
+    }
+    
+    static GrColor SkColor2GrColor(SkColor c) {
+        SkPMColor pm = SkPreMultiplyColor(c);
+        unsigned r = SkGetPackedR32(pm);
+        unsigned g = SkGetPackedG32(pm);
+        unsigned b = SkGetPackedB32(pm);
+        unsigned a = SkGetPackedA32(pm);
+        return GrColorPackRGBA(r, g, b, a);
+    }
+
+    /**
+     *  This abandons all texture caches (for bitmaps and text) associated with
+     *  the gpu, and frees any associated skia caches. It differs from
+     *  deleteAllTextures in that it assumes that the gpu has lots its context,
+     *  and thus the associated HW textures are no longer valid
+     */
+    static void AbandonAllTextures(GrContext*);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Classes
+
+class SkGrPathIter : public GrPathIter {
+public:
+    SkGrPathIter(const SkPath& path) : fIter(path, false), fPath(path) {}
+    virtual Command next(GrPoint pts[]);
+    virtual Command next();
+    virtual void rewind();
+    virtual ConvexHint hint() const;
+private:
+    
+#if !SK_SCALAR_IS_GR_SCALAR
+    SkPoint             fPoints[4];
+#endif
+    SkPath::Iter        fIter;
+    const SkPath&       fPath;
+};
+
+class SkGrClipIterator : public GrClipIterator {
+public:
+    void reset(const SkRegion& clip) {
+        fIter.reset(clip);
+        this->invalidateBoundsCache();
+    }
+    
+    // overrides
+    
+    virtual bool isDone() { return fIter.done(); }
+    virtual void getRect(GrIRect* rect) {
+        SkGr::SetIRect(rect, fIter.rect());
+    }
+    virtual void next() { fIter.next(); }
+    virtual void rewind() { fIter.rewind(); }
+    virtual void computeBounds(GrIRect* bounds);
+
+private:
+    SkRegion::Iterator fIter;
+};
+
+class SkGlyphCache;
+
+class SkGrFontScaler : public GrFontScaler {
+public:
+    explicit SkGrFontScaler(SkGlyphCache* strike);
+    virtual ~SkGrFontScaler();
+
+    // overrides
+    virtual const GrKey* getKey();
+    virtual bool getPackedGlyphBounds(GrGlyph::PackedID, GrIRect* bounds);
+    virtual bool getPackedGlyphImage(GrGlyph::PackedID, int width, int height,
+                                     int rowBytes, void* image);
+    virtual bool getGlyphPath(uint16_t glyphID, GrPath*);
+
+private:
+    SkGlyphCache* fStrike;
+    GrKey*  fKey;
+//    DECLARE_INSTANCE_COUNTER(SkGrFontScaler);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Helper functions
+
+GrTextureEntry* sk_gr_create_bitmap_texture(GrContext* ctx, 
+                                            GrTextureKey* key,
+                                            const GrSamplerState& sampler,
+                                            const SkBitmap& bitmap);
+
+void sk_gr_set_paint(GrContext* ctx, const SkPaint& paint, bool justAlpha = false);
+
+#endif
diff --git a/include/gpu/SkGrTexturePixelRef.h b/include/gpu/SkGrTexturePixelRef.h
new file mode 100644
index 0000000000..1f5133f86d
--- /dev/null
+++ b/include/gpu/SkGrTexturePixelRef.h
@@ -0,0 +1,50 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef SkGrTexturePixelRef_DEFINED
+#define SkGrTexturePixelRef_DEFINED
+
+#include "SkPixelRef.h"
+#include "GrGpu.h"
+
+class SkGrTexturePixelRef : public SkPixelRef {
+public:
+            SkGrTexturePixelRef(GrTexture*);
+    virtual ~SkGrTexturePixelRef();
+
+    // override from SkPixelRef
+    virtual SkGpuTexture* getTexture() { return (SkGpuTexture*)fTexture; }
+
+protected:
+    // override from SkPixelRef
+    virtual void* onLockPixels(SkColorTable** ptr) {
+        if (ptr) {
+            *ptr = NULL;
+        }
+        return NULL;
+    }
+
+    // override from SkPixelRef
+    virtual void onUnlockPixels() {}
+
+private:
+    GrTexture*  fTexture;
+    typedef SkPixelRef INHERITED;
+};
+
+#endif
+
diff --git a/include/utils/SkEGLContext.h b/include/utils/SkEGLContext.h
index 98eeec4ceb..4b17be1d4a 100644
--- a/include/utils/SkEGLContext.h
+++ b/include/utils/SkEGLContext.h
@@ -1,6 +1,11 @@
+#ifndef SkEGLContext_DEFINED
+#define SkEGLContext_DEFINED
 
-#include <AGL/agl.h>
+#include "SkTypes.h"
 
+/**
+ *  Create an offscreen opengl context
+ */
 class SkEGLContext {
 public:
 	SkEGLContext();
@@ -9,61 +14,7 @@ public:
 	bool init(int width, int height);
 
 private:
-	AGLContext	fAGLContext;
+	void* fContext;
 };
 
-SkEGLContext::SkEGLContext() : fAGLContext(NULL) {
-}
-
-SkEGLContext::~SkEGLContext() {
-	if (fAGLContext) {
-		aglDestroyContext(fAGLContext);
-	}
-}
-
-bool SkEGLContext::init(int width, int height) {
-	GLint major, minor;
-	AGLContext ctx;
-
-	aglGetVersion(&major, &minor);
-	SkDebugf("---- agl version %d %d\n", major, minor);
-
-	const GLint pixelAttrs[] = {
-		AGL_RGBA,
-		AGL_STENCIL_SIZE, 8,
-/*
-		AGL_SAMPLE_BUFFERS_ARB, 1,
-		AGL_MULTISAMPLE,
-		AGL_SAMPLES_ARB, 2,
-*/
-		AGL_ACCELERATED,
-		AGL_NONE
-	};
-	AGLPixelFormat format = aglChoosePixelFormat(NULL, 0, pixelAttrs);
-	//AGLPixelFormat format = aglCreatePixelFormat(pixelAttrs);
-	SkDebugf("----- agl format %p\n", format);
-	ctx = aglCreateContext(format, NULL);
-	SkDebugf("----- agl context %p\n", ctx);
-	aglDestroyPixelFormat(format);
-
-	SkDebugf("---- sizeof aglcontext %d\n", sizeof(AGLContext));
-/*
-	static const GLint interval = 1;
-	aglSetInteger(ctx, AGL_SWAP_INTERVAL, &interval);
-*/
-
-	aglSetCurrentContext(ctx);
-	fAGLContext = ctx;
-
-	// Now create our FBO render target
-
-	GLuint fboID;
-	GLuint cbID;
-	glGenFramebuffersEXT(1, &fboID);
-	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboID);
-	glGenRenderbuffers(1, &cbID);
-	glBindRenderbuffer(GL_RENDERBUFFER, cbID);
-	glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA, width, height);
-	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, cbID);
-	return true;
-}
+#endif