From 04d52f3a92bb3d72e035a7c002926953edb0b505 Mon Sep 17 00:00:00 2001 From: joshualitt Date: Fri, 13 Nov 2015 11:22:19 -0800 Subject: Create a standalone example for using Skia with SDL BUG=skia: Review URL: https://codereview.chromium.org/1442573003 --- example/SkiaSDLExample.cpp | 273 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 273 insertions(+) create mode 100644 example/SkiaSDLExample.cpp (limited to 'example') diff --git a/example/SkiaSDLExample.cpp b/example/SkiaSDLExample.cpp new file mode 100644 index 0000000000..0cc3402d71 --- /dev/null +++ b/example/SkiaSDLExample.cpp @@ -0,0 +1,273 @@ +/* + * Copyright 2015 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + * + */ + +#include "GrContext.h" +#include "SDL.h" +#include "SkCanvas.h" +#include "SkRandom.h" +#include "SkSurface.h" + +#include "gl/GrGLInterface.h" +#include "gl/GrGLUtil.h" + +#if defined(SK_BUILD_FOR_ANDROID) +#include +#elif defined(SK_BUILD_FOR_UNIX) +#include +#elif defined(SK_BUILD_FOR_MAC) +#include +#endif + +/* + * This application is a simple example of how to combine SDL and Skia it demonstrates: + * how to setup gpu rendering to the main window + * how to perform cpu-side rendering and draw the result to the gpu-backed screen + * draw simple primitives (rectangles) + * draw more complex primitives (star) + */ + +struct ApplicationState { + ApplicationState() : fQuit(false) {} + // Storage for the user created rectangles. The last one may still be being edited. + SkTArray fRects; + bool fQuit; +}; + +static void handle_error() { + const char* error = SDL_GetError(); + SkDebugf("SDL Error: %s\n", error); + SDL_ClearError(); +} + +static void handle_events(ApplicationState* state, SkCanvas* canvas) { + SDL_Event event; + while(SDL_PollEvent(&event)) { + switch (event.type) { + case SDL_MOUSEMOTION: + if (event.motion.state == SDL_PRESSED) { + SkRect& rect = state->fRects.back(); + rect.fRight = event.motion.x; + rect.fBottom = event.motion.y; + } + break; + case SDL_MOUSEBUTTONDOWN: + if (event.button.state == SDL_PRESSED) { + state->fRects.push_back() = SkRect::MakeLTRB(SkIntToScalar(event.button.x), + SkIntToScalar(event.button.y), + SkIntToScalar(event.button.x), + SkIntToScalar(event.button.y)); + } + break; + case SDL_KEYDOWN: { + SDL_Keycode key = event.key.keysym.sym; + if (key == SDLK_ESCAPE) { + state->fQuit = true; + } + break; + } + case SDL_QUIT: + state->fQuit = true; + break; + default: + break; + } + } +} + +// Creates a star type shape using a SkPath +static SkPath create_star() { + static const int kNumPoints = 5; + SkPath concavePath; + SkPoint points[kNumPoints] = {{0, SkIntToScalar(-50)} }; + SkMatrix rot; + rot.setRotate(SkIntToScalar(360) / kNumPoints); + for (int i = 1; i < kNumPoints; ++i) { + rot.mapPoints(points + i, points + i - 1, 1); + } + concavePath.moveTo(points[0]); + for (int i = 0; i < kNumPoints; ++i) { + concavePath.lineTo(points[(2 * i) % kNumPoints]); + } + concavePath.setFillType(SkPath::kEvenOdd_FillType); + SkASSERT(!concavePath.isConvex()); + concavePath.close(); + return concavePath; +} + +#if defined(SK_BUILD_FOR_ANDROID) +int SDL_main(int argc, char** argv) { +#else +int main(int argc, char** argv) { +#endif + uint32_t windowFlags = 0; + + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0); + + SDL_GLContext glContext = nullptr; +#if defined(SK_BUILD_FOR_ANDROID) + // For Android we need to set up for OpenGL ES and we make the window hi res & full screen + SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES); + windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | + SDL_WINDOW_BORDERLESS | SDL_WINDOW_FULLSCREEN_DESKTOP | + SDL_WINDOW_ALLOW_HIGHDPI; +#else + // For all other clients we use the core profile and operate in a window + SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); + + windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE; +#endif + static const int kStencilBits = 8; // Skia needs 8 stencil bits + SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); + SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0); + SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, kStencilBits); + + SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1); + + // If you want multisampling, uncomment the below lines and set a sample count + static const int kMsaaSampleCount = 0; //4; + // SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); + // SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, kMsaaSampleCount); + + /* + * In a real application you might want to initialize more subsystems + */ + if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) != 0) { + handle_error(); + return 1; + } + + // Setup window + // This code will create a window with the same resolution as the user's desktop. + SDL_DisplayMode dm; + if (SDL_GetDesktopDisplayMode(0, &dm) != 0) { + handle_error(); + return 1; + } + + SDL_Window* window = SDL_CreateWindow("SDL Window", SDL_WINDOWPOS_CENTERED, + SDL_WINDOWPOS_CENTERED, dm.w, dm.h, windowFlags); + + if (!window) { + handle_error(); + return 1; + } + + // To go fullscreen + // SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN); + + // try and setup a GL context + glContext = SDL_GL_CreateContext(window); + if (!glContext) { + handle_error(); + return 1; + } + + int success = SDL_GL_MakeCurrent(window, glContext); + if (success != 0) { + handle_error(); + return success; + } + + glViewport(0, 0, dm.w, dm.h); + glClearColor(1, 1, 1, 1); + glClearStencil(0); + glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + + // setup GrContext + SkAutoTUnref interface(GrGLCreateNativeInterface()); + + // To use NVPR, comment this out + interface.reset(GrGLInterfaceRemoveNVPR(interface)); + SkASSERT(interface); + + // setup contexts + SkAutoTUnref grContext(GrContext::Create(kOpenGL_GrBackend, + (GrBackendContext)interface.get())); + SkASSERT(grContext); + + // Wrap the frame buffer object attached to the screen in a Skia render target so Skia can + // render to it + GrBackendRenderTargetDesc desc; + desc.fWidth = dm.w; + desc.fHeight = dm.h; + desc.fConfig = kSkia8888_GrPixelConfig; + desc.fOrigin = kBottomLeft_GrSurfaceOrigin; + desc.fSampleCnt = kMsaaSampleCount; + desc.fStencilBits = kStencilBits; + GrGLint buffer; + GR_GL_GetIntegerv(interface, GR_GL_FRAMEBUFFER_BINDING, &buffer); + desc.fRenderTargetHandle = buffer; + SkAutoTUnref + renderTarget(grContext->textureProvider()->wrapBackendRenderTarget(desc)); + + // setup SkSurface + // To use distance field text, use commented out SkSurfaceProps instead + // SkSurfaceProps props(SkSurfaceProps::kUseDeviceIndependentFonts_Flag, + // SkSurfaceProps::kLegacyFontHost_InitType); + SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType); + SkAutoTUnref surface(SkSurface::NewRenderTargetDirect(renderTarget, &props)); + + SkCanvas* canvas = surface->getCanvas(); + + ApplicationState state; + + const char* helpMessage = "Click and drag to create rects. Press esc to quit."; + + SkPaint paint; + + // create a surface for CPU rasterization + SkAutoTUnref cpuSurface(SkSurface::NewRaster(canvas->imageInfo())); + + SkCanvas* offscreen = cpuSurface->getCanvas(); + offscreen->save(); + offscreen->translate(50.0f, 50.0f); + offscreen->drawPath(create_star(), paint); + offscreen->restore(); + + SkAutoTUnref image(cpuSurface->newImageSnapshot()); + + int rotation = 0; + while (!state.fQuit) { // Our application loop + SkRandom rand; + canvas->clear(SK_ColorWHITE); + handle_events(&state, canvas); + + paint.setColor(SK_ColorBLACK); + canvas->drawText(helpMessage, strlen(helpMessage), SkIntToScalar(100), + SkIntToScalar(100), paint); + for (int i = 0; i < state.fRects.count(); i++) { + paint.setColor(rand.nextU() | 0x44808080); + canvas->drawRect(state.fRects[i], paint); + } + + // draw offscreen canvas + canvas->save(); + canvas->translate(dm.w / 2.0, dm.h / 2.0); + canvas->rotate(rotation++); + canvas->drawImage(image, -50.0f, -50.0f); + canvas->restore(); + + canvas->flush(); + SDL_GL_SwapWindow(window); + } + + if (glContext) { + SDL_GL_DeleteContext(glContext); + } + + //Destroy window + SDL_DestroyWindow(window); + + //Quit SDL subsystems + SDL_Quit(); + return 0; +} -- cgit v1.2.3