void onOnceBeforeDraw() override { struct Rect : public Prim { SkRect draw(SkCanvas* canvas, const SkPaint& paint) override { SkRect rect = SkRect::MakeXYWH(0, 0, 50, 50); canvas->drawRect(rect, paint); return rect; } }; struct Circle : public Prim { SkRect draw(SkCanvas* canvas, const SkPaint& paint) override { static const SkScalar radius = 25; canvas->drawCircle(radius, radius, radius, paint); return SkRect::MakeXYWH(0, 0, 2 * radius, 2 * radius); } }; struct RRect : public Prim { SkRect draw(SkCanvas* canvas, const SkPaint& paint) override { SkRRect rrect; rrect.setRectXY(SkRect::MakeXYWH(0, 0, 50, 50), 10, 10); canvas->drawRRect(rrect, paint); return rrect.getBounds(); } }; struct DRRect : public Prim { SkRect draw(SkCanvas* canvas, const SkPaint& paint) override { SkRRect outerRRect; outerRRect.setRectXY(SkRect::MakeXYWH(0, 0, 50, 50), 5, 5); SkRRect innerRRect; innerRRect.setRectXY(SkRect::MakeXYWH(5, 8, 35, 30), 8, 3); canvas->drawDRRect(outerRRect, innerRRect, paint); return outerRRect.getBounds(); } }; struct Path : public Prim { SkRect draw(SkCanvas* canvas, const SkPaint& paint) override { SkPath path; path.addCircle(15, 15, 10); path.addOval(SkRect::MakeXYWH(2, 2, 22, 37)); path.setFillType(SkPath::kEvenOdd_FillType); canvas->drawPath(path, paint); return path.getBounds(); } }; struct Points : public Prim { Points(SkCanvas::PointMode mode) : fMode(mode) {} SkRect draw(SkCanvas* canvas, const SkPaint& paint) override { SkRandom random; SkPoint points[500]; SkRect bounds = SkRect::MakeWH(50, 50); int count = SkToInt(SK_ARRAY_COUNT(points)); if (SkCanvas::kPoints_PointMode != fMode) { count = SkTMin(count, 10); } for (int p = 0; p < count; ++p) { points[p].fX = random.nextUScalar1() * bounds.width(); points[p].fY = random.nextUScalar1() * bounds.width(); } canvas->drawPoints(fMode, count, points, paint); return bounds; } SkCanvas::PointMode fMode; }; struct Text : public Prim { SkRect draw(SkCanvas* canvas, const SkPaint& origPaint) override { SkPaint paint = origPaint; paint.setTextSize(30.f); this->setFont(&paint); const char* text = this->text(); static const SkVector offset = SkVector::Make(10, 10); canvas->drawText(text, strlen(text), offset.fX, offset.fY, paint); SkRect bounds; paint.measureText(text, strlen(text), &bounds); bounds.offset(offset); return bounds; } virtual void setFont(SkPaint* paint) { sk_tool_utils::set_portable_typeface(paint); } virtual const char* text() const { return "Hello, Skia!"; } }; struct BmpText : public Text { void setFont(SkPaint* paint) override { if (!fTypeface) { fTypeface.reset(GetResourceAsTypeface("/fonts/Funkster.ttf")); } paint->setTypeface(fTypeface); } const char* text() const override { return "Hi, Skia!"; } SkAutoTUnref<SkTypeface> fTypeface; }; fPrims.push_back(SkNEW(Rect)); fPrims.push_back(SkNEW(Circle)); fPrims.push_back(SkNEW(RRect)); fPrims.push_back(SkNEW(DRRect)); fPrims.push_back(SkNEW(Path)); fPrims.push_back(SkNEW(Points(SkCanvas::kPoints_PointMode))); fPrims.push_back(SkNEW(Points(SkCanvas::kLines_PointMode))); fPrims.push_back(SkNEW(Points(SkCanvas::kPolygon_PointMode))); fPrims.push_back(SkNEW(Text)); fPrims.push_back(SkNEW(BmpText)); }
static SkPicture* rtree_factory(const int width, const int height, int* recordingFlags) { *recordingFlags |= SkPicture::kOptimizeForClippedPlayback_RecordingFlag; return SkNEW(SkPicture); }
static SkEmptyTypeface* Create() { return SkNEW(SkEmptyTypeface); }
SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override { return SkNEW(EmptyLocalizedStrings); };
/** * Render the SKP file(s) within inputPath, writing their bitmap images into outputDir. * * @param inputPath path to an individual SKP file, or a directory of SKP files * @param outputDir if not NULL, write the image(s) generated into this directory * @param renderer PictureRenderer to use to render the SKPs * @param jsonSummaryPtr if not NULL, add the image(s) generated to this summary */ static bool render_picture(const SkString& inputPath, const SkString* outputDir, sk_tools::PictureRenderer& renderer, sk_tools::ImageResultsSummary *jsonSummaryPtr) { int diffs[256] = {0}; SkBitmap* bitmap = NULL; renderer.setJsonSummaryPtr(jsonSummaryPtr); bool success = render_picture_internal(inputPath, FLAGS_writeWholeImage ? NULL : outputDir, renderer, FLAGS_validate || FLAGS_writeWholeImage ? &bitmap : NULL); if (!success || ((FLAGS_validate || FLAGS_writeWholeImage) && bitmap == NULL)) { SkDebugf("Failed to draw the picture.\n"); SkDELETE(bitmap); return false; } if (FLAGS_validate) { SkBitmap* referenceBitmap = NULL; sk_tools::PictureRenderer* referenceRenderer; // If the renderer uses a BBoxHierarchy, then the reference renderer // will be the same renderer, without the bbh. AutoRestoreBbhType arbbh; if (sk_tools::PictureRenderer::kNone_BBoxHierarchyType != renderer.getBBoxHierarchyType()) { referenceRenderer = &renderer; referenceRenderer->ref(); // to match auto unref below arbbh.set(referenceRenderer, sk_tools::PictureRenderer::kNone_BBoxHierarchyType); } else { referenceRenderer = SkNEW(sk_tools::SimplePictureRenderer); } SkAutoTUnref<sk_tools::PictureRenderer> aurReferenceRenderer(referenceRenderer); success = render_picture_internal(inputPath, NULL, *referenceRenderer, &referenceBitmap); if (!success || NULL == referenceBitmap || NULL == referenceBitmap->getPixels()) { SkDebugf("Failed to draw the reference picture.\n"); SkDELETE(bitmap); SkDELETE(referenceBitmap); return false; } if (success && (bitmap->width() != referenceBitmap->width())) { SkDebugf("Expected image width: %i, actual image width %i.\n", referenceBitmap->width(), bitmap->width()); SkDELETE(bitmap); SkDELETE(referenceBitmap); return false; } if (success && (bitmap->height() != referenceBitmap->height())) { SkDebugf("Expected image height: %i, actual image height %i", referenceBitmap->height(), bitmap->height()); SkDELETE(bitmap); SkDELETE(referenceBitmap); return false; } for (int y = 0; success && y < bitmap->height(); y++) { for (int x = 0; success && x < bitmap->width(); x++) { int diff = MaxByteDiff(*referenceBitmap->getAddr32(x, y), *bitmap->getAddr32(x, y)); SkASSERT(diff >= 0 && diff <= 255); diffs[diff]++; if (diff > FLAGS_maxComponentDiff) { SkDebugf("Expected pixel at (%i %i) exceedds maximum " "component diff of %i: 0x%x, actual 0x%x\n", x, y, FLAGS_maxComponentDiff, *referenceBitmap->getAddr32(x, y), *bitmap->getAddr32(x, y)); SkDELETE(bitmap); SkDELETE(referenceBitmap); return false; } } } SkDELETE(referenceBitmap); for (int i = 1; i <= 255; ++i) { if(diffs[i] > 0) { SkDebugf("Number of pixels with max diff of %i is %i\n", i, diffs[i]); } } } if (FLAGS_writeWholeImage) { sk_tools::force_all_opaque(*bitmap); if (NULL != jsonSummaryPtr) { // TODO(epoger): This is a hacky way of constructing the filename associated with the // image checksum; we basically are repeating the logic of make_output_filepath() // and code below here, within here. // It would be better for the filename (without outputDir) to be passed in here, // and used both for the checksum file and writing into outputDir. // // TODO(epoger): what about including the config type within hashFilename? That way, // we could combine results of different config types without conflicting filenames. SkString hashFilename; sk_tools::get_basename(&hashFilename, inputPath); hashFilename.remove(hashFilename.size() - 4, 4); // Remove ".skp" hashFilename.append(".png"); jsonSummaryPtr->add(hashFilename.c_str(), *bitmap); } if (NULL != outputDir) { SkString inputFilename; sk_tools::get_basename(&inputFilename, inputPath); SkString outputPath; make_output_filepath(&outputPath, *outputDir, inputFilename); outputPath.append(".png"); if (!SkImageEncoder::EncodeFile(outputPath.c_str(), *bitmap, SkImageEncoder::kPNG_Type, 100)) { SkDebugf("Failed to draw the picture.\n"); success = false; } } } SkDELETE(bitmap); return success; }
SkImageDecoder* SkImageDecoder::Factory(SkStream* stream) { return SkNEW(SkImageDecoder_WIC); }
static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { return SkNEW(SkSimpleColorFilter); }
static const GrGLInterface* create_es_interface(GrGLVersion version, const GrGLExtensions& extensions) { if (version < GR_GL_VER(2,0)) { return NULL; } GrGLInterface* interface = SkNEW(GrGLInterface); interface->fBindingsExported = kES_GrGLBinding; interface->fActiveTexture = glActiveTexture; interface->fAttachShader = glAttachShader; interface->fBindAttribLocation = glBindAttribLocation; interface->fBindBuffer = glBindBuffer; interface->fBindTexture = glBindTexture; interface->fBindVertexArray = glBindVertexArrayOES; interface->fBlendColor = glBlendColor; interface->fBlendFunc = glBlendFunc; interface->fBufferData = glBufferData; interface->fBufferSubData = glBufferSubData; interface->fClear = glClear; interface->fClearColor = glClearColor; interface->fClearStencil = glClearStencil; interface->fColorMask = glColorMask; interface->fCompileShader = glCompileShader; interface->fCompressedTexImage2D = glCompressedTexImage2D; interface->fCopyTexSubImage2D = glCopyTexSubImage2D; interface->fCreateProgram = glCreateProgram; interface->fCreateShader = glCreateShader; interface->fCullFace = glCullFace; interface->fDeleteBuffers = glDeleteBuffers; interface->fDeleteProgram = glDeleteProgram; interface->fDeleteShader = glDeleteShader; interface->fDeleteTextures = glDeleteTextures; interface->fDeleteVertexArrays = glDeleteVertexArraysOES; interface->fDepthMask = glDepthMask; interface->fDisable = glDisable; interface->fDisableVertexAttribArray = glDisableVertexAttribArray; interface->fDrawArrays = glDrawArrays; interface->fDrawElements = glDrawElements; interface->fEnable = glEnable; interface->fEnableVertexAttribArray = glEnableVertexAttribArray; interface->fFinish = glFinish; interface->fFlush = glFlush; interface->fFrontFace = glFrontFace; interface->fGenBuffers = glGenBuffers; interface->fGenerateMipmap = glGenerateMipmap; interface->fGenTextures = glGenTextures; interface->fGenVertexArrays = glGenVertexArraysOES; interface->fGetBufferParameteriv = glGetBufferParameteriv; interface->fGetError = glGetError; interface->fGetIntegerv = glGetIntegerv; interface->fGetProgramInfoLog = glGetProgramInfoLog; interface->fGetProgramiv = glGetProgramiv; interface->fGetShaderInfoLog = glGetShaderInfoLog; interface->fGetShaderiv = glGetShaderiv; interface->fGetString = glGetString; #if GL_ES_VERSION_30 interface->fGetStringi = glGetStringi; #else interface->fGetStringi = (GrGLGetStringiProc) eglGetProcAddress("glGetStringi"); #endif interface->fGetUniformLocation = glGetUniformLocation; interface->fLineWidth = glLineWidth; interface->fLinkProgram = glLinkProgram; interface->fPixelStorei = glPixelStorei; interface->fReadPixels = glReadPixels; interface->fScissor = glScissor; #if GR_GL_USE_NEW_SHADER_SOURCE_SIGNATURE interface->fShaderSource = (GrGLShaderSourceProc) glShaderSource; #else interface->fShaderSource = glShaderSource; #endif interface->fStencilFunc = glStencilFunc; interface->fStencilFuncSeparate = glStencilFuncSeparate; interface->fStencilMask = glStencilMask; interface->fStencilMaskSeparate = glStencilMaskSeparate; interface->fStencilOp = glStencilOp; interface->fStencilOpSeparate = glStencilOpSeparate; interface->fTexImage2D = glTexImage2D; interface->fTexParameteri = glTexParameteri; interface->fTexParameteriv = glTexParameteriv; interface->fTexSubImage2D = glTexSubImage2D; if (version >= GR_GL_VER(3,0)) { #if GL_ES_VERSION_3_0 interface->fTexStorage2D = glTexStorage2D; #else interface->fTexStorage2D = (GrGLTexStorage2DProc) eglGetProcAddress("glTexStorage2D"); #endif } else { #if GL_EXT_texture_storage interface->fTexStorage2D = glTexStorage2DEXT; #else interface->fTexStorage2D = (GrGLTexStorage2DProc) eglGetProcAddress("glTexStorage2DEXT"); #endif } #if GL_EXT_discard_framebuffer interface->fDiscardFramebuffer = glDiscardFramebufferEXT; #endif interface->fUniform1f = glUniform1f; interface->fUniform1i = glUniform1i; interface->fUniform1fv = glUniform1fv; interface->fUniform1iv = glUniform1iv; interface->fUniform2f = glUniform2f; interface->fUniform2i = glUniform2i; interface->fUniform2fv = glUniform2fv; interface->fUniform2iv = glUniform2iv; interface->fUniform3f = glUniform3f; interface->fUniform3i = glUniform3i; interface->fUniform3fv = glUniform3fv; interface->fUniform3iv = glUniform3iv; interface->fUniform4f = glUniform4f; interface->fUniform4i = glUniform4i; interface->fUniform4fv = glUniform4fv; interface->fUniform4iv = glUniform4iv; interface->fUniformMatrix2fv = glUniformMatrix2fv; interface->fUniformMatrix3fv = glUniformMatrix3fv; interface->fUniformMatrix4fv = glUniformMatrix4fv; interface->fUseProgram = glUseProgram; interface->fVertexAttrib4fv = glVertexAttrib4fv; interface->fVertexAttribPointer = glVertexAttribPointer; interface->fViewport = glViewport; interface->fBindFramebuffer = glBindFramebuffer; interface->fBindRenderbuffer = glBindRenderbuffer; interface->fCheckFramebufferStatus = glCheckFramebufferStatus; interface->fDeleteFramebuffers = glDeleteFramebuffers; interface->fDeleteRenderbuffers = glDeleteRenderbuffers; interface->fFramebufferRenderbuffer = glFramebufferRenderbuffer; interface->fFramebufferTexture2D = glFramebufferTexture2D; #if GR_GL_IGNORE_ES3_MSAA if (extensions.has("GL_EXT_multisampled_render_to_texture")) { #if GL_EXT_multisampled_render_to_texture interface->fFramebufferTexture2DMultisample = glFramebufferTexture2DMultisampleEXT; interface->fRenderbufferStorageMultisample = glRenderbufferStorageMultisampleEXT; #else interface->fFramebufferTexture2DMultisample = (GrGLFramebufferTexture2DMultisampleProc) eglGetProcAddress("glFramebufferTexture2DMultisampleEXT"); interface->fRenderbufferStorageMultisample = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisampleEXT"); #endif } else if (extensions.has("GL_IMG_multisampled_render_to_texture")) { #if GL_IMG_multisampled_render_to_texture interface->fFramebufferTexture2DMultisample = glFramebufferTexture2DMultisampleIMG; interface->fRenderbufferStorageMultisample = glRenderbufferStorageMultisampleIMG; #else interface->fFramebufferTexture2DMultisample = (GrGLFramebufferTexture2DMultisampleProc) eglGetProcAddress("glFramebufferTexture2DMultisampleIMG"); interface->fRenderbufferStorageMultisample = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisampleIMG"); #endif } #else // GR_GL_IGNORE_ES3_MSAA if (version >= GR_GL_VER(3,0)) { #if GL_ES_VERSION_3_0 interface->fRenderbufferStorageMultisample = glRenderbufferStorageMultisample; interface->fBlitFramebuffer = glBlitFramebuffer; #else interface->fRenderbufferStorageMultisample = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisample"); interface->fBlitFramebuffer = (GrGLBlitFramebufferProc) eglGetProcAddress("glBlitFramebuffer"); #endif } if (extensions.has("GL_EXT_multisampled_render_to_texture")) { #if GL_EXT_multisampled_render_to_texture interface->fFramebufferTexture2DMultisample = glFramebufferTexture2DMultisampleEXT; interface->fRenderbufferStorageMultisampleES2EXT = glRenderbufferStorageMultisampleEXT; #else interface->fFramebufferTexture2DMultisample = (GrGLFramebufferTexture2DMultisampleProc) eglGetProcAddress("glFramebufferTexture2DMultisampleEXT"); interface->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisampleEXT"); #endif } else if (extensions.has("GL_IMG_multisampled_render_to_texture")) { #if GL_IMG_multisampled_render_to_texture interface->fFramebufferTexture2DMultisample = glFramebufferTexture2DMultisampleIMG; interface->fRenderbufferStorageMultisampleES2EXT = glRenderbufferStorageMultisampleIMG; #else interface->fFramebufferTexture2DMultisample = (GrGLFramebufferTexture2DMultisampleProc) eglGetProcAddress("glFramebufferTexture2DMultisampleIMG"); interface->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisampleIMG"); #endif } #endif // GR_GL_IGNORE_ES3_MSAA interface->fGenFramebuffers = glGenFramebuffers; interface->fGenRenderbuffers = glGenRenderbuffers; interface->fGetFramebufferAttachmentParameteriv = glGetFramebufferAttachmentParameteriv; interface->fGetRenderbufferParameteriv = glGetRenderbufferParameteriv; interface->fRenderbufferStorage = glRenderbufferStorage; #if GL_OES_mapbuffer interface->fMapBuffer = glMapBufferOES; interface->fUnmapBuffer = glUnmapBufferOES; #else interface->fMapBuffer = (GrGLMapBufferProc) eglGetProcAddress("glMapBufferOES"); interface->fUnmapBuffer = (GrGLUnmapBufferProc) eglGetProcAddress("glUnmapBufferOES"); #endif return interface; }
static const GrGLInterface* create_desktop_interface(GrGLVersion version, const GrGLExtensions& extensions) { // Currently this assumes a 4.4 context or later. Supporting lower GL versions would require // getting suffixed versions of pointers for supported extensions. if (version < GR_GL_VER(4,4)) { return NULL; } GrGLInterface* interface = SkNEW(GrGLInterface); interface->fBindingsExported = kDesktop_GrGLBinding; interface->fActiveTexture = (GrGLActiveTextureProc) eglGetProcAddress("glActiveTexture"); interface->fAttachShader = (GrGLAttachShaderProc) eglGetProcAddress("glAttachShader"); interface->fBeginQuery = (GrGLBeginQueryProc) eglGetProcAddress("glBeginQuery"); interface->fBindAttribLocation = (GrGLBindAttribLocationProc) eglGetProcAddress("glBindAttribLocation"); interface->fBindBuffer = (GrGLBindBufferProc) eglGetProcAddress("glBindBuffer"); interface->fBindFragDataLocation = (GrGLBindFragDataLocationProc) eglGetProcAddress("glBindFragDataLocation"); interface->fBindFragDataLocationIndexed = (GrGLBindFragDataLocationIndexedProc) eglGetProcAddress("glBindFragDataLocationIndexed"); interface->fBindFramebuffer = (GrGLBindFramebufferProc) eglGetProcAddress("glBindFramebuffer"); interface->fBindRenderbuffer = (GrGLBindRenderbufferProc) eglGetProcAddress("glBindRenderbuffer"); interface->fBindTexture = (GrGLBindTextureProc) eglGetProcAddress("glBindTexture"); interface->fBindVertexArray = (GrGLBindVertexArrayProc) eglGetProcAddress("glBindVertexArray"); interface->fBlendColor = (GrGLBlendColorProc) eglGetProcAddress("glBlendColor"); interface->fBlendFunc = (GrGLBlendFuncProc) eglGetProcAddress("glBlendFunc"); interface->fBlitFramebuffer = (GrGLBlitFramebufferProc) eglGetProcAddress("glBlitFramebuffer"); interface->fBufferData = (GrGLBufferDataProc) eglGetProcAddress("glBufferData"); interface->fBufferSubData = (GrGLBufferSubDataProc) eglGetProcAddress("glBufferSubData"); interface->fCheckFramebufferStatus = (GrGLCheckFramebufferStatusProc) eglGetProcAddress("glCheckFramebufferStatus"); interface->fClear = (GrGLClearProc) eglGetProcAddress("glClear"); interface->fClearColor = (GrGLClearColorProc) eglGetProcAddress("glClearColor"); interface->fClearStencil = (GrGLClearStencilProc) eglGetProcAddress("glClearStencil"); interface->fClientActiveTexture = (GrGLClientActiveTextureProc) eglGetProcAddress("glClientActiveTexture"); interface->fColorMask = (GrGLColorMaskProc) eglGetProcAddress("glColorMask"); interface->fCompileShader = (GrGLCompileShaderProc) eglGetProcAddress("glCompileShader"); interface->fCompressedTexImage2D = (GrGLCompressedTexImage2DProc) eglGetProcAddress("glCompressedTexImage2D"); interface->fCopyTexSubImage2D = (GrGLCopyTexSubImage2DProc) eglGetProcAddress("glCopyTexSubImage2D"); interface->fCreateProgram = (GrGLCreateProgramProc) eglGetProcAddress("glCreateProgram"); interface->fCreateShader = (GrGLCreateShaderProc) eglGetProcAddress("glCreateShader"); interface->fCullFace = (GrGLCullFaceProc) eglGetProcAddress("glCullFace"); interface->fDeleteBuffers = (GrGLDeleteBuffersProc) eglGetProcAddress("glDeleteBuffers"); interface->fDeleteFramebuffers = (GrGLDeleteFramebuffersProc) eglGetProcAddress("glDeleteFramebuffers"); interface->fDeleteProgram = (GrGLDeleteProgramProc) eglGetProcAddress("glDeleteProgram"); interface->fDeleteQueries = (GrGLDeleteQueriesProc) eglGetProcAddress("glDeleteQueries"); interface->fDeleteRenderbuffers = (GrGLDeleteRenderbuffersProc) eglGetProcAddress("glDeleteRenderbuffers"); interface->fDeleteShader = (GrGLDeleteShaderProc) eglGetProcAddress("glDeleteShader"); interface->fDeleteTextures = (GrGLDeleteTexturesProc) eglGetProcAddress("glDeleteTextures"); interface->fDeleteVertexArrays = (GrGLDeleteVertexArraysProc) eglGetProcAddress("glDeleteVertexArrays"); interface->fDepthMask = (GrGLDepthMaskProc) eglGetProcAddress("glDepthMask"); interface->fDisable = (GrGLDisableProc) eglGetProcAddress("glDisable"); interface->fDisableClientState = (GrGLDisableClientStateProc) eglGetProcAddress("glDisableClientState"); interface->fDisableVertexAttribArray = (GrGLDisableVertexAttribArrayProc) eglGetProcAddress("glDisableVertexAttribArray"); interface->fDrawArrays = (GrGLDrawArraysProc) eglGetProcAddress("glDrawArrays"); interface->fDrawBuffer = (GrGLDrawBufferProc) eglGetProcAddress("glDrawBuffer"); interface->fDrawBuffers = (GrGLDrawBuffersProc) eglGetProcAddress("glDrawBuffers"); interface->fDrawElements = (GrGLDrawElementsProc) eglGetProcAddress("glDrawElements"); interface->fEnable = (GrGLEnableProc) eglGetProcAddress("glEnable"); interface->fEnableClientState = (GrGLEnableClientStateProc) eglGetProcAddress("glEnableClientState"); interface->fEnableVertexAttribArray = (GrGLEnableVertexAttribArrayProc) eglGetProcAddress("glEnableVertexAttribArray"); interface->fEndQuery = (GrGLEndQueryProc) eglGetProcAddress("glEndQuery"); interface->fFinish = (GrGLFinishProc) eglGetProcAddress("glFinish"); interface->fFlush = (GrGLFlushProc) eglGetProcAddress("glFlush"); interface->fFramebufferRenderbuffer = (GrGLFramebufferRenderbufferProc) eglGetProcAddress("glFramebufferRenderbuffer"); interface->fFramebufferTexture2D = (GrGLFramebufferTexture2DProc) eglGetProcAddress("glFramebufferTexture2D"); interface->fFrontFace = (GrGLFrontFaceProc) eglGetProcAddress("glFrontFace"); interface->fGenBuffers = (GrGLGenBuffersProc) eglGetProcAddress("glGenBuffers"); interface->fGenFramebuffers = (GrGLGenFramebuffersProc) eglGetProcAddress("glGenFramebuffers"); interface->fGenerateMipmap = (GrGLGenerateMipmapProc) eglGetProcAddress("glGenerateMipmap"); interface->fGenQueries = (GrGLGenQueriesProc) eglGetProcAddress("glGenQueries"); interface->fGenRenderbuffers = (GrGLGenRenderbuffersProc) eglGetProcAddress("glGenRenderbuffers"); interface->fGenTextures = (GrGLGenTexturesProc) eglGetProcAddress("glGenTextures"); interface->fGenVertexArrays = (GrGLGenVertexArraysProc) eglGetProcAddress("glGenVertexArrays"); interface->fGetBufferParameteriv = (GrGLGetBufferParameterivProc) eglGetProcAddress("glGetBufferParameteriv"); interface->fGetError = (GrGLGetErrorProc) eglGetProcAddress("glGetError"); interface->fGetFramebufferAttachmentParameteriv = (GrGLGetFramebufferAttachmentParameterivProc) eglGetProcAddress("glGetFramebufferAttachmentParameteriv"); interface->fGetIntegerv = (GrGLGetIntegervProc) eglGetProcAddress("glGetIntegerv"); interface->fGetQueryObjecti64v = (GrGLGetQueryObjecti64vProc) eglGetProcAddress("glGetQueryObjecti64v"); interface->fGetQueryObjectiv = (GrGLGetQueryObjectivProc) eglGetProcAddress("glGetQueryObjectiv"); interface->fGetQueryObjectui64v = (GrGLGetQueryObjectui64vProc) eglGetProcAddress("glGetQueryObjectui64v"); interface->fGetQueryObjectuiv = (GrGLGetQueryObjectuivProc) eglGetProcAddress("glGetQueryObjectuiv"); interface->fGetQueryiv = (GrGLGetQueryivProc) eglGetProcAddress("glGetQueryiv"); interface->fGetProgramInfoLog = (GrGLGetProgramInfoLogProc) eglGetProcAddress("glGetProgramInfoLog"); interface->fGetProgramiv = (GrGLGetProgramivProc) eglGetProcAddress("glGetProgramiv"); interface->fGetRenderbufferParameteriv = (GrGLGetRenderbufferParameterivProc) eglGetProcAddress("glGetRenderbufferParameteriv"); interface->fGetShaderInfoLog = (GrGLGetShaderInfoLogProc) eglGetProcAddress("glGetShaderInfoLog"); interface->fGetShaderiv = (GrGLGetShaderivProc) eglGetProcAddress("glGetShaderiv"); interface->fGetString = (GrGLGetStringProc) eglGetProcAddress("glGetString"); interface->fGetStringi = (GrGLGetStringiProc) eglGetProcAddress("glGetStringi"); interface->fGetTexLevelParameteriv = (GrGLGetTexLevelParameterivProc) eglGetProcAddress("glGetTexLevelParameteriv"); interface->fGetUniformLocation = (GrGLGetUniformLocationProc) eglGetProcAddress("glGetUniformLocation"); interface->fLineWidth = (GrGLLineWidthProc) eglGetProcAddress("glLineWidth"); interface->fLinkProgram = (GrGLLinkProgramProc) eglGetProcAddress("glLinkProgram"); interface->fLoadIdentity = (GrGLLoadIdentityProc) eglGetProcAddress("glLoadIdentity"); interface->fLoadMatrixf = (GrGLLoadMatrixfProc) eglGetProcAddress("glLoadMatrixf"); interface->fMapBuffer = (GrGLMapBufferProc) eglGetProcAddress("glMapBuffer"); interface->fMatrixMode = (GrGLMatrixModeProc) eglGetProcAddress("glMatrixMode"); interface->fPixelStorei = (GrGLPixelStoreiProc) eglGetProcAddress("glPixelStorei"); interface->fQueryCounter = (GrGLQueryCounterProc) eglGetProcAddress("glQueryCounter"); interface->fReadBuffer = (GrGLReadBufferProc) eglGetProcAddress("glReadBuffer"); interface->fReadPixels = (GrGLReadPixelsProc) eglGetProcAddress("glReadPixels"); interface->fRenderbufferStorage = (GrGLRenderbufferStorageProc) eglGetProcAddress("glRenderbufferStorage"); interface->fRenderbufferStorageMultisample = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisample"); interface->fScissor = (GrGLScissorProc) eglGetProcAddress("glScissor"); interface->fShaderSource = (GrGLShaderSourceProc) eglGetProcAddress("glShaderSource"); interface->fStencilFunc = (GrGLStencilFuncProc) eglGetProcAddress("glStencilFunc"); interface->fStencilFuncSeparate = (GrGLStencilFuncSeparateProc) eglGetProcAddress("glStencilFuncSeparate"); interface->fStencilMask = (GrGLStencilMaskProc) eglGetProcAddress("glStencilMask"); interface->fStencilMaskSeparate = (GrGLStencilMaskSeparateProc) eglGetProcAddress("glStencilMaskSeparate"); interface->fStencilOp = (GrGLStencilOpProc) eglGetProcAddress("glStencilOp"); interface->fStencilOpSeparate = (GrGLStencilOpSeparateProc) eglGetProcAddress("glStencilOpSeparate"); interface->fTexGenf = (GrGLTexGenfProc) eglGetProcAddress("glTexGenf"); interface->fTexGenfv = (GrGLTexGenfvProc) eglGetProcAddress("glTexGenfv"); interface->fTexGeni = (GrGLTexGeniProc) eglGetProcAddress("glTexGeni"); interface->fTexImage2D = (GrGLTexImage2DProc) eglGetProcAddress("glTexImage2D"); interface->fTexParameteri = (GrGLTexParameteriProc) eglGetProcAddress("glTexParameteri"); interface->fTexParameteriv = (GrGLTexParameterivProc) eglGetProcAddress("glTexParameteriv"); interface->fTexSubImage2D = (GrGLTexSubImage2DProc) eglGetProcAddress("glTexSubImage2D"); interface->fTexStorage2D = (GrGLTexStorage2DProc) eglGetProcAddress("glTexStorage2D"); interface->fUniform1f = (GrGLUniform1fProc) eglGetProcAddress("glUniform1f"); interface->fUniform1i = (GrGLUniform1iProc) eglGetProcAddress("glUniform1i"); interface->fUniform1fv = (GrGLUniform1fvProc) eglGetProcAddress("glUniform1fv"); interface->fUniform1iv = (GrGLUniform1ivProc) eglGetProcAddress("glUniform1iv"); interface->fUniform2f = (GrGLUniform2fProc) eglGetProcAddress("glUniform2f"); interface->fUniform2i = (GrGLUniform2iProc) eglGetProcAddress("glUniform2i"); interface->fUniform2fv = (GrGLUniform2fvProc) eglGetProcAddress("glUniform2fv"); interface->fUniform2iv = (GrGLUniform2ivProc) eglGetProcAddress("glUniform2iv"); interface->fUniform3f = (GrGLUniform3fProc) eglGetProcAddress("glUniform3f"); interface->fUniform3i = (GrGLUniform3iProc) eglGetProcAddress("glUniform3i"); interface->fUniform3fv = (GrGLUniform3fvProc) eglGetProcAddress("glUniform3fv"); interface->fUniform3iv = (GrGLUniform3ivProc) eglGetProcAddress("glUniform3iv"); interface->fUniform4f = (GrGLUniform4fProc) eglGetProcAddress("glUniform4f"); interface->fUniform4i = (GrGLUniform4iProc) eglGetProcAddress("glUniform4i"); interface->fUniform4fv = (GrGLUniform4fvProc) eglGetProcAddress("glUniform4fv"); interface->fUniform4iv = (GrGLUniform4ivProc) eglGetProcAddress("glUniform4iv"); interface->fUniformMatrix2fv = (GrGLUniformMatrix2fvProc) eglGetProcAddress("glUniformMatrix2fv"); interface->fUniformMatrix3fv = (GrGLUniformMatrix3fvProc) eglGetProcAddress("glUniformMatrix3fv"); interface->fUniformMatrix4fv = (GrGLUniformMatrix4fvProc) eglGetProcAddress("glUniformMatrix4fv"); interface->fUnmapBuffer = (GrGLUnmapBufferProc) eglGetProcAddress("glUnmapBuffer"); interface->fUseProgram = (GrGLUseProgramProc) eglGetProcAddress("glUseProgram"); interface->fVertexAttrib4fv = (GrGLVertexAttrib4fvProc) eglGetProcAddress("glVertexAttrib4fv"); interface->fVertexAttribPointer = (GrGLVertexAttribPointerProc) eglGetProcAddress("glVertexAttribPointer"); interface->fVertexPointer = (GrGLVertexPointerProc) eglGetProcAddress("glVertexPointer"); interface->fViewport = (GrGLViewportProc) eglGetProcAddress("glViewport"); if (extensions.has("GL_NV_path_rendering")) { interface->fPathCommands = (GrGLPathCommandsProc) eglGetProcAddress("glPathCommandsNV"); interface->fPathCoords = (GrGLPathCoordsProc) eglGetProcAddress("glPathCoordsNV"); interface->fPathSubCommands = (GrGLPathSubCommandsProc) eglGetProcAddress("glPathSubCommandsNV"); interface->fPathSubCoords = (GrGLPathSubCoordsProc) eglGetProcAddress("glPathSubCoordsNV"); interface->fPathString = (GrGLPathStringProc) eglGetProcAddress("glPathStringNV"); interface->fPathGlyphs = (GrGLPathGlyphsProc) eglGetProcAddress("glPathGlyphsNV"); interface->fPathGlyphRange = (GrGLPathGlyphRangeProc) eglGetProcAddress("glPathGlyphRangeNV"); interface->fWeightPaths = (GrGLWeightPathsProc) eglGetProcAddress("glWeightPathsNV"); interface->fCopyPath = (GrGLCopyPathProc) eglGetProcAddress("glCopyPathNV"); interface->fInterpolatePaths = (GrGLInterpolatePathsProc) eglGetProcAddress("glInterpolatePathsNV"); interface->fTransformPath = (GrGLTransformPathProc) eglGetProcAddress("glTransformPathNV"); interface->fPathParameteriv = (GrGLPathParameterivProc) eglGetProcAddress("glPathParameterivNV"); interface->fPathParameteri = (GrGLPathParameteriProc) eglGetProcAddress("glPathParameteriNV"); interface->fPathParameterfv = (GrGLPathParameterfvProc) eglGetProcAddress("glPathParameterfvNV"); interface->fPathParameterf = (GrGLPathParameterfProc) eglGetProcAddress("glPathParameterfNV"); interface->fPathDashArray = (GrGLPathDashArrayProc) eglGetProcAddress("glPathDashArrayNV"); interface->fGenPaths = (GrGLGenPathsProc) eglGetProcAddress("glGenPathsNV"); interface->fDeletePaths = (GrGLDeletePathsProc) eglGetProcAddress("glDeletePathsNV"); interface->fIsPath = (GrGLIsPathProc) eglGetProcAddress("glIsPathNV"); interface->fPathStencilFunc = (GrGLPathStencilFuncProc) eglGetProcAddress("glPathStencilFuncNV"); interface->fPathStencilDepthOffset = (GrGLPathStencilDepthOffsetProc) eglGetProcAddress("glPathStencilDepthOffsetNV"); interface->fStencilFillPath = (GrGLStencilFillPathProc) eglGetProcAddress("glStencilFillPathNV"); interface->fStencilStrokePath = (GrGLStencilStrokePathProc) eglGetProcAddress("glStencilStrokePathNV"); interface->fStencilFillPathInstanced = (GrGLStencilFillPathInstancedProc) eglGetProcAddress("glStencilFillPathInstancedNV"); interface->fStencilStrokePathInstanced = (GrGLStencilStrokePathInstancedProc) eglGetProcAddress("glStencilStrokePathInstancedNV"); interface->fPathCoverDepthFunc = (GrGLPathCoverDepthFuncProc) eglGetProcAddress("glPathCoverDepthFuncNV"); interface->fPathColorGen = (GrGLPathColorGenProc) eglGetProcAddress("glPathColorGenNV"); interface->fPathTexGen = (GrGLPathTexGenProc) eglGetProcAddress("glPathTexGenNV"); interface->fPathFogGen = (GrGLPathFogGenProc) eglGetProcAddress("glPathFogGenNV"); interface->fCoverFillPath = (GrGLCoverFillPathProc) eglGetProcAddress("glCoverFillPathNV"); interface->fCoverStrokePath = (GrGLCoverStrokePathProc) eglGetProcAddress("glCoverStrokePathNV"); interface->fCoverFillPathInstanced = (GrGLCoverFillPathInstancedProc) eglGetProcAddress("glCoverFillPathInstancedNV"); interface->fCoverStrokePathInstanced = (GrGLCoverStrokePathInstancedProc) eglGetProcAddress("glCoverStrokePathInstancedNV"); interface->fGetPathParameteriv = (GrGLGetPathParameterivProc) eglGetProcAddress("glGetPathParameterivNV"); interface->fGetPathParameterfv = (GrGLGetPathParameterfvProc) eglGetProcAddress("glGetPathParameterfvNV"); interface->fGetPathCommands = (GrGLGetPathCommandsProc) eglGetProcAddress("glGetPathCommandsNV"); interface->fGetPathCoords = (GrGLGetPathCoordsProc) eglGetProcAddress("glGetPathCoordsNV"); interface->fGetPathDashArray = (GrGLGetPathDashArrayProc) eglGetProcAddress("glGetPathDashArrayNV"); interface->fGetPathMetrics = (GrGLGetPathMetricsProc) eglGetProcAddress("glGetPathMetricsNV"); interface->fGetPathMetricRange = (GrGLGetPathMetricRangeProc) eglGetProcAddress("glGetPathMetricRangeNV"); interface->fGetPathSpacing = (GrGLGetPathSpacingProc) eglGetProcAddress("glGetPathSpacingNV"); interface->fGetPathColorGeniv = (GrGLGetPathColorGenivProc) eglGetProcAddress("glGetPathColorGenivNV"); interface->fGetPathColorGenfv = (GrGLGetPathColorGenfvProc) eglGetProcAddress("glGetPathColorGenfvNV"); interface->fGetPathTexGeniv = (GrGLGetPathTexGenivProc) eglGetProcAddress("glGetPathTexGenivNV"); interface->fGetPathTexGenfv = (GrGLGetPathTexGenfvProc) eglGetProcAddress("glGetPathTexGenfvNV"); interface->fIsPointInFillPath = (GrGLIsPointInFillPathProc) eglGetProcAddress("glIsPointInFillPathNV"); interface->fIsPointInStrokePath = (GrGLIsPointInStrokePathProc) eglGetProcAddress("glIsPointInStrokePathNV"); interface->fGetPathLength = (GrGLGetPathLengthProc) eglGetProcAddress("glGetPathLengthNV"); interface->fPointAlongPath = (GrGLPointAlongPathProc) eglGetProcAddress("glPointAlongPathNV"); } return interface; }
// As a template argument, this must have external linkage. SkRemotableFontIdentitySet* sk_remotable_font_identity_set_new() { return SkNEW(SkRemotableFontIdentitySet); }
static GrGLInterface* create_es_interface(GrGLVersion version, GrGLExtensions* extensions) { if (version < GR_GL_VER(2,0)) { return NULL; } GrGLInterface* interface = SkNEW(GrGLInterface); interface->fStandard = kGLES_GrGLStandard; GrGLInterface::Functions* functions = &interface->fFunctions; functions->fActiveTexture = glActiveTexture; functions->fAttachShader = glAttachShader; functions->fBindAttribLocation = glBindAttribLocation; functions->fBindBuffer = glBindBuffer; functions->fBindTexture = glBindTexture; functions->fBindVertexArray = (*(PFNGLBINDVERTEXARRAYOESPROC)eglGetProcAddress("glBindVertexArrayOES"));// glBindVertexArrayOES; functions->fBlendColor = glBlendColor; functions->fBlendFunc = glBlendFunc; functions->fBufferData = glBufferData; functions->fBufferSubData = glBufferSubData; functions->fClear = glClear; functions->fClearColor = glClearColor; functions->fClearStencil = glClearStencil; functions->fColorMask = glColorMask; functions->fCompileShader = glCompileShader; functions->fCompressedTexImage2D = glCompressedTexImage2D; functions->fCompressedTexSubImage2D = glCompressedTexSubImage2D; functions->fCopyTexSubImage2D = glCopyTexSubImage2D; functions->fCreateProgram = glCreateProgram; functions->fCreateShader = glCreateShader; functions->fCullFace = glCullFace; functions->fDeleteBuffers = glDeleteBuffers; functions->fDeleteProgram = glDeleteProgram; functions->fDeleteShader = glDeleteShader; functions->fDeleteTextures = glDeleteTextures; functions->fDeleteVertexArrays = (*(PFNGLDELETEVERTEXARRAYSOESPROC)eglGetProcAddress("glDeleteVertexArraysOES")); functions->fDepthMask = glDepthMask; functions->fDisable = glDisable; functions->fDisableVertexAttribArray = glDisableVertexAttribArray; functions->fDrawArrays = glDrawArrays; functions->fDrawElements = glDrawElements; functions->fEnable = glEnable; functions->fEnableVertexAttribArray = glEnableVertexAttribArray; functions->fFinish = glFinish; functions->fFlush = glFlush; functions->fFrontFace = glFrontFace; functions->fGenBuffers = glGenBuffers; functions->fGenerateMipmap = glGenerateMipmap; functions->fGenTextures = glGenTextures; functions->fGenVertexArrays = (*(PFNGLGENVERTEXARRAYSOESPROC)eglGetProcAddress("glGenVertexArraysOES")); functions->fGetBufferParameteriv = glGetBufferParameteriv; functions->fGetError = glGetError; functions->fGetIntegerv = glGetIntegerv; functions->fGetProgramInfoLog = glGetProgramInfoLog; functions->fGetProgramiv = glGetProgramiv; functions->fGetShaderInfoLog = glGetShaderInfoLog; functions->fGetShaderiv = glGetShaderiv; functions->fGetString = glGetString; #if GL_ES_VERSION_3_0 functions->fGetStringi = glGetStringi; #else functions->fGetStringi = (GrGLGetStringiProc) eglGetProcAddress("glGetStringi"); #endif functions->fGetUniformLocation = glGetUniformLocation; functions->fLineWidth = glLineWidth; functions->fLinkProgram = glLinkProgram; functions->fPixelStorei = glPixelStorei; functions->fReadPixels = glReadPixels; functions->fScissor = glScissor; #if GR_GL_USE_NEW_SHADER_SOURCE_SIGNATURE functions->fShaderSource = (GrGLShaderSourceProc) glShaderSource; #else functions->fShaderSource = glShaderSource; #endif functions->fStencilFunc = glStencilFunc; functions->fStencilFuncSeparate = glStencilFuncSeparate; functions->fStencilMask = glStencilMask; functions->fStencilMaskSeparate = glStencilMaskSeparate; functions->fStencilOp = glStencilOp; functions->fStencilOpSeparate = glStencilOpSeparate; functions->fTexImage2D = glTexImage2D; functions->fTexParameteri = glTexParameteri; functions->fTexParameteriv = glTexParameteriv; functions->fTexSubImage2D = glTexSubImage2D; if (version >= GR_GL_VER(3,0)) { #if GL_ES_VERSION_3_0 functions->fTexStorage2D = glTexStorage2D; #else functions->fTexStorage2D = (GrGLTexStorage2DProc) eglGetProcAddress("glTexStorage2D"); #endif } else { #if GL_EXT_texture_storage functions->fTexStorage2D = glTexStorage2DEXT; #else functions->fTexStorage2D = (GrGLTexStorage2DProc) eglGetProcAddress("glTexStorage2DEXT"); #endif } #if GL_EXT_discard_framebuffer functions->fDiscardFramebuffer = (*(PFNGLDISCARDFRAMEBUFFEREXTPROC)eglGetProcAddress("glDiscardFramebufferEXT")); #endif functions->fUniform1f = glUniform1f; functions->fUniform1i = glUniform1i; functions->fUniform1fv = glUniform1fv; functions->fUniform1iv = glUniform1iv; functions->fUniform2f = glUniform2f; functions->fUniform2i = glUniform2i; functions->fUniform2fv = glUniform2fv; functions->fUniform2iv = glUniform2iv; functions->fUniform3f = glUniform3f; functions->fUniform3i = glUniform3i; functions->fUniform3fv = glUniform3fv; functions->fUniform3iv = glUniform3iv; functions->fUniform4f = glUniform4f; functions->fUniform4i = glUniform4i; functions->fUniform4fv = glUniform4fv; functions->fUniform4iv = glUniform4iv; functions->fUniformMatrix2fv = glUniformMatrix2fv; functions->fUniformMatrix3fv = glUniformMatrix3fv; functions->fUniformMatrix4fv = glUniformMatrix4fv; functions->fUseProgram = glUseProgram; functions->fVertexAttrib4fv = glVertexAttrib4fv; functions->fVertexAttribPointer = glVertexAttribPointer; functions->fViewport = glViewport; functions->fBindFramebuffer = glBindFramebuffer; functions->fBindRenderbuffer = glBindRenderbuffer; functions->fCheckFramebufferStatus = glCheckFramebufferStatus; functions->fDeleteFramebuffers = glDeleteFramebuffers; functions->fDeleteRenderbuffers = glDeleteRenderbuffers; functions->fFramebufferRenderbuffer = glFramebufferRenderbuffer; functions->fFramebufferTexture2D = glFramebufferTexture2D; if (version >= GR_GL_VER(3,0)) { #if GL_ES_VERSION_3_0 functions->fRenderbufferStorageMultisample = glRenderbufferStorageMultisample; functions->fBlitFramebuffer = glBlitFramebuffer; #else functions->fRenderbufferStorageMultisample = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisample"); functions->fBlitFramebuffer = (GrGLBlitFramebufferProc) eglGetProcAddress("glBlitFramebuffer"); #endif } if (extensions->has("GL_EXT_multisampled_render_to_texture")) { #if GL_EXT_multisampled_render_to_texture functions->fFramebufferTexture2DMultisample = glFramebufferTexture2DMultisampleEXT; functions->fRenderbufferStorageMultisampleES2EXT = glRenderbufferStorageMultisampleEXT; #else functions->fFramebufferTexture2DMultisample = (GrGLFramebufferTexture2DMultisampleProc) eglGetProcAddress("glFramebufferTexture2DMultisampleEXT"); functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisampleEXT"); #endif } else if (extensions->has("GL_IMG_multisampled_render_to_texture")) { #if GL_IMG_multisampled_render_to_texture functions->fFramebufferTexture2DMultisample = (GrGLFramebufferTexture2DMultisampleProc) eglGetProcAddress("glFramebufferTexture2DMultisampleIMG");; functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisampleIMG"); #else functions->fFramebufferTexture2DMultisample = (GrGLFramebufferTexture2DMultisampleProc) eglGetProcAddress("glFramebufferTexture2DMultisampleIMG"); functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisampleIMG"); #endif } functions->fGenFramebuffers = glGenFramebuffers; functions->fGenRenderbuffers = glGenRenderbuffers; functions->fGetFramebufferAttachmentParameteriv = glGetFramebufferAttachmentParameteriv; functions->fGetRenderbufferParameteriv = glGetRenderbufferParameteriv; functions->fRenderbufferStorage = glRenderbufferStorage; #if GL_OES_mapbuffer functions->fMapBuffer = glMapBufferOES; functions->fUnmapBuffer = glUnmapBufferOES; #else functions->fMapBuffer = (GrGLMapBufferProc) eglGetProcAddress("glMapBufferOES"); functions->fUnmapBuffer = (GrGLUnmapBufferProc) eglGetProcAddress("glUnmapBufferOES"); #endif if (version >= GR_GL_VER(3,0)) { #if GL_ES_VERSION_3_0 functions->fMapBufferRange = glMapBufferRange; functions->fFlushMappedBufferRange = glFlushMappedBufferRange; #else functions->fMapBufferRange = (GrGLMapBufferRangeProc) eglGetProcAddress("glMapBufferRange"); functions->fFlushMappedBufferRange = (GrGLFlushMappedBufferRangeProc) eglGetProcAddress("glFlushMappedBufferRange"); #endif } else if (extensions->has("GL_EXT_map_buffer_range")) { #if GL_EXT_map_buffer_range functions->fMapBufferRange = glMapBufferRangeEXT; functions->fFlushMappedBufferRange = glFlushMappedBufferRangeEXT; #else functions->fMapBufferRange = (GrGLMapBufferRangeProc) eglGetProcAddress("glMapBufferRangeEXT"); functions->fFlushMappedBufferRange = (GrGLFlushMappedBufferRangeProc) eglGetProcAddress("glFlushMappedBufferRangeEXT"); #endif } if (extensions->has("GL_EXT_debug_marker")) { functions->fInsertEventMarker = (GrGLInsertEventMarkerProc) eglGetProcAddress("glInsertEventMarker"); functions->fPushGroupMarker = (GrGLInsertEventMarkerProc) eglGetProcAddress("glPushGroupMarker"); functions->fPopGroupMarker = (GrGLPopGroupMarkerProc) eglGetProcAddress("glPopGroupMarker"); // The below check is here because a device has been found that has the extension string but // returns NULL from the eglGetProcAddress for the functions if (NULL == functions->fInsertEventMarker || NULL == functions->fPushGroupMarker || NULL == functions->fPopGroupMarker) { extensions->remove("GL_EXT_debug_marker"); } } #if GL_ES_VERSION_3_0 functions->fInvalidateFramebuffer = glInvalidateFramebuffer; functions->fInvalidateSubFramebuffer = glInvalidateSubFramebuffer; #else functions->fInvalidateFramebuffer = (GrGLInvalidateFramebufferProc) eglGetProcAddress("glInvalidateFramebuffer"); functions->fInvalidateSubFramebuffer = (GrGLInvalidateSubFramebufferProc) eglGetProcAddress("glInvalidateSubFramebuffer"); #endif functions->fInvalidateBufferData = (GrGLInvalidateBufferDataProc) eglGetProcAddress("glInvalidateBufferData"); functions->fInvalidateBufferSubData = (GrGLInvalidateBufferSubDataProc) eglGetProcAddress("glInvalidateBufferSubData"); functions->fInvalidateTexImage = (GrGLInvalidateTexImageProc) eglGetProcAddress("glInvalidateTexImage"); functions->fInvalidateTexSubImage = (GrGLInvalidateTexSubImageProc) eglGetProcAddress("glInvalidateTexSubImage"); return interface; }
GrGLXferProcessor* ShaderPDXferProcessor::createGLInstance() const { return SkNEW(GLShaderPDXferProcessor); }
GrGLXferProcessor* PorterDuffXferProcessor::createGLInstance() const { return SkNEW(GLPorterDuffXferProcessor); }
sk_tools::PictureRenderer* parseRenderer(SkString& error, PictureTool tool) { error.reset(); if (FLAGS_multi <= 0) { error.printf("--multi must be > 0, was %i", FLAGS_multi); return NULL; } bool useTiles = false; const char* widthString = NULL; const char* heightString = NULL; bool isPowerOf2Mode = false; bool isCopyMode = false; const char* mode = NULL; bool gridSupported = false; SkAutoTUnref<sk_tools::PictureRenderer> renderer; if (FLAGS_mode.count() >= 1) { mode = FLAGS_mode[0]; if (0 == strcmp(mode, "record")) { renderer.reset(SkNEW(sk_tools::RecordPictureRenderer)); gridSupported = true; // undocumented } else if (0 == strcmp(mode, "clone")) { renderer.reset(sk_tools::CreatePictureCloneRenderer()); } else if (0 == strcmp(mode, "tile") || 0 == strcmp(mode, "pow2tile") || 0 == strcmp(mode, "copyTile")) { useTiles = true; if (0 == strcmp(mode, "pow2tile")) { isPowerOf2Mode = true; } else if (0 == strcmp(mode, "copyTile")) { isCopyMode = true; } else { gridSupported = true; } if (FLAGS_mode.count() < 2) { error.printf("Missing width for --mode %s\n", mode); return NULL; } widthString = FLAGS_mode[1]; if (FLAGS_mode.count() < 3) { error.printf("Missing height for --mode %s\n", mode); return NULL; } heightString = FLAGS_mode[2]; } else if (0 == strcmp(mode, "playbackCreation") && kBench_PictureTool == tool) { renderer.reset(SkNEW(sk_tools::PlaybackCreationRenderer)); gridSupported = true; // undocumented } else if (0 == strcmp(mode, "gatherPixelRefs") && kBench_PictureTool == tool) { renderer.reset(sk_tools::CreateGatherPixelRefsRenderer()); } else if (0 == strcmp(mode, "rerecord") && kRender_PictureTool == tool) { renderer.reset(SkNEW(sk_tools::RecordPictureRenderer)); // Allow 'mode' to be set to 'simple', but do not create a renderer, so we can // ensure that pipe does not override a mode besides simple. The renderer will // be created below. } else if (0 != strcmp(mode, "simple")) { error.printf("%s is not a valid mode for --mode\n", mode); return NULL; } } if (useTiles) { SkASSERT(NULL == renderer); SkAutoTUnref<sk_tools::TiledPictureRenderer> tiledRenderer; if (isCopyMode) { int xTiles = -1; int yTiles = -1; if (FLAGS_tiles.count() > 0) { if (FLAGS_tiles.count() != 2) { error.printf("--tiles requires an x value and a y value.\n"); return NULL; } xTiles = atoi(FLAGS_tiles[0]); yTiles = atoi(FLAGS_tiles[1]); } int x, y; if (xTiles != -1 && yTiles != -1) { x = xTiles; y = yTiles; if (x <= 0 || y <= 0) { error.printf("--tiles must be given values > 0\n"); return NULL; } } else { x = y = 4; } tiledRenderer.reset(SkNEW_ARGS(sk_tools::CopyTilesRenderer, (x, y))); } else if (FLAGS_multi > 1) { tiledRenderer.reset(SkNEW_ARGS(sk_tools::MultiCorePictureRenderer, (FLAGS_multi))); } else { tiledRenderer.reset(SkNEW(sk_tools::TiledPictureRenderer)); } if (isPowerOf2Mode) { int minWidth = atoi(widthString); if (!SkIsPow2(minWidth) || minWidth < 0) { SkString err; error.printf("-mode %s must be given a width" " value that is a power of two\n", mode); return NULL; } tiledRenderer->setTileMinPowerOf2Width(minWidth); } else if (sk_tools::is_percentage(widthString)) { if (isCopyMode) { error.printf("--mode %s does not support percentages.\n", mode); return NULL; } tiledRenderer->setTileWidthPercentage(atof(widthString)); if (!(tiledRenderer->getTileWidthPercentage() > 0)) { error.printf("--mode %s must be given a width percentage > 0\n", mode); return NULL; } } else { tiledRenderer->setTileWidth(atoi(widthString)); if (!(tiledRenderer->getTileWidth() > 0)) { error.printf("--mode %s must be given a width > 0\n", mode); return NULL; } } if (sk_tools::is_percentage(heightString)) { if (isCopyMode) { error.printf("--mode %s does not support percentages.\n", mode); return NULL; } tiledRenderer->setTileHeightPercentage(atof(heightString)); if (!(tiledRenderer->getTileHeightPercentage() > 0)) { error.printf("--mode %s must be given a height percentage > 0\n", mode); return NULL; } } else { tiledRenderer->setTileHeight(atoi(heightString)); if (!(tiledRenderer->getTileHeight() > 0)) { SkString err; error.printf("--mode %s must be given a height > 0\n", mode); return NULL; } } renderer.reset(tiledRenderer.detach()); if (FLAGS_pipe) { error.printf("Pipe rendering is currently not compatible with tiling.\n" "Turning off pipe.\n"); } } else { // useTiles if (FLAGS_multi > 1) { error.printf("Multithreaded drawing requires tiled rendering.\n"); return NULL; } if (FLAGS_pipe) { if (renderer != NULL) { error.printf("Pipe is incompatible with other modes.\n"); return NULL; } renderer.reset(SkNEW(sk_tools::PipePictureRenderer)); } } if (NULL == renderer) { renderer.reset(SkNEW(sk_tools::SimplePictureRenderer)); } if (FLAGS_viewport.count() > 0) { if (FLAGS_viewport.count() != 2) { error.printf("--viewport requires a width and a height.\n"); return NULL; } SkISize viewport; viewport.fWidth = atoi(FLAGS_viewport[0]); viewport.fHeight = atoi(FLAGS_viewport[1]); renderer->setViewport(viewport); } sk_tools::PictureRenderer::SkDeviceTypes deviceType = sk_tools::PictureRenderer::kBitmap_DeviceType; #if SK_SUPPORT_GPU int sampleCount = 0; #endif if (FLAGS_config.count() > 0) { if (0 == strcmp(FLAGS_config[0], "8888")) { deviceType = sk_tools::PictureRenderer::kBitmap_DeviceType; } #if SK_SUPPORT_GPU else if (0 == strcmp(FLAGS_config[0], "gpu")) { deviceType = sk_tools::PictureRenderer::kGPU_DeviceType; if (FLAGS_multi > 1) { error.printf("GPU not compatible with multithreaded tiling.\n"); return NULL; } } else if (0 == strcmp(FLAGS_config[0], "msaa4")) { deviceType = sk_tools::PictureRenderer::kGPU_DeviceType; if (FLAGS_multi > 1) { error.printf("GPU not compatible with multithreaded tiling.\n"); return NULL; } sampleCount = 4; } else if (0 == strcmp(FLAGS_config[0], "msaa16")) { deviceType = sk_tools::PictureRenderer::kGPU_DeviceType; if (FLAGS_multi > 1) { error.printf("GPU not compatible with multithreaded tiling.\n"); return NULL; } sampleCount = 16; } else if (0 == strcmp(FLAGS_config[0], "nvprmsaa4")) { deviceType = sk_tools::PictureRenderer::kNVPR_DeviceType; if (FLAGS_multi > 1) { error.printf("GPU not compatible with multithreaded tiling.\n"); return NULL; } sampleCount = 4; } else if (0 == strcmp(FLAGS_config[0], "nvprmsaa16")) { deviceType = sk_tools::PictureRenderer::kNVPR_DeviceType; if (FLAGS_multi > 1) { error.printf("GPU not compatible with multithreaded tiling.\n"); return NULL; } sampleCount = 16; } #if SK_ANGLE else if (0 == strcmp(FLAGS_config[0], "angle")) { deviceType = sk_tools::PictureRenderer::kAngle_DeviceType; if (FLAGS_multi > 1) { error.printf("Angle not compatible with multithreaded tiling.\n"); return NULL; } } #endif #if SK_MESA else if (0 == strcmp(FLAGS_config[0], "mesa")) { deviceType = sk_tools::PictureRenderer::kMesa_DeviceType; if (FLAGS_multi > 1) { error.printf("Mesa not compatible with multithreaded tiling.\n"); return NULL; } } #endif #endif else { error.printf("%s is not a valid mode for --config\n", FLAGS_config[0]); return NULL; } renderer->setDeviceType(deviceType); #if SK_SUPPORT_GPU renderer->setSampleCount(sampleCount); #endif } sk_tools::PictureRenderer::BBoxHierarchyType bbhType = sk_tools::PictureRenderer::kNone_BBoxHierarchyType; if (FLAGS_bbh.count() > 0) { const char* type = FLAGS_bbh[0]; if (0 == strcmp(type, "none")) { bbhType = sk_tools::PictureRenderer::kNone_BBoxHierarchyType; } else if (0 == strcmp(type, "quadtree")) { bbhType = sk_tools::PictureRenderer::kQuadTree_BBoxHierarchyType; } else if (0 == strcmp(type, "rtree")) { bbhType = sk_tools::PictureRenderer::kRTree_BBoxHierarchyType; } else if (0 == strcmp(type, "grid")) { if (!gridSupported) { error.printf("'--bbh grid' is not compatible with --mode=%s.\n", mode); return NULL; } bbhType = sk_tools::PictureRenderer::kTileGrid_BBoxHierarchyType; if (FLAGS_bbh.count() != 3) { error.printf("--bbh grid requires a width and a height.\n"); return NULL; } int gridWidth = atoi(FLAGS_bbh[1]); int gridHeight = atoi(FLAGS_bbh[2]); renderer->setGridSize(gridWidth, gridHeight); } else { error.printf("%s is not a valid value for --bbhType\n", type); return NULL; } if (FLAGS_pipe && sk_tools::PictureRenderer::kNone_BBoxHierarchyType != bbhType) { error.printf("--pipe and --bbh cannot be used together\n"); return NULL; } } renderer->setBBoxHierarchyType(bbhType); renderer->setScaleFactor(SkDoubleToScalar(FLAGS_scale)); return renderer.detach(); }
const GrGLInterface* GrGLCreateANGLEInterface() { static HMODULE ghANGLELib = NULL; if (NULL == ghANGLELib) { // We load the ANGLE library and never let it go ghANGLELib = LoadLibrary("libGLESv2.dll"); } if (NULL == ghANGLELib) { // We can't setup the interface correctly w/o the DLL return NULL; } GrGLInterface* interface = SkNEW(GrGLInterface); interface->fStandard = kGLES_GrGLStandard; GrGLInterface::Functions* functions = &interface->fFunctions; GET_PROC(ActiveTexture); GET_PROC(AttachShader); GET_PROC(BindAttribLocation); GET_PROC(BindBuffer); GET_PROC(BindTexture); functions->fBindVertexArray = (GrGLBindVertexArrayProc) eglGetProcAddress("glBindVertexArrayOES"); GET_PROC(BlendColor); GET_PROC(BlendFunc); GET_PROC(BufferData); GET_PROC(BufferSubData); GET_PROC(Clear); GET_PROC(ClearColor); GET_PROC(ClearStencil); GET_PROC(ColorMask); GET_PROC(CompileShader); GET_PROC(CompressedTexImage2D); GET_PROC(CopyTexSubImage2D); GET_PROC(CreateProgram); GET_PROC(CreateShader); GET_PROC(CullFace); GET_PROC(DeleteBuffers); GET_PROC(DeleteProgram); GET_PROC(DeleteShader); GET_PROC(DeleteTextures); functions->fDeleteVertexArrays = (GrGLDeleteVertexArraysProc) eglGetProcAddress("glDeleteVertexArraysOES"); GET_PROC(DepthMask); GET_PROC(Disable); GET_PROC(DisableVertexAttribArray); GET_PROC(DrawArrays); GET_PROC(DrawElements); GET_PROC(Enable); GET_PROC(EnableVertexAttribArray); GET_PROC(Finish); GET_PROC(Flush); GET_PROC(FrontFace); GET_PROC(GenBuffers); GET_PROC(GenerateMipmap); GET_PROC(GenTextures); functions->fGenVertexArrays = (GrGLGenVertexArraysProc) eglGetProcAddress("glGenVertexArraysOES"); GET_PROC(GetBufferParameteriv); GET_PROC(GetError); GET_PROC(GetIntegerv); GET_PROC(GetProgramInfoLog); GET_PROC(GetProgramiv); GET_PROC(GetShaderInfoLog); GET_PROC(GetShaderiv); GET_PROC(GetString); GET_PROC(GetUniformLocation); GET_PROC(LineWidth); GET_PROC(LinkProgram); GET_PROC(PixelStorei); GET_PROC(ReadPixels); GET_PROC(Scissor); GET_PROC(ShaderSource); GET_PROC(StencilFunc); GET_PROC(StencilFuncSeparate); GET_PROC(StencilMask); GET_PROC(StencilMaskSeparate); GET_PROC(StencilOp); GET_PROC(StencilOpSeparate); GET_PROC(TexImage2D); GET_PROC(TexParameteri); GET_PROC(TexParameteriv); GET_PROC(TexSubImage2D); #if GL_ARB_texture_storage GET_PROC(TexStorage2D); #elif GL_EXT_texture_storage functions->fTexStorage2D = (GrGLTexStorage2DProc) eglGetProcAddress("glTexStorage2DEXT"); #endif GET_PROC(Uniform1f); GET_PROC(Uniform1i); GET_PROC(Uniform1fv); GET_PROC(Uniform1iv); GET_PROC(Uniform2f); GET_PROC(Uniform2i); GET_PROC(Uniform2fv); GET_PROC(Uniform2iv); GET_PROC(Uniform3f); GET_PROC(Uniform3i); GET_PROC(Uniform3fv); GET_PROC(Uniform3iv); GET_PROC(Uniform4f); GET_PROC(Uniform4i); GET_PROC(Uniform4fv); GET_PROC(Uniform4iv); GET_PROC(UniformMatrix2fv); GET_PROC(UniformMatrix3fv); GET_PROC(UniformMatrix4fv); GET_PROC(UseProgram); GET_PROC(VertexAttrib4fv); GET_PROC(VertexAttribPointer); GET_PROC(Viewport); GET_PROC(BindFramebuffer); GET_PROC(BindRenderbuffer); GET_PROC(CheckFramebufferStatus); GET_PROC(DeleteFramebuffers); GET_PROC(DeleteRenderbuffers); GET_PROC(FramebufferRenderbuffer); GET_PROC(FramebufferTexture2D); GET_PROC(GenFramebuffers); GET_PROC(GenRenderbuffers); GET_PROC(GetFramebufferAttachmentParameteriv); GET_PROC(GetRenderbufferParameteriv); GET_PROC(RenderbufferStorage); functions->fMapBuffer = (GrGLMapBufferProc) eglGetProcAddress("glMapBufferOES"); functions->fUnmapBuffer = (GrGLUnmapBufferProc) eglGetProcAddress("glUnmapBufferOES"); #if GL_EXT_debug_marker functions->fInsertEventMarker = (GrGLInsertEventMarkerProc) eglGetProcAddress("glInsertEventMarkerEXT"); functions->fPushGroupMarker = (GrGLInsertEventMarkerProc) eglGetProcAddress("glPushGroupMarkerEXT"); functions->fPopGroupMarker = (GrGLPopGroupMarkerProc) eglGetProcAddress("glPopGropuMarkerEXT"); #endif interface->fExtensions.init(kGLES_GrGLStandard, interface->fFunctions.fGetString, interface->fFunctions.fGetStringi, interface->fFunctions.fGetIntegerv); return interface; }
const GrGLInterface* GrGLAssembleGLESInterface(void* ctx, GrGLGetProc get) { GET_PROC_LOCAL(GetString); if (NULL == GetString) { return NULL; } const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION)); GrGLVersion version = GrGLGetVersionFromString(verStr); if (version < GR_GL_VER(2,0)) { return NULL; } GET_PROC_LOCAL(GetIntegerv); GET_PROC_LOCAL(GetStringi); GrGLExtensions extensions; if (!extensions.init(kGLES_GrGLStandard, GetString, GetStringi, GetIntegerv)) { return NULL; } GrGLInterface* interface = SkNEW(GrGLInterface); GrGLInterface::Functions* functions = &interface->fFunctions; GET_PROC(ActiveTexture); GET_PROC(AttachShader); GET_PROC(BindAttribLocation); GET_PROC(BindBuffer); GET_PROC(BindTexture); GET_PROC_SUFFIX(BindVertexArray, OES); GET_PROC(BlendColor); GET_PROC(BlendFunc); GET_PROC(BufferData); GET_PROC(BufferSubData); GET_PROC(Clear); GET_PROC(ClearColor); GET_PROC(ClearStencil); GET_PROC(ColorMask); GET_PROC(CompileShader); GET_PROC(CompressedTexImage2D); GET_PROC(CompressedTexSubImage2D); GET_PROC(CopyTexSubImage2D); GET_PROC(CreateProgram); GET_PROC(CreateShader); GET_PROC(CullFace); GET_PROC(DeleteBuffers); GET_PROC(DeleteProgram); GET_PROC(DeleteShader); GET_PROC(DeleteTextures); GET_PROC_SUFFIX(DeleteVertexArrays, OES); GET_PROC(DepthMask); GET_PROC(Disable); GET_PROC(DisableVertexAttribArray); GET_PROC(DrawArrays); GET_PROC(DrawElements); GET_PROC(Enable); GET_PROC(EnableVertexAttribArray); GET_PROC(Finish); GET_PROC(Flush); GET_PROC(FrontFace); GET_PROC(GenBuffers); GET_PROC(GenerateMipmap); GET_PROC(GenTextures); GET_PROC_SUFFIX(GenVertexArrays, OES); GET_PROC(GetBufferParameteriv); GET_PROC(GetError); GET_PROC(GetIntegerv); GET_PROC(GetProgramInfoLog); GET_PROC(GetProgramiv); GET_PROC(GetShaderInfoLog); GET_PROC(GetShaderiv); GET_PROC(GetString); GET_PROC(GetStringi); GET_PROC(GetUniformLocation); GET_PROC(LineWidth); GET_PROC(LinkProgram); GET_PROC(PixelStorei); GET_PROC(ReadPixels); GET_PROC(Scissor); GET_PROC(ShaderSource); GET_PROC(StencilFunc); GET_PROC(StencilFuncSeparate); GET_PROC(StencilMask); GET_PROC(StencilMaskSeparate); GET_PROC(StencilOp); GET_PROC(StencilOpSeparate); GET_PROC(TexImage2D); GET_PROC(TexParameteri); GET_PROC(TexParameteriv); GET_PROC(TexSubImage2D); if (version >= GR_GL_VER(3,0)) { GET_PROC(TexStorage2D); } else { GET_PROC_SUFFIX(TexStorage2D, EXT); } GET_PROC_SUFFIX(DiscardFramebuffer, EXT); GET_PROC(Uniform1f); GET_PROC(Uniform1i); GET_PROC(Uniform1fv); GET_PROC(Uniform1iv); GET_PROC(Uniform2f); GET_PROC(Uniform2i); GET_PROC(Uniform2fv); GET_PROC(Uniform2iv); GET_PROC(Uniform3f); GET_PROC(Uniform3i); GET_PROC(Uniform3fv); GET_PROC(Uniform3iv); GET_PROC(Uniform4f); GET_PROC(Uniform4i); GET_PROC(Uniform4fv); GET_PROC(Uniform4iv); GET_PROC(UniformMatrix2fv); GET_PROC(UniformMatrix3fv); GET_PROC(UniformMatrix4fv); GET_PROC(UseProgram); GET_PROC(VertexAttrib1f); GET_PROC(VertexAttrib2fv); GET_PROC(VertexAttrib3fv); GET_PROC(VertexAttrib4fv); GET_PROC(VertexAttribPointer); GET_PROC(Viewport); GET_PROC(BindFramebuffer); GET_PROC(BindRenderbuffer); GET_PROC(CheckFramebufferStatus); GET_PROC(DeleteFramebuffers); GET_PROC(DeleteRenderbuffers); GET_PROC(FramebufferRenderbuffer); GET_PROC(FramebufferTexture2D); if (version >= GR_GL_VER(3,0)) { GET_PROC(RenderbufferStorageMultisample); GET_PROC(BlitFramebuffer); } if (extensions.has("GL_EXT_multisampled_render_to_texture")) { GET_PROC_SUFFIX(FramebufferTexture2DMultisample, EXT); functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleEXT"); } else if (extensions.has("GL_IMG_multisampled_render_to_texture")) { GET_PROC_SUFFIX(FramebufferTexture2DMultisample, IMG); functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleIMG"); } else if (extensions.has("GL_APPLE_framebuffer_multisample")) { functions->fRenderbufferStorageMultisampleES2APPLE = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleAPPLE"); GET_PROC_SUFFIX(ResolveMultisampleFramebuffer, APPLE); } GET_PROC(GenFramebuffers); GET_PROC(GenRenderbuffers); GET_PROC(GetFramebufferAttachmentParameteriv); GET_PROC(GetRenderbufferParameteriv); GET_PROC(RenderbufferStorage); GET_PROC_SUFFIX(MapBuffer, OES); GET_PROC_SUFFIX(UnmapBuffer, OES); if (version >= GR_GL_VER(3,0)) { GET_PROC(MapBufferRange); GET_PROC(FlushMappedBufferRange); } else if (extensions.has("GL_EXT_map_buffer_range")) { GET_PROC_SUFFIX(MapBufferRange, EXT); GET_PROC_SUFFIX(FlushMappedBufferRange, EXT); } if (extensions.has("GL_EXT_debug_marker")) { GET_PROC(InsertEventMarker); GET_PROC(PushGroupMarker); GET_PROC(PopGroupMarker); // The below check is here because a device has been found that has the extension string but // returns NULL from the eglGetProcAddress for the functions if (NULL == functions->fInsertEventMarker || NULL == functions->fPushGroupMarker || NULL == functions->fPopGroupMarker) { extensions.remove("GL_EXT_debug_marker"); } } GET_PROC(InvalidateFramebuffer); GET_PROC(InvalidateSubFramebuffer); GET_PROC(InvalidateBufferData); GET_PROC(InvalidateBufferSubData); GET_PROC(InvalidateTexImage); GET_PROC(InvalidateTexSubImage); if (version >= GR_GL_VER(3,1)) { GET_PROC(GetProgramResourceLocation); } if (extensions.has("GL_NV_path_rendering")) { GET_PROC_SUFFIX(MatrixLoadf, EXT); GET_PROC_SUFFIX(MatrixLoadIdentity, EXT); GET_PROC_SUFFIX(PathCommands, NV); GET_PROC_SUFFIX(PathCoords, NV); GET_PROC_SUFFIX(PathParameteri, NV); GET_PROC_SUFFIX(PathParameterf, NV); GET_PROC_SUFFIX(GenPaths, NV); GET_PROC_SUFFIX(DeletePaths, NV); GET_PROC_SUFFIX(IsPath, NV); GET_PROC_SUFFIX(PathStencilFunc, NV); GET_PROC_SUFFIX(StencilFillPath, NV); GET_PROC_SUFFIX(StencilStrokePath, NV); GET_PROC_SUFFIX(StencilFillPathInstanced, NV); GET_PROC_SUFFIX(StencilStrokePathInstanced, NV); GET_PROC_SUFFIX(CoverFillPath, NV); GET_PROC_SUFFIX(CoverStrokePath, NV); GET_PROC_SUFFIX(CoverFillPathInstanced, NV); GET_PROC_SUFFIX(CoverStrokePathInstanced, NV); GET_PROC_SUFFIX(StencilThenCoverFillPath, NV); GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV); GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV); GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV); GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV); GET_PROC_SUFFIX(PathMemoryGlyphIndexArray, NV); } interface->fStandard = kGLES_GrGLStandard; interface->fExtensions.swap(&extensions); return interface; }
SkPicture* SkPicture::clone() const { SkPicture* clonedPicture = SkNEW(SkPicture); clone(clonedPicture, 1); return clonedPicture; }
const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) { GET_PROC_LOCAL(GetString); GET_PROC_LOCAL(GetStringi); GET_PROC_LOCAL(GetIntegerv); // GetStringi may be NULL depending on the GL version. if (NULL == GetString || NULL == GetIntegerv) { return NULL; } const char* versionString = (const char*) GetString(GR_GL_VERSION); GrGLVersion glVer = GrGLGetVersionFromString(versionString); if (glVer < GR_GL_VER(1,5) || GR_GL_INVALID_VER == glVer) { // We must have array and element_array buffer objects. return NULL; } GrGLExtensions extensions; if (!extensions.init(kGL_GrGLStandard, GetString, GetStringi, GetIntegerv)) { return NULL; } GrGLInterface* interface = SkNEW(GrGLInterface()); GrGLInterface::Functions* functions = &interface->fFunctions; GET_PROC(ActiveTexture); GET_PROC(AttachShader); GET_PROC(BindAttribLocation); GET_PROC(BindBuffer); if (glVer >= GR_GL_VER(3,0)) { GET_PROC(BindFragDataLocation); } GET_PROC(BeginQuery); GET_PROC(BindTexture); GET_PROC(BlendFunc); if (glVer >= GR_GL_VER(1,4) || extensions.has("GL_ARB_imaging") || extensions.has("GL_EXT_blend_color")) { GET_PROC(BlendColor); } GET_PROC(BufferData); GET_PROC(BufferSubData); GET_PROC(Clear); GET_PROC(ClearColor); GET_PROC(ClearStencil); GET_PROC(ColorMask); GET_PROC(CompileShader); GET_PROC(CompressedTexImage2D); GET_PROC(CompressedTexSubImage2D); GET_PROC(CopyTexSubImage2D); GET_PROC(CreateProgram); GET_PROC(CreateShader); GET_PROC(CullFace); GET_PROC(DeleteBuffers); GET_PROC(DeleteProgram); GET_PROC(DeleteQueries); GET_PROC(DeleteShader); GET_PROC(DeleteTextures); GET_PROC(DepthMask); GET_PROC(Disable); GET_PROC(DisableVertexAttribArray); GET_PROC(DrawArrays); GET_PROC(DrawBuffer); GET_PROC(DrawBuffers); GET_PROC(DrawElements); GET_PROC(Enable); GET_PROC(EnableVertexAttribArray); GET_PROC(EndQuery); GET_PROC(Finish); GET_PROC(Flush); GET_PROC(FrontFace); GET_PROC(GenBuffers); GET_PROC(GenerateMipmap); GET_PROC(GetBufferParameteriv); GET_PROC(GetError); GET_PROC(GetIntegerv); GET_PROC(GetQueryObjectiv); GET_PROC(GetQueryObjectuiv); if (glVer >= GR_GL_VER(3,3) || extensions.has("GL_ARB_timer_query")) { GET_PROC(GetQueryObjecti64v); GET_PROC(GetQueryObjectui64v); GET_PROC(QueryCounter); } else if (extensions.has("GL_EXT_timer_query")) { GET_PROC_SUFFIX(GetQueryObjecti64v, EXT); GET_PROC_SUFFIX(GetQueryObjectui64v, EXT); } GET_PROC(GetQueryiv); GET_PROC(GetProgramInfoLog); GET_PROC(GetProgramiv); GET_PROC(GetShaderInfoLog); GET_PROC(GetShaderiv); GET_PROC(GetString); GET_PROC(GetStringi); GET_PROC(GetTexLevelParameteriv); GET_PROC(GenQueries); GET_PROC(GenTextures); GET_PROC(GetUniformLocation); GET_PROC(LineWidth); GET_PROC(LinkProgram); GET_PROC(MapBuffer); if (extensions.has("GL_EXT_direct_state_access")) { GET_PROC_SUFFIX(MatrixLoadf, EXT); GET_PROC_SUFFIX(MatrixLoadIdentity, EXT); } GET_PROC(PixelStorei); GET_PROC(ReadBuffer); GET_PROC(ReadPixels); GET_PROC(Scissor); GET_PROC(ShaderSource); GET_PROC(StencilFunc); GET_PROC(StencilFuncSeparate); GET_PROC(StencilMask); GET_PROC(StencilMaskSeparate); GET_PROC(StencilOp); GET_PROC(StencilOpSeparate); GET_PROC(TexImage2D); GET_PROC(TexParameteri); GET_PROC(TexParameteriv); if (glVer >= GR_GL_VER(4,2) || extensions.has("GL_ARB_texture_storage")) { GET_PROC(TexStorage2D); } else if (extensions.has("GL_EXT_texture_storage")) { GET_PROC_SUFFIX(TexStorage2D, EXT); } GET_PROC(TexSubImage2D); GET_PROC(Uniform1f); GET_PROC(Uniform1i); GET_PROC(Uniform1fv); GET_PROC(Uniform1iv); GET_PROC(Uniform2f); GET_PROC(Uniform2i); GET_PROC(Uniform2fv); GET_PROC(Uniform2iv); GET_PROC(Uniform3f); GET_PROC(Uniform3i); GET_PROC(Uniform3fv); GET_PROC(Uniform3iv); GET_PROC(Uniform4f); GET_PROC(Uniform4i); GET_PROC(Uniform4fv); GET_PROC(Uniform4iv); GET_PROC(UniformMatrix2fv); GET_PROC(UniformMatrix3fv); GET_PROC(UniformMatrix4fv); GET_PROC(UnmapBuffer); GET_PROC(UseProgram); GET_PROC(VertexAttrib1f); GET_PROC(VertexAttrib2fv); GET_PROC(VertexAttrib3fv); GET_PROC(VertexAttrib4fv); GET_PROC(VertexAttribPointer); GET_PROC(Viewport); GET_PROC(BindFragDataLocationIndexed); if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_vertex_array_object")) { // no ARB suffix for GL_ARB_vertex_array_object GET_PROC(BindVertexArray); GET_PROC(GenVertexArrays); GET_PROC(DeleteVertexArrays); } if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_map_buffer_range")) { GET_PROC(MapBufferRange); GET_PROC(FlushMappedBufferRange); } // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since // GL_ARB_framebuffer_object doesn't use ARB suffix.) if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_framebuffer_object")) { GET_PROC(GenFramebuffers); GET_PROC(GetFramebufferAttachmentParameteriv); GET_PROC(GetRenderbufferParameteriv); GET_PROC(BindFramebuffer); GET_PROC(FramebufferTexture2D); GET_PROC(CheckFramebufferStatus); GET_PROC(DeleteFramebuffers); GET_PROC(RenderbufferStorage); GET_PROC(GenRenderbuffers); GET_PROC(DeleteRenderbuffers); GET_PROC(FramebufferRenderbuffer); GET_PROC(BindRenderbuffer); GET_PROC(RenderbufferStorageMultisample); GET_PROC(BlitFramebuffer); } else if (extensions.has("GL_EXT_framebuffer_object")) { GET_PROC_SUFFIX(GenFramebuffers, EXT); GET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT); GET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT); GET_PROC_SUFFIX(BindFramebuffer, EXT); GET_PROC_SUFFIX(FramebufferTexture2D, EXT); GET_PROC_SUFFIX(CheckFramebufferStatus, EXT); GET_PROC_SUFFIX(DeleteFramebuffers, EXT); GET_PROC_SUFFIX(RenderbufferStorage, EXT); GET_PROC_SUFFIX(GenRenderbuffers, EXT); GET_PROC_SUFFIX(DeleteRenderbuffers, EXT); GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT); GET_PROC_SUFFIX(BindRenderbuffer, EXT); if (extensions.has("GL_EXT_framebuffer_multisample")) { GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT); } if (extensions.has("GL_EXT_framebuffer_blit")) { GET_PROC_SUFFIX(BlitFramebuffer, EXT); } } else { // we must have FBOs delete interface; return NULL; } if (extensions.has("GL_NV_path_rendering")) { GET_PROC_SUFFIX(PathCommands, NV); GET_PROC_SUFFIX(PathCoords, NV); GET_PROC_SUFFIX(PathParameteri, NV); GET_PROC_SUFFIX(PathParameterf, NV); GET_PROC_SUFFIX(GenPaths, NV); GET_PROC_SUFFIX(DeletePaths, NV); GET_PROC_SUFFIX(IsPath, NV); GET_PROC_SUFFIX(PathStencilFunc, NV); GET_PROC_SUFFIX(StencilFillPath, NV); GET_PROC_SUFFIX(StencilStrokePath, NV); GET_PROC_SUFFIX(StencilFillPathInstanced, NV); GET_PROC_SUFFIX(StencilStrokePathInstanced, NV); GET_PROC_SUFFIX(PathTexGen, NV); GET_PROC_SUFFIX(CoverFillPath, NV); GET_PROC_SUFFIX(CoverStrokePath, NV); GET_PROC_SUFFIX(CoverFillPathInstanced, NV); GET_PROC_SUFFIX(CoverStrokePathInstanced, NV); // NV_path_rendering v1.2 (These methods may not be present) GET_PROC_SUFFIX(StencilThenCoverFillPath, NV); GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV); GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV); GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV); // NV_path_rendering v1.3 (These methods may not be present) GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV); GET_PROC_SUFFIX(PathMemoryGlyphIndexArray, NV); } if (extensions.has("GL_EXT_debug_marker")) { GET_PROC_SUFFIX(InsertEventMarker, EXT); GET_PROC_SUFFIX(PushGroupMarker, EXT); GET_PROC_SUFFIX(PopGroupMarker, EXT); } if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_invalidate_subdata")) { GET_PROC(InvalidateBufferData); GET_PROC(InvalidateBufferSubData); GET_PROC(InvalidateFramebuffer); GET_PROC(InvalidateSubFramebuffer); GET_PROC(InvalidateTexImage); GET_PROC(InvalidateTexSubImage); } if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_program_interface_query")) { GET_PROC(GetProgramResourceLocation); } interface->fStandard = kGL_GrGLStandard; interface->fExtensions.swap(&extensions); return interface; }
int tool_main(int argc, char** argv) { SetupCrashHandler(); SkString usage; usage.printf("Time drawing .skp files.\n" "\tPossible arguments for --filter: [%s]\n\t\t[%s]", filterTypesUsage().c_str(), filterFlagsUsage().c_str()); SkCommandLineFlags::SetUsage(usage.c_str()); SkCommandLineFlags::Parse(argc, argv); if (FLAGS_repeat < 1) { SkString error; error.printf("--repeats must be >= 1. Was %i\n", FLAGS_repeat); gLogger.logError(error); exit(-1); } if (FLAGS_logFile.count() == 1) { if (!gLogger.SetLogFile(FLAGS_logFile[0])) { SkString str; str.printf("Could not open %s for writing.\n", FLAGS_logFile[0]); gLogger.logError(str); // TODO(borenet): We're disabling this for now, due to // write-protected Android devices. The very short-term // solution is to ignore the fact that we have no log file. //exit(-1); } } SkAutoTDelete<PictureJSONResultsWriter> jsonWriter; if (FLAGS_jsonLog.count() == 1) { SkASSERT(FLAGS_builderName.count() == 1 && FLAGS_gitHash.count() == 1); jsonWriter.reset(SkNEW(PictureJSONResultsWriter( FLAGS_jsonLog[0], FLAGS_builderName[0], FLAGS_buildNumber, FLAGS_timestamp, FLAGS_gitHash[0], FLAGS_gitNumber))); gWriter.add(jsonWriter.get()); } gWriter.add(&gLogWriter); #if SK_ENABLE_INST_COUNT gPrintInstCount = true; #endif SkAutoGraphics ag; sk_tools::PictureBenchmark benchmark; setup_benchmark(&benchmark); int failures = 0; for (int i = 0; i < FLAGS_readPath.count(); ++i) { failures += process_input(FLAGS_readPath[i], benchmark); } if (failures != 0) { SkString err; err.printf("Failed to run %i benchmarks.\n", failures); gLogger.logError(err); return 1; } #if SK_LAZY_CACHE_STATS if (FLAGS_trackDeferredCaching) { SkDebugf("Total cache hit rate: %f\n", (double) gTotalCacheHits / (gTotalCacheHits + gTotalCacheMisses)); } #endif gWriter.end(); return 0; }
bool TiledPictureRenderer::render(SkBitmap** out) { SkASSERT(fPicture != NULL); if (NULL == fPicture) { return false; } SkBitmap bitmap; if (out) { *out = SkNEW(SkBitmap); setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), SkScalarCeilToInt(fPicture->cullRect().height())); setup_bitmap(&bitmap, fTileWidth, fTileHeight); } bool success = true; if (fUseMultiPictureDraw) { SkMultiPictureDraw mpd; SkTDArray<SkSurface*> surfaces; surfaces.setReserve(fTileRects.count()); // Create a separate SkSurface/SkCanvas for each tile along with a // translated version of the skp (to mimic Chrome's behavior) and // feed all such pairs to the MultiPictureDraw. for (int i = 0; i < fTileRects.count(); ++i) { SkImageInfo ii = fCanvas->imageInfo().makeWH(fTileRects[i].width(), fTileRects[i].height()); *surfaces.append() = fCanvas->newSurface(ii); surfaces[i]->getCanvas()->setMatrix(fCanvas->getTotalMatrix()); SkPictureRecorder recorder; SkRTreeFactory bbhFactory; SkCanvas* c = recorder.beginRecording(SkIntToScalar(fTileRects[i].width()), SkIntToScalar(fTileRects[i].height()), &bbhFactory, SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag); c->save(); SkMatrix mat; mat.setTranslate(-SkIntToScalar(fTileRects[i].fLeft), -SkIntToScalar(fTileRects[i].fTop)); c->setMatrix(mat); c->drawPicture(fPicture); c->restore(); SkAutoTUnref<SkPicture> xlatedPicture(recorder.endRecording()); mpd.add(surfaces[i]->getCanvas(), xlatedPicture); } // Render all the buffered SkCanvases/SkPictures mpd.draw(); // Sort out the results and cleanup the allocated surfaces for (int i = 0; i < fTileRects.count(); ++i) { success &= this->postRender(surfaces[i]->getCanvas(), fTileRects[i], &bitmap, out, i); surfaces[i]->unref(); } } else { for (int i = 0; i < fTileRects.count(); ++i) { draw_tile_to_canvas(fCanvas, fTileRects[i], fPicture); success &= this->postRender(fCanvas, fTileRects[i], &bitmap, out, i); } } return success; }
void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override { int instanceCount = fGeoData.count(); SkMatrix invert; if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) { SkDebugf("Could not invert viewmatrix\n"); return; } uint32_t flags = 0; flags |= this->viewMatrix().isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0; GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode); // Setup GrGeometryProcessor GrBatchAtlas* atlas = fAtlas; SkAutoTUnref<GrGeometryProcessor> dfProcessor( GrDistanceFieldPathGeoProc::Create(this->color(), this->viewMatrix(), atlas->getTexture(), params, flags, this->usesLocalCoords())); batchTarget->initDraw(dfProcessor, pipeline); FlushInfo flushInfo; // allocate vertices size_t vertexStride = dfProcessor->getVertexStride(); SkASSERT(vertexStride == 2 * sizeof(SkPoint)); const GrVertexBuffer* vertexBuffer; void* vertices = batchTarget->makeVertSpace(vertexStride, kVerticesPerQuad * instanceCount, &vertexBuffer, &flushInfo.fVertexOffset); flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer)); flushInfo.fIndexBuffer.reset(batchTarget->resourceProvider()->refQuadIndexBuffer()); if (!vertices || !flushInfo.fIndexBuffer) { SkDebugf("Could not allocate vertices\n"); return; } flushInfo.fInstancesToFlush = 0; for (int i = 0; i < instanceCount; i++) { Geometry& args = fGeoData[i]; // get mip level SkScalar maxScale = this->viewMatrix().getMaxScale(); const SkRect& bounds = args.fPath.getBounds(); SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height()); SkScalar size = maxScale * maxDim; uint32_t desiredDimension; if (size <= kSmallMIP) { desiredDimension = kSmallMIP; } else if (size <= kMediumMIP) { desiredDimension = kMediumMIP; } else { desiredDimension = kLargeMIP; } // check to see if path is cached // TODO: handle stroked vs. filled version of same path PathData::Key key = { args.fPath.getGenerationID(), desiredDimension }; args.fPathData = fPathCache->find(key); if (NULL == args.fPathData || !atlas->hasID(args.fPathData->fID)) { // Remove the stale cache entry if (args.fPathData) { fPathCache->remove(args.fPathData->fKey); fPathList->remove(args.fPathData); SkDELETE(args.fPathData); } SkScalar scale = desiredDimension/maxDim; args.fPathData = SkNEW(PathData); if (!this->addPathToAtlas(batchTarget, dfProcessor, pipeline, &flushInfo, atlas, args.fPathData, args.fPath, args.fStroke, args.fAntiAlias, desiredDimension, scale)) { SkDebugf("Can't rasterize path\n"); return; } } atlas->setLastUseToken(args.fPathData->fID, batchTarget->currentToken()); // Now set vertices intptr_t offset = reinterpret_cast<intptr_t>(vertices); offset += i * kVerticesPerQuad * vertexStride; SkPoint* positions = reinterpret_cast<SkPoint*>(offset); this->writePathVertices(batchTarget, atlas, pipeline, dfProcessor, positions, vertexStride, this->viewMatrix(), args.fPath, args.fPathData); flushInfo.fInstancesToFlush++; } this->flush(batchTarget, &flushInfo); }
const GrGLInterface* GrGLCreateNullInterface() { // The gl functions are not context-specific so we create one global // interface static SkAutoTUnref<GrGLInterface> glInterface; if (!glInterface.get()) { GrGLInterface* interface = SkNEW(GrGLInterface); glInterface.reset(interface); interface->fBindingsExported = kDesktop_GrGLBinding; interface->fActiveTexture = nullGLActiveTexture; interface->fAttachShader = nullGLAttachShader; interface->fBeginQuery = nullGLBeginQuery; interface->fBindAttribLocation = nullGLBindAttribLocation; interface->fBindBuffer = nullGLBindBuffer; interface->fBindFragDataLocation = nullGLBindFragDataLocation; interface->fBindTexture = nullGLBindTexture; interface->fBlendColor = nullGLBlendColor; interface->fBlendFunc = nullGLBlendFunc; interface->fBufferData = nullGLBufferData; interface->fBufferSubData = nullGLBufferSubData; interface->fClear = nullGLClear; interface->fClearColor = nullGLClearColor; interface->fClearStencil = nullGLClearStencil; interface->fColorMask = nullGLColorMask; interface->fCompileShader = nullGLCompileShader; interface->fCompressedTexImage2D = nullGLCompressedTexImage2D; interface->fCreateProgram = nullGLCreateProgram; interface->fCreateShader = nullGLCreateShader; interface->fCullFace = nullGLCullFace; interface->fDeleteBuffers = nullGLDeleteBuffers; interface->fDeleteProgram = nullGLDelete; interface->fDeleteQueries = nullGLDeleteIds; interface->fDeleteShader = nullGLDelete; interface->fDeleteTextures = nullGLDeleteIds; interface->fDepthMask = nullGLDepthMask; interface->fDisable = nullGLDisable; interface->fDisableVertexAttribArray = nullGLDisableVertexAttribArray; interface->fDrawArrays = nullGLDrawArrays; interface->fDrawBuffer = nullGLDrawBuffer; interface->fDrawBuffers = nullGLDrawBuffers; interface->fDrawElements = nullGLDrawElements; interface->fEnable = nullGLEnable; interface->fEnableVertexAttribArray = nullGLEnableVertexAttribArray; interface->fEndQuery = nullGLEndQuery; interface->fFinish = nullGLFinish; interface->fFlush = nullGLFlush; interface->fFrontFace = nullGLFrontFace; interface->fGenBuffers = nullGLGenIds; interface->fGenQueries = nullGLGenIds; interface->fGenTextures = nullGLGenIds; interface->fGetBufferParameteriv = nullGLGetBufferParameteriv; interface->fGetError = nullGLGetError; interface->fGetIntegerv = nullGLGetIntegerv; interface->fGetQueryObjecti64v = nullGLGetQueryObjecti64v; interface->fGetQueryObjectiv = nullGLGetQueryObjectiv; interface->fGetQueryObjectui64v = nullGLGetQueryObjectui64v; interface->fGetQueryObjectuiv = nullGLGetQueryObjectuiv; interface->fGetQueryiv = nullGLGetQueryiv; interface->fGetProgramInfoLog = nullGLGetInfoLog; interface->fGetProgramiv = nullGLGetShaderOrProgramiv; interface->fGetShaderInfoLog = nullGLGetInfoLog; interface->fGetShaderiv = nullGLGetShaderOrProgramiv; interface->fGetString = nullGLGetString; interface->fGetTexLevelParameteriv = nullGLGetTexLevelParameteriv; interface->fGetUniformLocation = nullGLGetUniformLocation; interface->fLineWidth = nullGLLineWidth; interface->fLinkProgram = nullGLLinkProgram; interface->fPixelStorei = nullGLPixelStorei; interface->fQueryCounter = nullGLQueryCounter; interface->fReadBuffer = nullGLReadBuffer; interface->fReadPixels = nullGLReadPixels; interface->fScissor = nullGLScissor; interface->fShaderSource = nullGLShaderSource; interface->fStencilFunc = nullGLStencilFunc; interface->fStencilFuncSeparate = nullGLStencilFuncSeparate; interface->fStencilMask = nullGLStencilMask; interface->fStencilMaskSeparate = nullGLStencilMaskSeparate; interface->fStencilOp = nullGLStencilOp; interface->fStencilOpSeparate = nullGLStencilOpSeparate; interface->fTexImage2D = nullGLTexImage2D; interface->fTexParameteri = nullGLTexParameteri; interface->fTexParameteriv = nullGLTexParameteriv; interface->fTexSubImage2D = nullGLTexSubImage2D; interface->fTexStorage2D = nullGLTexStorage2D; interface->fUniform1f = nullGLUniform1f; interface->fUniform1i = nullGLUniform1i; interface->fUniform1fv = nullGLUniform1fv; interface->fUniform1iv = nullGLUniform1iv; interface->fUniform2f = nullGLUniform2f; interface->fUniform2i = nullGLUniform2i; interface->fUniform2fv = nullGLUniform2fv; interface->fUniform2iv = nullGLUniform2iv; interface->fUniform3f = nullGLUniform3f; interface->fUniform3i = nullGLUniform3i; interface->fUniform3fv = nullGLUniform3fv; interface->fUniform3iv = nullGLUniform3iv; interface->fUniform4f = nullGLUniform4f; interface->fUniform4i = nullGLUniform4i; interface->fUniform4fv = nullGLUniform4fv; interface->fUniform4iv = nullGLUniform4iv; interface->fUniformMatrix2fv = nullGLUniformMatrix2fv; interface->fUniformMatrix3fv = nullGLUniformMatrix3fv; interface->fUniformMatrix4fv = nullGLUniformMatrix4fv; interface->fUseProgram = nullGLUseProgram; interface->fVertexAttrib4fv = nullGLVertexAttrib4fv; interface->fVertexAttribPointer = nullGLVertexAttribPointer; interface->fViewport = nullGLViewport; interface->fBindFramebuffer = nullGLBindFramebuffer; interface->fBindRenderbuffer = nullGLBindRenderbuffer; interface->fCheckFramebufferStatus = nullGLCheckFramebufferStatus; interface->fDeleteFramebuffers = nullGLDeleteFramebuffers; interface->fDeleteRenderbuffers = nullGLDeleteRenderbuffers; interface->fFramebufferRenderbuffer = nullGLFramebufferRenderbuffer; interface->fFramebufferTexture2D = nullGLFramebufferTexture2D; interface->fGenFramebuffers = nullGLGenIds; interface->fGenRenderbuffers = nullGLGenIds; interface->fGetFramebufferAttachmentParameteriv = nullGLGetFramebufferAttachmentParameteriv; interface->fGetRenderbufferParameteriv = nullGLGetRenderbufferParameteriv; interface->fRenderbufferStorage = nullGLRenderbufferStorage; interface->fRenderbufferStorageMultisample = nullGLRenderbufferStorageMultisample; interface->fBlitFramebuffer = nullGLBlitFramebuffer; interface->fResolveMultisampleFramebuffer = nullGLResolveMultisampleFramebuffer; interface->fMapBuffer = nullGLMapBuffer; interface->fUnmapBuffer = nullGLUnmapBuffer; interface->fBindFragDataLocationIndexed = nullGLBindFragDataLocationIndexed; } glInterface.get()->ref(); return glInterface.get(); }
sk_path_t* sk_path_new() { return (sk_path_t*)SkNEW(SkPath); }
GrContext* GrContext::CreateMockContext() { GrContext* context = SkNEW(GrContext); context->initMockContext(); return context; }
static SkPicture* vanilla_factory(const int width, const int height, int* recordingFlags) { return SkNEW(SkPicture); }
SkSemaphore::SkSemaphore() : fCount(0), fOSSemaphore(SkNEW(OSSemaphore)) {}
static SkImageDecoder* sk_libbmp_dfactory(SkStreamRewindable* stream) { if (is_bmp(stream)) { return SkNEW(SkBMPImageDecoder); } return NULL; }
MockGpu(GrContext* context) : INHERITED(context) { fCaps.reset(SkNEW(GrDrawTargetCaps)); }
static void intialize_default_tracer(SkEventTracer* current_instance) { if (NULL == current_instance) { SkEventTracer::SetInstance(SkNEW(SkDefaultEventTracer)); } atexit(cleanup_tracer); }
static bool emit_pdf_document(const SkTDArray<const SkPDFDevice*>& pageDevices, SkWStream* stream) { if (pageDevices.isEmpty()) { return false; } SkTDArray<SkPDFDict*> pages; SkAutoTUnref<SkPDFDict> dests(SkNEW(SkPDFDict)); for (int i = 0; i < pageDevices.count(); i++) { SkASSERT(pageDevices[i]); SkASSERT(i == 0 || pageDevices[i - 1]->getCanon() == pageDevices[i]->getCanon()); SkAutoTUnref<SkPDFDict> page(create_pdf_page(pageDevices[i])); pageDevices[i]->appendDestinations(dests, page.get()); pages.push(page.detach()); } SkTDArray<SkPDFDict*> pageTree; SkAutoTUnref<SkPDFDict> docCatalog(SkNEW_ARGS(SkPDFDict, ("Catalog"))); SkPDFDict* pageTreeRoot; generate_page_tree(pages, &pageTree, &pageTreeRoot); docCatalog->insertObjRef("Pages", SkRef(pageTreeRoot)); if (dests->size() > 0) { docCatalog->insertObjRef("Dests", dests.detach()); } /* TODO(vandebo): output intent SkAutoTUnref<SkPDFDict> outputIntent = new SkPDFDict("OutputIntent"); outputIntent->insertName("S", "GTS_PDFA1"); outputIntent->insertString("OutputConditionIdentifier", "sRGB"); SkAutoTUnref<SkPDFArray> intentArray(new SkPDFArray); intentArray->appendObject(SkRef(outputIntent.get())); docCatalog->insertObject("OutputIntent", intentArray.detach()); */ // Build font subsetting info before proceeding. SkPDFSubstituteMap substitutes; perform_font_subsetting(pageDevices, &substitutes); SkPDFObjNumMap objNumMap; if (objNumMap.addObject(docCatalog.get())) { docCatalog->addResources(&objNumMap, substitutes); } size_t baseOffset = stream->bytesWritten(); emit_pdf_header(stream); SkTDArray<int32_t> offsets; for (int i = 0; i < objNumMap.objects().count(); ++i) { SkPDFObject* object = objNumMap.objects()[i]; size_t offset = stream->bytesWritten(); // This assert checks that size(pdf_header) > 0 and that // the output stream correctly reports bytesWritten(). SkASSERT(offset > baseOffset); offsets.push(SkToS32(offset - baseOffset)); SkASSERT(object == substitutes.getSubstitute(object)); SkASSERT(objNumMap.getObjectNumber(object) == i + 1); stream->writeDecAsText(i + 1); stream->writeText(" 0 obj\n"); // Generation number is always 0. object->emitObject(stream, objNumMap, substitutes); stream->writeText("\nendobj\n"); } int32_t xRefFileOffset = SkToS32(stream->bytesWritten() - baseOffset); // Include the zeroth object in the count. int32_t objCount = SkToS32(offsets.count() + 1); stream->writeText("xref\n0 "); stream->writeDecAsText(objCount); stream->writeText("\n0000000000 65535 f \n"); for (int i = 0; i < offsets.count(); i++) { SkASSERT(offsets[i] > 0); stream->writeBigDecAsText(offsets[i], 10); stream->writeText(" 00000 n \n"); } emit_pdf_footer(stream, objNumMap, substitutes, docCatalog.get(), objCount, xRefFileOffset); // The page tree has both child and parent pointers, so it creates a // reference cycle. We must clear that cycle to properly reclaim memory. for (int i = 0; i < pageTree.count(); i++) { pageTree[i]->clear(); } pageTree.safeUnrefAll(); pages.unrefAll(); return true; }