--- /dev/null
+/*
+ * 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 <GLES/gl.h>
+#elif defined(SK_BUILD_FOR_UNIX)
+#include <GL/gl.h>
+#elif defined(SK_BUILD_FOR_MAC)
+#include <gl.h>
+#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<SkRect> 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<const GrGLInterface> interface(GrGLCreateNativeInterface());
+
+ // To use NVPR, comment this out
+ interface.reset(GrGLInterfaceRemoveNVPR(interface));
+ SkASSERT(interface);
+
+ // setup contexts
+ SkAutoTUnref<GrContext> 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<GrRenderTarget>
+ 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<SkSurface> 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<SkSurface> 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<SkImage> 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;
+}
projects / platform / upstream / libSkiaSharp.git / commitdiff