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
|
package net.java.games.jogl.impl.macosx;
import net.java.games.jogl.*;
import net.java.games.jogl.impl.*;
public class MacOSXPbufferGLContext extends MacOSXGLContext {
private static final boolean DEBUG = Debug.debug("MacOSXPbufferGLContext");
protected int initWidth;
protected int initHeight;
private long pBuffer;
protected int width;
protected int height;
// State for render-to-texture and render-to-texture-rectangle support
private boolean created;
private int textureTarget; // e.g. GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_NV
private int texture; // actual texture object
public MacOSXPbufferGLContext(GLCapabilities capabilities, int initialWidth, int initialHeight) {
super(null, capabilities, null, null);
this.initWidth = initialWidth;
this.initHeight = initialHeight;
}
public boolean canCreatePbufferContext() {
return false;
}
public GLContext createPbufferContext(GLCapabilities capabilities,
int initialWidth,
int initialHeight) {
throw new GLException("Not supported");
}
public void bindPbufferToTexture() {
GL gl = getGL();
gl.glBindTexture(textureTarget, texture);
// FIXME: not clear whether this is really necessary, but since
// the API docs seem to imply it is and since it doesn't seem to
// impact performance, leaving it in
CGL.setContextTextureImageToPBuffer(nsContext, pBuffer, GL.GL_FRONT);
}
public void releasePbufferFromTexture() {
}
public void createPbuffer(long parentView, long parentContext) {
GL gl = getGL();
// Must initally grab OpenGL function pointers while parent's
// context is current because otherwise we don't have the cgl
// extensions available to us
resetGLFunctionAvailability();
int renderTarget;
if (capabilities.getOffscreenRenderToTextureRectangle()) {
width = initWidth;
height = initHeight;
renderTarget = GL.GL_TEXTURE_RECTANGLE_EXT;
} else {
width = getNextPowerOf2(initWidth);
height = getNextPowerOf2(initHeight);
renderTarget = GL.GL_TEXTURE_2D;
}
int internalFormat = GL.GL_RGBA;
if (capabilities.getOffscreenFloatingPointBuffers()) {
if (!gl.isExtensionAvailable("GL_APPLE_float_pixels")) {
throw new GLException("Floating-point support (GL_APPLE_float_pixels) not available");
}
switch (capabilities.getRedBits()) {
case 16: internalFormat = GL.GL_RGBA_FLOAT16_APPLE; break;
case 32: internalFormat = GL.GL_RGBA_FLOAT32_APPLE; break;
default: throw new GLException("Invalid floating-point bit depth (only 16 and 32 supported)");
}
}
pBuffer = CGL.createPBuffer(renderTarget, internalFormat, width, height);
if (pBuffer == 0) {
throw new GLException("pbuffer creation error: CGL.createPBuffer() failed");
}
if (DEBUG) {
System.err.println("Created pbuffer 0x" + Long.toHexString(pBuffer) + ", " + width + " x " + height + " for " + this);
}
}
protected synchronized boolean makeCurrent(Runnable initAction) throws GLException {
created = false;
if (pBuffer == 0) {
if (DEBUG) {
System.err.println("Pbuffer not instantiated yet for " + this);
}
// pbuffer not instantiated yet
return false;
}
boolean res = super.makeCurrent(initAction);
if (created) {
// Initialize render-to-texture support if requested
boolean rect = capabilities.getOffscreenRenderToTextureRectangle();
GL gl = getGL();
if (rect) {
if (!gl.isExtensionAvailable("GL_EXT_texture_rectangle")) {
System.err.println("MacOSXPbufferGLContext: WARNING: GL_EXT_texture_rectangle extension not " +
"supported; skipping requested render_to_texture_rectangle support for pbuffer");
rect = false;
}
}
textureTarget = (rect ? GL.GL_TEXTURE_RECTANGLE_EXT : GL.GL_TEXTURE_2D);
int[] tmp = new int[1];
gl.glGenTextures(1, tmp);
texture = tmp[0];
gl.glBindTexture(textureTarget, texture);
gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
gl.glCopyTexImage2D(textureTarget, 0, GL.GL_RGB, 0, 0, width, height, 0);
}
return res;
}
public void destroyPBuffer() {
if (this.pBuffer != 0) {
CGL.destroyPBuffer(nsContext, pBuffer);
}
this.pBuffer = 0;
if (DEBUG) {
System.err.println("Destroyed pbuffer " + width + " x " + height);
}
}
public void handleModeSwitch(long parentView, long parentContext) {
throw new GLException("Not yet implemented");
}
protected boolean isOffscreen() {
// FIXME: currently the only caller of this won't cause proper
// resizing of the pbuffer anyway.
return false;
}
protected void destroyImpl() throws GLException {
destroyPBuffer();
}
public void swapBuffers() throws GLException {
// FIXME: do we need to do anything if the pbuffer is double-buffered?
}
public int getFloatingPointMode() {
return GLPbuffer.APPLE_FLOAT;
}
private int getNextPowerOf2(int number) {
if (((number-1) & number) == 0) {
//ex: 8 -> 0b1000; 8-1=7 -> 0b0111; 0b1000&0b0111 == 0
return number;
}
int power = 0;
while (number > 0) {
number = number>>1;
power++;
}
return (1<<power);
}
protected boolean create() {
if (!super.create()) {
return false;
}
created = true;
// Must now associate the pbuffer with our newly-created context
CGL.setContextPBuffer(nsContext, pBuffer);
return true;
}
}
|
