cgl 0.3.2

Rust bindings for CGL on Mac
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204

// Copyright 2013 The Servo Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

// Mac-specific OpenGL bindings.

#![allow(non_upper_case_globals)]

use libc::{c_void, c_int, c_char};
use std::os::raw;

pub type GLenum = raw::c_uint;
pub type GLint = raw::c_int;
pub type GLsizei = raw::c_int;
pub type GLuint = raw::c_uint;

pub type CGLPixelFormatAttribute = c_int;
pub type CGLContextParameter = c_int;
pub type CGLContextEnable = c_int;
pub type CGLGlobalOption = c_int;
pub type CGLError = c_int;

pub type CGLPixelFormatObj = *mut c_void;
pub type CGLContextObj = *mut c_void;
pub type CGLShareGroupObj = *mut c_void;
pub type IOSurfaceRef = *mut c_void;

pub const kCGLNoError: CGLError = 0;

pub const kCGLPFAAllRenderers: CGLPixelFormatAttribute = 1;
pub const kCGLPFADoubleBuffer: CGLPixelFormatAttribute = 5;
pub const kCGLPFAStereo: CGLPixelFormatAttribute = 6;
pub const kCGLPFAAuxBuffers: CGLPixelFormatAttribute = 7;
pub const kCGLPFAColorSize: CGLPixelFormatAttribute = 8;
pub const kCGLPFAAlphaSize: CGLPixelFormatAttribute = 11;
pub const kCGLPFADepthSize: CGLPixelFormatAttribute = 12;
pub const kCGLPFAStencilSize: CGLPixelFormatAttribute = 13;
pub const kCGLPFAAccumSize: CGLPixelFormatAttribute = 14;
pub const kCGLPFAMinimumPolicy: CGLPixelFormatAttribute = 51;
pub const kCGLPFAMaximumPolicy: CGLPixelFormatAttribute = 52;
pub const kCGLPFAOffScreen: CGLPixelFormatAttribute = 53;
pub const kCGLPFAFullScreen: CGLPixelFormatAttribute = 54;
pub const kCGLPFASampleBuffers: CGLPixelFormatAttribute = 55;
pub const kCGLPFASamples: CGLPixelFormatAttribute = 56;
pub const kCGLPFAAuxDepthStencil: CGLPixelFormatAttribute = 57;
pub const kCGLPFAColorFloat: CGLPixelFormatAttribute = 58;
pub const kCGLPFAMultisample: CGLPixelFormatAttribute = 59;
pub const kCGLPFASupersample: CGLPixelFormatAttribute = 60;
pub const kCGLPFASampleAlpha: CGLPixelFormatAttribute = 61;
pub const kCGLPFARendererID: CGLPixelFormatAttribute = 70;
pub const kCGLPFASingleRenderer: CGLPixelFormatAttribute = 71;
pub const kCGLPFANoRecovery: CGLPixelFormatAttribute = 72;
pub const kCGLPFAAccelerated: CGLPixelFormatAttribute = 73;
pub const kCGLPFAClosestPolicy: CGLPixelFormatAttribute = 74;
pub const kCGLPFARobust: CGLPixelFormatAttribute = 75;
pub const kCGLPFABackingStore: CGLPixelFormatAttribute = 76;
pub const kCGLPFAMPSafe: CGLPixelFormatAttribute = 78;
pub const kCGLPFAWindow: CGLPixelFormatAttribute = 80;
pub const kCGLPFAMultiScreen: CGLPixelFormatAttribute = 81;
pub const kCGLPFACompliant: CGLPixelFormatAttribute = 83;
pub const kCGLPFADisplayMask: CGLPixelFormatAttribute = 84;
pub const kCGLPFAPBuffer: CGLPixelFormatAttribute = 90;
pub const kCGLPFARemotePBuffer: CGLPixelFormatAttribute = 91;
pub const kCGLPFAAllowOfflineRenderers: CGLPixelFormatAttribute = 96;
pub const kCGLPFAAcceleratedCompute: CGLPixelFormatAttribute = 97;
pub const kCGLPFAOpenGLProfile: CGLPixelFormatAttribute = 99;
pub const kCGLPFAVirtualScreenCount: CGLPixelFormatAttribute = 128;

pub const kCGLCESwapRectangle: CGLContextEnable = 201;
pub const kCGLCESwapLimit: CGLContextEnable = 203;
pub const kCGLCERasterization: CGLContextEnable = 221;
pub const kCGLCEStateValidation: CGLContextEnable = 301;
pub const kCGLCESurfaceBackingSize: CGLContextEnable = 305;
pub const kCGLCEDisplayListOptimization: CGLContextEnable = 307;
pub const kCGLCEMPEngine: CGLContextEnable = 313;
pub const kCGLCECrashOnRemovedFunctions: CGLContextEnable = 316;

pub const kCGLCPSwapRectangle: CGLContextParameter = 200;
pub const kCGLCPSwapInterval: CGLContextParameter = 222;
pub const kCGLCPDispatchTableSize: CGLContextParameter = 224;
pub const kCGLCPClientStorage: CGLContextParameter = 226;
pub const kCGLCPSurfaceTexture: CGLContextParameter = 228;
pub const kCGLCPSurfaceOrder: CGLContextParameter = 235;
pub const kCGLCPSurfaceOpacity: CGLContextParameter = 236;
pub const kCGLCPSurfaceBackingSize: CGLContextParameter = 304;
pub const kCGLCPSurfaceSurfaceVolatile: CGLContextParameter = 306;
pub const kCGLCPReclaimResources: CGLContextParameter = 308;
pub const kCGLCPCurrentRendererID: CGLContextParameter = 309;
pub const kCGLCPGPUVertexProcessing: CGLContextParameter = 310;
pub const kCGLCPGPUFragmentProcessing: CGLContextParameter = 311;
pub const kCGLCPHasDrawable: CGLContextParameter = 314;
pub const kCGLCPMPSwapsInFlight: CGLContextParameter = 315;

pub const kCGLGOFormatCacheSize: CGLGlobalOption = 501;
pub const kCGLGOClearFormatCache: CGLGlobalOption = 502;
pub const kCGLGORetainRenderers: CGLGlobalOption = 503;
pub const kCGLGOResetLibrary: CGLGlobalOption = 504;
pub const kCGLGOUseErrorHandler: CGLGlobalOption = 505;
pub const kCGLGOUseBuildCache: CGLGlobalOption = 506;

pub const CORE_BOOLEAN_ATTRIBUTES: &'static [CGLPixelFormatAttribute] =
    &[kCGLPFAAllRenderers,
      kCGLPFADoubleBuffer,
      kCGLPFAStereo,
      kCGLPFAAuxBuffers,
      kCGLPFAMinimumPolicy,
      kCGLPFAMaximumPolicy,
      kCGLPFAOffScreen,
      kCGLPFAFullScreen,
      kCGLPFAAuxDepthStencil,
      kCGLPFAColorFloat,
      kCGLPFAMultisample,
      kCGLPFASupersample,
      kCGLPFASampleAlpha,
      kCGLPFASingleRenderer,
      kCGLPFANoRecovery,
      kCGLPFAAccelerated,
      kCGLPFAClosestPolicy,
      kCGLPFARobust,
      kCGLPFABackingStore,
      kCGLPFAMPSafe,
      kCGLPFAWindow,
      kCGLPFAMultiScreen,
      kCGLPFACompliant,
      kCGLPFAPBuffer,
      kCGLPFARemotePBuffer,
      kCGLPFAAllowOfflineRenderers,
      kCGLPFAAcceleratedCompute];

pub const CORE_INTEGER_ATTRIBUTES: &'static [CGLPixelFormatAttribute] =
    &[kCGLPFAColorSize,
      kCGLPFAAlphaSize,
      kCGLPFADepthSize,
      kCGLPFAStencilSize,
      kCGLPFAAccumSize,
      kCGLPFASampleBuffers,
      kCGLPFASamples,
      kCGLPFARendererID,
      kCGLPFADisplayMask,
      kCGLPFAOpenGLProfile,
      kCGLPFAVirtualScreenCount];

#[link(name = "OpenGL", kind = "framework")]
extern {
    // CGLCurrent.h

    pub fn CGLSetCurrentContext(ctx: CGLContextObj) -> CGLError;
    pub fn CGLGetCurrentContext() -> CGLContextObj;
    pub fn CGLGetShareGroup(context: CGLContextObj) -> CGLShareGroupObj;

    // OpenGL.h

    // Pixel format functions
    pub fn CGLChoosePixelFormat(attribs: *const CGLPixelFormatAttribute,
                                pix: *mut CGLPixelFormatObj,
                                npix: *mut GLint) -> CGLError;
    pub fn CGLDescribePixelFormat(pix: CGLPixelFormatObj,
                                  pix_num: GLint,
                                  attrib: CGLPixelFormatAttribute,
                                  value: *mut GLint) -> CGLError;
    pub fn CGLDestroyPixelFormat(pix: CGLPixelFormatObj) -> CGLError;
    pub fn CGLReleasePixelFormat(pix: CGLPixelFormatObj);
    pub fn CGLRetainPixelFormat(pix: CGLPixelFormatObj) -> CGLPixelFormatObj;
    pub fn CGLGetPixelFormatRetainCount(pix: CGLPixelFormatObj) -> GLuint;

    // Context functions
    pub fn CGLCreateContext(pix: CGLPixelFormatObj, share: CGLContextObj, ctx: *mut CGLContextObj) ->
                            CGLError;
    pub fn CGLDestroyContext(ctx: CGLContextObj) -> CGLError;
    pub fn CGLGetPixelFormat(ctx: CGLContextObj) -> CGLPixelFormatObj;

    // Getting and Setting Context Options
    pub fn CGLEnable(ctx: CGLContextObj, pname: CGLContextEnable) -> CGLError;
    pub fn CGLDisable(ctx: CGLContextObj, pname: CGLContextEnable) -> CGLError;
    pub fn CGLIsEnabled(ctx: CGLContextObj, pname: CGLContextEnable, enable: &mut GLint) -> CGLError;
    pub fn CGLSetParameter(ctx: CGLContextObj, pname: CGLContextParameter, params: &GLint) -> CGLError;
    pub fn CGLGetParameter(ctx: CGLContextObj, pname: CGLContextParameter, params: &mut GLint) -> CGLError;

    // Locking functions
    pub fn CGLLockContext(ctx: CGLContextObj) -> CGLError;
    pub fn CGLUnlockContext(ctx: CGLContextObj) -> CGLError;

    // Getting and Setting Global Information
    pub fn CGLSetOption(pname: CGLGlobalOption, param: &GLint) -> CGLError;
    pub fn CGLGetOption(pname: CGLGlobalOption, param: &mut GLint) -> CGLError;
    pub fn CGLSetGlobalOption(pname: CGLGlobalOption, param: &GLint) -> CGLError;
    pub fn CGLGetGlobalOption(pname: CGLGlobalOption, param: &mut GLint) -> CGLError;
    pub fn CGLGetVersion (major: &mut GLint, minor: &mut GLint) -> CGLError;

    // CGLIOSurface.h

    pub fn CGLTexImageIOSurface2D(ctx: CGLContextObj, target: GLenum, internal_format: GLenum,
                                  width: GLsizei, height: GLsizei, format: GLenum, ty: GLenum,
                                  ioSurface: IOSurfaceRef, plane: GLuint) -> CGLError;

    // https://developer.apple.com/library/mac/documentation/GraphicsImaging/Reference/CGL_OpenGL/#//apple_ref/c/func/CGLErrorString

    pub fn CGLErrorString(error: CGLError) -> *const c_char;
}