servo-skia 0.30000008.0

2D graphic library for drawing Text, Geometries, and Images
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

/*
 * Copyright 2015 The Servo Project Developers
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

use gl_rasterization_context;
use skia;

use euclid::Size2D;
use cgl;
use gleam::gl;
use std::ptr;
use std::rc::Rc;

pub struct PlatformDisplayData {
    pub pixel_format: cgl::CGLPixelFormatObj,
}

pub struct GLPlatformContext {
    gl: Rc<gl::Gl>,
    pub cgl_context: cgl::CGLContextObj,

    pub framebuffer_id: gl::GLuint,
    texture_id: gl::GLuint,
    depth_stencil_renderbuffer_id: gl::GLuint,
}

impl Drop for GLPlatformContext {
    fn drop(&mut self) {
        self.make_current();
        gl_rasterization_context::destroy_framebuffer(self.gl(),
                                                      self.framebuffer_id,
                                                      self.texture_id,
                                                      self.depth_stencil_renderbuffer_id);

        unsafe {
            cgl::CGLDestroyContext(self.cgl_context);
        }
    }
}

impl GLPlatformContext {
    pub fn new(gl: Rc<gl::Gl>,
               platform_display_data: PlatformDisplayData,
               size: Size2D<i32>)
               -> Option<GLPlatformContext> {
        unsafe {
            let mut cgl_context = ptr::null_mut();
            let _ = cgl::CGLCreateContext(platform_display_data.pixel_format,
                                          ptr::null_mut(),
                                          &mut cgl_context);
            if ptr::null_mut() == cgl_context {
                return None;
            }

            cgl::CGLSetCurrentContext(cgl_context);
            gl.enable(gl::TEXTURE_RECTANGLE_ARB);

            let gl_interface = skia::SkiaGrGLCreateNativeInterface();
            if gl_interface == ptr::null_mut() {
                cgl::CGLDestroyContext(cgl_context);
                return None
            }

            // We only start the framebuffer setup here, since we cannot complete it until
            // we have a texture image. That will be provided by the IOSurface in the
            // GLRasterizationContext.
            let (framebuffer_id, texture_id, depth_stencil_renderbuffer_id) =
                gl_rasterization_context::start_framebuffer_setup(&*gl,
                                                                  gl::TEXTURE_RECTANGLE_ARB,
                                                                  size,
                                                                  gl_interface);
            skia::SkiaGrGLInterfaceRelease(gl_interface);
            Some(GLPlatformContext {
                gl: gl,
                cgl_context: cgl_context,
                framebuffer_id: framebuffer_id,
                texture_id: texture_id,
                depth_stencil_renderbuffer_id: depth_stencil_renderbuffer_id,
            })
        }
    }

    fn gl(&self) -> &gl::Gl {
        &*self.gl
    }

    pub fn drop_current_context(&self) {
        unsafe {
            cgl::CGLSetCurrentContext(ptr::null_mut());
        }
    }

    pub fn make_current(&self) {
        unsafe {
            cgl::CGLSetCurrentContext(self.cgl_context);
        }
    }
}