Newer
Older
Lorenz Meier
committed
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
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#ifndef OSG_TEXTURE3D
#define OSG_TEXTURE3D 1
#include <osg/Texture>
#ifndef GL_MAX_3D_TEXTURE_SIZE
#define GL_MAX_3D_TEXTURE_SIZE 0x8073
#endif
namespace osg {
/** Encapsulates OpenGL 2D texture functionality. Doesn't support cube maps,
* so ignore \a face parameters.
*/
class OSG_EXPORT Texture3D : public Texture
{
public :
Texture3D();
Texture3D(Image* image);
/** Copy constructor using CopyOp to manage deep vs shallow copy. */
Texture3D(const Texture3D& text,const CopyOp& copyop=CopyOp::SHALLOW_COPY);
META_StateAttribute(osg, Texture3D,TEXTURE);
/** Return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs. */
virtual int compare(const StateAttribute& rhs) const;
virtual GLenum getTextureTarget() const { return GL_TEXTURE_3D; }
/** Sets the texture image. */
void setImage(Image* image);
/** Gets the texture image. */
Image* getImage() { return _image.get(); }
/** Gets the const texture image. */
inline const Image* getImage() const { return _image.get(); }
inline unsigned int& getModifiedCount(unsigned int contextID) const
{
// get the modified count for the current contextID.
return _modifiedCount[contextID];
}
/** Sets the texture image, ignoring face. */
virtual void setImage(unsigned int, Image* image) { setImage(image); }
/** Gets the texture image, ignoring face. */
virtual Image* getImage(unsigned int) { return _image.get(); }
/** Gets the const texture image, ignoring face. */
virtual const Image* getImage(unsigned int) const { return _image.get(); }
/** Gets the number of images that can be assigned to the Texture. */
virtual unsigned int getNumImages() const { return 1; }
/** Sets the texture width, height, and depth. If width, height, or
* depth are zero, calculate the respective value from the source
* image size. */
inline void setTextureSize(int width, int height, int depth) const
{
_textureWidth = width;
_textureHeight = height;
_textureDepth = depth;
}
/** Gets the texture subload width. */
inline void getTextureSize(int& width, int& height, int& depth) const
{
width = _textureWidth;
height = _textureHeight;
depth = _textureDepth;
}
void setTextureWidth(int width) { _textureWidth=width; }
void setTextureHeight(int height) { _textureHeight=height; }
void setTextureDepth(int depth) { _textureDepth=depth; }
virtual int getTextureWidth() const { return _textureWidth; }
virtual int getTextureHeight() const { return _textureHeight; }
virtual int getTextureDepth() const { return _textureDepth; }
class OSG_EXPORT SubloadCallback : public Referenced
{
public:
virtual void load(const Texture3D& texture,State& state) const = 0;
virtual void subload(const Texture3D& texture,State& state) const = 0;
};
void setSubloadCallback(SubloadCallback* cb) { _subloadCallback = cb;; }
SubloadCallback* getSubloadCallback() { return _subloadCallback.get(); }
const SubloadCallback* getSubloadCallback() const { return _subloadCallback.get(); }
/** Helper function. Sets the number of mipmap levels created for this
* texture. Should only be called within an osg::Texture::apply(), or
* during a custom OpenGL texture load. */
void setNumMipmapLevels(unsigned int num) const { _numMipmapLevels=num; }
/** Gets the number of mipmap levels created. */
unsigned int getNumMipmapLevels() const { return _numMipmapLevels; }
/** Copies a two-dimensional texture subimage, as per
* glCopyTexSubImage3D. Updates a portion of an existing OpenGL
* texture object from the current OpenGL background framebuffer
* contents at position \a x, \a y with width \a width and height
* \a height. Loads framebuffer data into the texture using offsets
* \a xoffset, \a yoffset, and \a zoffset. \a width and \a height
* must be powers of two. */
void copyTexSubImage3D(State& state, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height);
/** Bind the texture object. If the texture object hasn't already been
* compiled, create the texture mipmap levels. */
virtual void apply(State& state) const;
/** Encapsulates queries of extension availability, obtains extension
* function pointers, and provides convenience wrappers for
* calling extension functions. */
class OSG_EXPORT Extensions : public osg::Referenced
{
public:
Extensions(unsigned int contextID);
Extensions(const Extensions& rhs);
void lowestCommonDenominator(const Extensions& rhs);
void setupGLExtensions(unsigned int contextID);
void setTexture3DSupported(bool flag) { _isTexture3DSupported=flag; }
bool isTexture3DSupported() const { return _isTexture3DSupported; }
void setTexture3DFast(bool flag) { _isTexture3DFast=flag; }
bool isTexture3DFast() const { return _isTexture3DFast; }
void setMaxTexture3DSize(GLint maxsize) { _maxTexture3DSize=maxsize; }
GLint maxTexture3DSize() const { return _maxTexture3DSize; }
bool isCompressedTexImage3DSupported() const { return glCompressedTexImage3D!=0; }
bool isCompressedTexSubImage3DSupported() const { return glCompressedTexSubImage3D!=0; }
typedef void (GL_APIENTRY * GLTexImage3DProc) ( GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
typedef void (GL_APIENTRY * GLTexSubImage3DProc) ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
typedef void (GL_APIENTRY * CompressedTexImage3DArbProc) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
typedef void (GL_APIENTRY * CompressedTexSubImage3DArbProc) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
typedef void (GL_APIENTRY * GLCopyTexSubImageProc) ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
GLTexImage3DProc glTexImage3D;
GLTexSubImage3DProc glTexSubImage3D;
CompressedTexImage3DArbProc glCompressedTexImage3D;
CompressedTexSubImage3DArbProc glCompressedTexSubImage3D;
GLCopyTexSubImageProc glCopyTexSubImage3D;
protected:
~Extensions() {}
bool _isTexture3DSupported;
bool _isTexture3DFast;
GLint _maxTexture3DSize;
};
/** Encapsulates queries of extension availability, obtains extension
* function pointers, and provides convenience wrappers for
* calling extension functions. */
static Extensions* getExtensions(unsigned int contextID,bool createIfNotInitalized);
/** Overrides Extensions objects across graphics contexts. Typically
* used to ensure the same lowest common denominator of extensions
* on systems with different graphics pipes. */
static void setExtensions(unsigned int contextID,Extensions* extensions);
protected :
virtual ~Texture3D();
void computeRequiredTextureDimensions(State& state, const osg::Image& image,GLsizei& width, GLsizei& height,GLsizei& depth, GLsizei& numMipmapLevels) const;
virtual void computeInternalFormat() const;
void allocateMipmap(State& state) const;
void applyTexImage3D(GLenum target, Image* image, State& state, GLsizei& inwidth, GLsizei& inheight, GLsizei& indepth, GLsizei& numMipmapLevels) const;
/** It's not ideal that _image is mutable, but it's required since
* Image::ensureDimensionsArePowerOfTwo() can only be called in a
* valid OpenGL context, and therefore within Texture::apply, which
* is const. */
mutable ref_ptr<Image> _image;
/** Subloaded images can have different texture and image sizes. */
mutable GLsizei _textureWidth, _textureHeight, _textureDepth;
/** Number of mip map levels the the texture has been created with, */
mutable GLsizei _numMipmapLevels;
ref_ptr<SubloadCallback> _subloadCallback;
typedef buffered_value<unsigned int> ImageModifiedCount;
mutable ImageModifiedCount _modifiedCount;
};
}
#endif