#include <OpenGl_telem_util.hxx>
#include <OpenGl_TextureBox.hxx>
-#include <OpenGl_Memory.hxx>
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_Structure.hxx>
struct SEQ_
{
- Tint ts_num, ts_alloc;
- void **tmesh_sequence;
+ NCollection_Vector<void *> tmesh_sequence;
GLenum triangle_type; /* FSXXX OPTI */
DEFINE_STANDARD_ALLOC
};
-struct OPENGL_DISPLAY_PGN
-{
- Tint num_of_seq;
- Tint num_alloc;
- SEQ_ *seq;
- DEFINE_STANDARD_ALLOC
-};
-
static void bgntriangulate( const TEL_POLYGON_DATA *, void (APIENTRY*)() );
static void endtriangulate(void);
/* JWR - allow varying the size */
-#define INCREMENT 8
-
-static int seq_increment = INCREMENT;
-
static const TEL_POLYGON_DATA *DaTa;
static GLUtesselator *tripak = 0;
STATIC void APIENTRY
out_bgntmesh( GLenum triangle_type )
{
- OPENGL_DISPLAY_PGN *dis = DaTa->dsply;
-
- dis->num_of_seq++;
- if( dis->num_alloc < dis->num_of_seq )
- {
- dis->num_alloc += seq_increment;
-
- if( dis->seq == 0 )
- {
- dis->seq = new SEQ_[dis->num_alloc];
- }
- else
- {
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
- dis->seq = (SEQ_*)realloc( dis->seq, dis->num_alloc*sizeof(SEQ_) );
-#else
- dis->seq = cmn_resizemem<SEQ_>( dis->seq, dis->num_alloc );
-#endif
- }
- }
- dis->seq[ dis->num_of_seq - 1 ].ts_num = 0;
- dis->seq[ dis->num_of_seq - 1 ].ts_alloc = 0;
- dis->seq[ dis->num_of_seq - 1 ].tmesh_sequence = 0;
+ NCollection_Vector<SEQ_> *dis = DaTa->dsply;
+ SEQ_ aSeq;
#ifdef JWR_DEC_TRIFAN_BUG
- dis->seq[ dis->num_of_seq - 1 ].triangle_type = GL_POLYGON;
+ aSeq.triangle_type = GL_POLYGON;
+ dis->Append(aSeq);
glBegin(GL_POLYGON);
#else
- dis->seq[ dis->num_of_seq - 1 ].triangle_type = triangle_type;
+ aSeq.triangle_type = triangle_type;
+ dis->Append(aSeq);
glBegin(triangle_type);
#endif
}
STATIC void APIENTRY
out_vert1( void *data )
{
- SEQ_ *s = &( DaTa->dsply->seq[ DaTa->dsply->num_of_seq - 1 ] );
-
- s->ts_num++;
- if( s->ts_alloc < s->ts_num )
- {
- s->ts_alloc += seq_increment;
-
- if( s->tmesh_sequence == 0 )
- {
- s->tmesh_sequence = new void*[s->ts_alloc];
- }
- else
- {
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
- s->tmesh_sequence = (void**)realloc( s->tmesh_sequence, s->ts_alloc*sizeof(void*));
-#else
- s->tmesh_sequence = cmn_resizemem<void*>( s->tmesh_sequence, s->ts_alloc);
-#endif
- }
- }
- s->tmesh_sequence[ s->ts_num - 1 ] = data;
+ SEQ_ &s = DaTa->dsply->ChangeValue(DaTa->dsply->Length() - 1);
+ s.tmesh_sequence.Append(data);
if ( data < (void *)0xffff ) {
long a = (long)data;
STATIC void APIENTRY
out_vert2( void *data )
{
- SEQ_ *s = &( DaTa->dsply->seq[ DaTa->dsply->num_of_seq - 1 ] );
+ SEQ_ &s = DaTa->dsply->ChangeValue(DaTa->dsply->Length() - 1);
- s->ts_num++;
- if( s->ts_alloc < s->ts_num )
- {
- s->ts_alloc += seq_increment;
-
- if( s->tmesh_sequence == 0 )
- {
- s->tmesh_sequence = new void*[s->ts_alloc];
- }
- else
- {
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
- s->tmesh_sequence = (void**)( s->tmesh_sequence, s->ts_alloc*sizeof(void*) );
-#else
- s->tmesh_sequence = cmn_resizemem<void*>( s->tmesh_sequence, s->ts_alloc );
-#endif
- }
- }
- s->tmesh_sequence[ s->ts_num - 1 ] = data;
+ s.tmesh_sequence.Append(data);
if ( data < (void *)0xffff ) {
long a = (long)data;
STATIC void APIENTRY
out_vert3( void *data )
{
- SEQ_ *s = &( DaTa->dsply->seq[ DaTa->dsply->num_of_seq - 1 ] );
+ SEQ_ &s = DaTa->dsply->ChangeValue(DaTa->dsply->Length() - 1);
- s->ts_num++;
- if( s->ts_alloc < s->ts_num )
- {
- s->ts_alloc += seq_increment;
-
- if( s->tmesh_sequence == 0 )
- {
- s->tmesh_sequence = new void*[s->ts_alloc];
- }
- else
- {
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
- s->tmesh_sequence = (void**)realloc( s->tmesh_sequence, s->ts_alloc*sizeof(void*) );
-#else
- s->tmesh_sequence = cmn_resizemem<void*>( s->tmesh_sequence, s->ts_alloc );
-#endif
- }
- }
- s->tmesh_sequence[ s->ts_num - 1 ] = data;
+ s.tmesh_sequence.Append(data);
if ( data <= (void *)0xffff ) {
long a = (long)data;
STATIC void APIENTRY
mycombine( GLdouble coords[3], int *data, GLfloat w[4], void **dataout)
{
- extra_vertex new_vertex = (extra_vertex) malloc(sizeof(EXTRA_VERTEX));
+ extra_vertex new_vertex = new EXTRA_VERTEX();
new_vertex->vert[0] = ( float )coords[0];
new_vertex->vert[1] = ( float )coords[1];
SEQ_ *s;
extra_vertex b;
- OPENGL_DISPLAY_PGN *dis = myData.dsply;
- for( i = 0; i < dis->num_of_seq; i++ )
+ NCollection_Vector<SEQ_> *dis = myData.dsply;
+ for( i = 0; i < dis->Length(); i++ )
{
- s = &(dis->seq[i]);
+ s = &(dis->ChangeValue(i));
glBegin(s->triangle_type);
switch( v )
{
case 1:
{
- for( j = 0, k = 0; j < s->ts_num; j++ )
+ for( j = 0, k = 0; j < s->tmesh_sequence.Length(); j++ )
{
- if ( s->tmesh_sequence[j] < (void *)0xffff )
- glVertex3fv( myData.vertices[ (long)s->tmesh_sequence[ j ] ].xyz );
+ if ( s->tmesh_sequence(j) < (void *)0xffff )
+ glVertex3fv( myData.vertices[ (long)s->tmesh_sequence.Value(j) ].xyz );
else {
- extra_vertex b = (extra_vertex)s->tmesh_sequence[j];
+ b = (extra_vertex) s->tmesh_sequence(j);
glVertex3fv( b->vert );
}
}
case 2:
{
- for( j = 0, k = 0; j < s->ts_num; j++ )
+ for( j = 0, k = 0; j < s->tmesh_sequence.Length(); j++ )
{
- if ( s->tmesh_sequence[j] < (void *)0xffff ) {
- glColor3fv( myData.vcolours[ (long) s->tmesh_sequence[ j ] ].rgb );
- glVertex3fv( myData.vertices[ (long) s->tmesh_sequence[ j ] ].xyz );
+ if ( s->tmesh_sequence(j) < (void *)0xffff ) {
+ glColor3fv( myData.vcolours[ (long) s->tmesh_sequence(j) ].rgb );
+ glVertex3fv( myData.vertices[ (long) s->tmesh_sequence(j) ].xyz );
} else {
- b = (extra_vertex) s->tmesh_sequence[j];
+ b = (extra_vertex) s->tmesh_sequence(j);
glColor3fv( myData.vcolours[(b->ind)].rgb);
glVertex3fv( b->vert );
}
}
case 3:
{
- for( j = 0, k = 0; j < s->ts_num; j++ )
+ for( j = 0, k = 0; j < s->tmesh_sequence.Length(); j++ )
{
- if ( s->tmesh_sequence[j] < (void *)0xffff ) {
- glNormal3fv( myData.vnormals[ (long) s->tmesh_sequence[ j ] ].xyz);
- glVertex3fv( myData.vertices[ (long) s->tmesh_sequence[ j ] ].xyz);
+ if ( s->tmesh_sequence(j) < (void *)0xffff ) {
+ glNormal3fv( myData.vnormals[ (long) s->tmesh_sequence(j) ].xyz);
+ glVertex3fv( myData.vertices[ (long) s->tmesh_sequence(j) ].xyz);
} else {
- b = (extra_vertex) s->tmesh_sequence[j];
+ b = (extra_vertex) s->tmesh_sequence(j);
glNormal3fv( myData.vnormals[(b->ind)].xyz);
glVertex3fv( b->vert );
}
}
#endif
- myData.dsply = new OPENGL_DISPLAY_PGN();
- myData.dsply->num_of_seq = 0;
- myData.dsply->num_alloc = 0;
- myData.dsply->seq = NULL;
+ myData.dsply = new NCollection_Vector<SEQ_>();
}
/*----------------------------------------------------------------------*/
{
Tint i, j;
- for( i = 0; i < myData.dsply->num_of_seq; i++ )
+ for( i = 0; i < myData.dsply->Length(); i++ )
{
- if(myData.dsply->seq[i].tmesh_sequence) {
- for ( j = 0; j < myData.dsply->seq[i].ts_num ; j++ ) {
- if ( myData.dsply->seq[i].tmesh_sequence[j] >= (void *)0xffff )
- free(myData.dsply->seq[i].tmesh_sequence[j]);
- }
+ for ( j = 0; j < myData.dsply->Value(i).tmesh_sequence.Length() ; j++ )
+ {
+ if ( myData.dsply->Value(i).tmesh_sequence(j) >= (void *)0xffff )
+ delete myData.dsply->Value(i).tmesh_sequence(j);
}
- delete[] myData.dsply->seq[i].tmesh_sequence;
}
- delete[] myData.dsply->seq;
+
delete myData.dsply;
}
}
#include <OpenGl_Display.hxx>
#include <OpenGl_TextureBox.hxx>
#include <OpenGl_ImageBox.hxx>
-#include <OpenGl_Memory.hxx>
#include <OpenGl_ResourceCleaner.hxx>
#include <OpenGl_ResourceTexture.hxx>
#include <GL/glu.h> // gluBuild2DMipmaps()
-#define GROW_TEXTURES 8
-#define GROW_TEXTURES_DATA 8
-#define GROW_CONTEXT 8
+#include <NCollection_Vector.hxx>
typedef enum {TEXDATA_NONE, TEXDATA_1D, TEXDATA_2D, TEXDATA_2DMM} texDataStatus;
typedef enum {TEX_NONE, TEX_ALLOCATED} texStatus;
DEFINE_STANDARD_ALLOC
};
+struct contextData
+{
+ GLuint number;
+ GLDRAWABLE drawable;
+ GLCONTEXT context;
+ char use_bind_texture;
+};
struct texDraw
{
TextureDataID data;
- GLuint *number;
- GLDRAWABLE *drawable;
- GLCONTEXT *context;
- char *use_bind_texture;
- int context_count;
- int context_size;
+ NCollection_Vector<contextData> contextdata;
texStatus status;
GLint Gen;
* Variables statiques
*/
-static texDraw *textab = NULL;
-static int textures_count = 0;
-static int textures_size = 0;
+static NCollection_Vector<texDraw> textab;
-static texData *texdata = NULL;
-static int textures_data_count = 0;
-static int textures_data_size = 0;
+static NCollection_Vector<texData> texdata;
static TextureDataID current_texture_data = TEXTUREDATA_ERROR;
static TextureID current_texture = TEXTUREBOX_ERROR;
*/
static TextureDataID FindTextureData(char *FileName)
{
- int i;
-
- for (i=0; i<textures_data_size; i++)
- if ( texdata[i].status!=TEXDATA_NONE && strcmp(FileName, texdata[i].imageFileName)==0 )
+ for (int i = 0; i < texdata.Length(); i++)
+ {
+ if ( texdata(i).status != TEXDATA_NONE && strcmp(FileName, texdata(i).imageFileName) == 0 )
+ {
return i;
+ }
+ }
return TEXTUREDATA_ERROR;
}
*/
static TextureDataID FindFreeTextureData(void)
{
- int i;
-
- /* ya encore de la place ? */
- if (textures_data_count == textures_data_size)
+ for (int i = 0; i < texdata.Length(); i++)
{
- textures_data_size += GROW_TEXTURES_DATA;
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
- texdata = (texData*)realloc(texdata, textures_data_size*sizeof(texData));
-#else
- texdata = cmn_resizemem<texData>(texdata, textures_data_size);
-#endif
- if (texdata == NULL) return TEXTUREDATA_ERROR;
-
- for (i=textures_data_count; i<textures_data_size; i++)
- texdata[i].status = TEXDATA_NONE;
-
- /* on a deja assez perdu de temps comme ca => retourne un ID rapidement... */
- return textures_data_count++;
- }
-
- /* recherche d'un ID libre */
- for (i=0; i<textures_data_size; i++)
- if (texdata[i].status == TEXDATA_NONE)
+ if (texdata(i).status == TEXDATA_NONE)
{
- textures_data_count = Max (textures_data_count, i + 1);
return i;
}
+ }
- return TEXTUREDATA_ERROR;
+ texData aTexData;
+ texdata.Append(aTexData);
+ return texdata.Length() - 1;
}
/*----------------------------------------------------------------------*/
*/
static TextureID FindFreeTexture(void)
{
- int i;
-
- /* ya encore de la place ? */
- if (textures_count == textures_size)
+ for (int i = 0; i < textab.Length(); i++)
{
- textures_size += GROW_TEXTURES;
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
- textab = (texDraw*)realloc(textab, textures_size*sizeof(texDraw));
-#else
- textab = cmn_resizemem<texDraw>(textab, textures_size);
-#endif
- if (textab == NULL) return TEXTUREBOX_ERROR;
-
- for (i=textures_count; i<textures_size; i++)
- textab[i].status = TEX_NONE;
-
- /* on a deja assez perdu de temps comme ca => retourne un ID rapidement... */
- return textures_count++;
- }
-
- for (i=0; i<textures_size; i++)
- if (textab[i].status == TEX_NONE)
+ if (textab(i).status == TEX_NONE)
{
- textures_count = Max (textures_count, i + 1);
return i;
}
+ }
- return TEXTUREBOX_ERROR;
+ texDraw aTexDraw;
+ textab.Append(aTexDraw);
+ return textab.Length() - 1;
}
/*----------------------------------------------------------------------*/
int i;
GLCONTEXT cur = GET_GL_CONTEXT();
- for (i=0; i<textab[ID].context_count; i++)
- if (textab[ID].context[i] == cur)
+ for (i=0; i<textab(ID).contextdata.Length(); i++)
+ if (textab(ID).contextdata(i).context == cur)
return i;
return TEXTUREBOX_ERROR;
{
TextureDataID data;
- data = textab[ID].data;
- switch (texdata[data].status)
+ data = textab(ID).data;
+ switch (texdata(data).status)
{
case TEXDATA_1D:
glTexImage1D(GL_TEXTURE_1D, 0, 4,
- texdata[data].imageWidth, 0,
- GL_RGBA, GL_UNSIGNED_BYTE, texdata[data].image);
+ texdata(data).imageWidth, 0,
+ GL_RGBA, GL_UNSIGNED_BYTE, texdata(data).image);
break;
case TEXDATA_2D:
glTexImage2D(GL_TEXTURE_2D, 0, 4,
- texdata[data].imageWidth, texdata[data].imageHeight, 0,
- GL_RGBA, GL_UNSIGNED_BYTE, texdata[data].image);
+ texdata(data).imageWidth, texdata(data).imageHeight, 0,
+ GL_RGBA, GL_UNSIGNED_BYTE, texdata(data).image);
break;
case TEXDATA_2DMM:
gluBuild2DMipmaps(GL_TEXTURE_2D, 4,
- texdata[data].imageWidth,
- texdata[data].imageHeight,
- GL_RGBA, GL_UNSIGNED_BYTE, texdata[data].image);
+ texdata(data).imageWidth,
+ texdata(data).imageHeight,
+ GL_RGBA, GL_UNSIGNED_BYTE, texdata(data).image);
break;
default:
break;
TextureDataID data;
- data = textab[ID].data;
+ data = textab(ID).data;
glGetIntegerv(GL_MATRIX_MODE, &cur_matrix);
/*
*/
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
- /* if (textab[ID].Gen != GL_SPHERE_MAP)
+ /* if (textab(ID).Gen != GL_SPHERE_MAP)
{*/
- glScalef(textab[ID].scalex, textab[ID].scaley, 1.0);
- glTranslatef(-textab[ID].transx, -textab[ID].transy, 0.0);
- glRotatef(-textab[ID].angle, 0.0, 0.0, 1.0);
+ glScalef(textab(ID).scalex, textab(ID).scaley, 1.0);
+ glTranslatef(-textab(ID).transx, -textab(ID).transy, 0.0);
+ glRotatef(-textab(ID).angle, 0.0, 0.0, 1.0);
/*}*/
/*
* GENERATION AUTOMATIQUE DE TEXTURE
*/
- switch (textab[ID].Gen)
+ switch (textab(ID).Gen)
{
case GL_OBJECT_LINEAR:
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
- glTexGenfv(GL_S, GL_OBJECT_PLANE, textab[ID].Plane1);
- if (texdata[data].status != TEXDATA_1D)
+ glTexGenfv(GL_S, GL_OBJECT_PLANE, textab(ID).Plane1);
+ if (texdata(data).status != TEXDATA_1D)
{
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
- glTexGenfv(GL_T, GL_OBJECT_PLANE, textab[ID].Plane2);
+ glTexGenfv(GL_T, GL_OBJECT_PLANE, textab(ID).Plane2);
}
break;
case GL_SPHERE_MAP:
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
- if (texdata[data].status != TEXDATA_1D)
+ if (texdata(data).status != TEXDATA_1D)
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
break;
glLoadIdentity();
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
- glTexGenfv(GL_S, GL_EYE_PLANE, textab[ID].Plane1);
+ glTexGenfv(GL_S, GL_EYE_PLANE, textab(ID).Plane1);
- if (texdata[data].status != TEXDATA_1D)
+ if (texdata(data).status != TEXDATA_1D)
{
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
- glTexGenfv(GL_T, GL_EYE_PLANE, textab[ID].Plane2);
+ glTexGenfv(GL_T, GL_EYE_PLANE, textab(ID).Plane2);
}
glPopMatrix();
/*
* RENDU DE LA TEXTURE AVEC LES LUMIERES
*/
- glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, textab[ID].Light);
+ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, textab(ID).Light);
/*
* LISSAGE DE LA TEXTURE
*/
- switch (texdata[data].status)
+ switch (texdata(data).status)
{
case TEXDATA_1D:
case TEXDATA_2D:
- glTexParameteri(texdata[data].type, GL_TEXTURE_MAG_FILTER, textab[ID].Render);
- glTexParameteri(texdata[data].type, GL_TEXTURE_MIN_FILTER, textab[ID].Render);
+ glTexParameteri(texdata(data).type, GL_TEXTURE_MAG_FILTER, textab(ID).Render);
+ glTexParameteri(texdata(data).type, GL_TEXTURE_MIN_FILTER, textab(ID).Render);
break;
case TEXDATA_2DMM:
- if (textab[ID].Render == GL_NEAREST)
+ if (textab(ID).Render == GL_NEAREST)
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
/*
* WRAP DE LA TEXTURE
*/
- switch (texdata[data].status)
+ switch (texdata(data).status)
{
case TEXDATA_1D:
- glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, textab[ID].Wrap);
+ glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, textab(ID).Wrap);
break;
case TEXDATA_2D:
case TEXDATA_2DMM:
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, textab[ID].Wrap);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, textab[ID].Wrap);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, textab(ID).Wrap);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, textab(ID).Wrap);
break;
default:
break;
*/
static void MyGenTextureEXT (TextureID ID)
{
- int Context = textab[ID].context_count;
- TextureDataID data = textab[ID].data;
-
- textab[ID].context[Context] = GET_GL_CONTEXT();
- textab[ID].drawable[Context] = GET_GLDEV_CONTEXT();
- textab[ID].use_bind_texture[Context] = (char )GL_TRUE;
- glGenTextures (1, &textab[ID].number[Context]);
- glBindTexture (texdata[data].type, textab[ID].number[Context]);
+ TextureDataID data = textab(ID).data;
+ contextData aContextData;
+
+ aContextData.context = GET_GL_CONTEXT();
+ aContextData.drawable = GET_GLDEV_CONTEXT();
+ aContextData.use_bind_texture = (char )GL_TRUE;
+ glGenTextures (1, &aContextData.number);
+ textab(ID).contextdata.Append(aContextData);
+ glBindTexture (texdata(data).type, aContextData.number);
LoadTexture (ID);
- textab[ID].context_count++;
}
/*----------------------------------------------------------------------*/
*/
static void MyBindTextureEXT (TextureID ID, int Context)
{
- TextureDataID data = textab[ID].data;
- if (texdata[data].status == TEXDATA_NONE)
+ TextureDataID data = textab(ID).data;
+ if (texdata(data).status == TEXDATA_NONE)
return;
- GLenum aParamName = texdata[data].status == TEXDATA_1D ?
- GL_TEXTURE_BINDING_1D : GL_TEXTURE_BINDING_2D;
+ GLenum aParamName = texdata(data).status == TEXDATA_1D ?
+ GL_TEXTURE_BINDING_1D : GL_TEXTURE_BINDING_2D;
GLint aCurrTex = -1;
glGetIntegerv (aParamName, &aCurrTex);
- if (textab[ID].number[Context] != aCurrTex)
+ if (textab(ID).contextdata(Context).number != aCurrTex)
{
- glBindTexture (texdata[data].type, textab[ID].number[Context]);
+ glBindTexture (texdata(data).type, textab(ID).contextdata(Context).number);
}
}
#ifdef PRINT
printf("InstallTextureInContext::installation de la texture dans le context\n");
#endif
-
-
- /* ya encore de la place dans le tableau de context ? */
- if (textab[ID].context_count == textab[ID].context_size)
- {
-#ifdef PRINT
- printf("InstallTextureInContext::allocation dans le context\n");
-#endif
- textab[ID].context_size += GROW_CONTEXT;
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
- textab[ID].number =
- (GLuint*)realloc(textab[ID].number, textab[ID].context_size*sizeof(GLuint));
- textab[ID].context =
- (GLCONTEXT*)realloc(textab[ID].context, textab[ID].context_size*sizeof(GLCONTEXT));
- textab[ID].drawable =
- (GLDRAWABLE*)realloc(textab[ID].drawable, textab[ID].context_size*sizeof(GLDRAWABLE));
- textab[ID].use_bind_texture =
- (char*)realloc(textab[ID].use_bind_texture, textab[ID].context_size);
-#else
- textab[ID].number =
- cmn_resizemem<GLuint>(textab[ID].number, textab[ID].context_size);
- textab[ID].context =
- cmn_resizemem<GLCONTEXT>(textab[ID].context, textab[ID].context_size);
- textab[ID].drawable =
- cmn_resizemem<GLDRAWABLE>(textab[ID].drawable, textab[ID].context_size);
- textab[ID].use_bind_texture =
- cmn_resizemem<char>(textab[ID].use_bind_texture, textab[ID].context_size);
-#endif
- if ( (textab[ID].number == NULL) ||
- (textab[ID].context == NULL) ||
- (textab[ID].drawable == NULL) ||
- (textab[ID].use_bind_texture == NULL) )
- {
- /* erreur => libere tout */
- free(textab[ID].number);
- free(textab[ID].context);
- free(textab[ID].drawable);
- free(textab[ID].use_bind_texture);
- textab[ID].context_size = 0;
-
- return TEXTUREBOX_ERROR;
- }
- }
-
MyGenTextureEXT(ID);
SetTextureParam(ID);
#ifdef PRINT
i = FindFreeTextureData();
if (i == TEXTUREDATA_ERROR) return TEXTUREBOX_ERROR;
- texdata[i].share_count = 0;
- strcpy(texdata[i].imageFileName, FileName);
- texdata[i].image = (GLubyte *)read_texture(FileName,
- &texdata[i].imageWidth,
- &texdata[i].imageHeight,
+ texdata(i).share_count = 0;
+ strcpy(texdata(i).imageFileName, FileName);
+ texdata(i).image = (GLubyte *)read_texture(FileName,
+ &texdata(i).imageWidth,
+ &texdata(i).imageHeight,
&dummy);
- if (texdata[i].image == NULL) return TEXTUREBOX_ERROR;
+ if (texdata(i).image == NULL) return TEXTUREBOX_ERROR;
- texdata[i].status = status;
- texdata[i].type = status2type[status];
+ texdata(i).status = status;
+ texdata(i).type = status2type[status];
}
j = FindFreeTexture();
#ifdef PRINT
printf("GetTexture::installation texture pour obj %d\n", j);
#endif
- textab[j].context_count = 0;
- textab[j].context_size = 0;
- textab[j].number = NULL;
- textab[j].drawable = NULL;
- textab[j].context = NULL;
- textab[j].use_bind_texture = NULL;
- textab[j].data = i;
- textab[j].status = TEX_ALLOCATED;
- texdata[i].share_count++;
+ textab(j).contextdata.Clear();
+ textab(j).data = i;
+ textab(j).status = TEX_ALLOCATED;
+ texdata(i).share_count++;
SetTextureDefaultParams(j);
#ifdef PRINT
- printf("GetTexture::texture %s(%d) texture %d count=%d\n", texdata[i].imageFileName, i, j, texdata[i].share_count);
+ printf("GetTexture::texture %s(%d) texture %d count=%d\n", texdata(i).imageFileName, i, j, texdata(i).share_count);
#endif
}
else
- if (texdata[i].share_count != 0)
- free(texdata[i].image);
+ if (texdata(i).share_count != 0)
+ delete [] texdata(i).image;
return j;
}
i = FindFreeTextureData();
if (i == TEXTUREDATA_ERROR) return TEXTUREBOX_ERROR;
- texdata[i].share_count = 0;
- strcpy(texdata[i].imageFileName, FileName);
- texdata[i].image = (GLubyte *)malloc(width*height*4*sizeof(GLubyte));
- memcpy(texdata[i].image, data, (width*height*4));
- texdata[i].imageWidth = width;
- texdata[i].imageHeight = height;
+ texdata(i).share_count = 0;
+ strcpy(texdata(i).imageFileName, FileName);
+ texdata(i).image = new GLubyte[width*height*4];
+ memcpy(texdata(i).image, data, (width*height*4));
+ texdata(i).imageWidth = width;
+ texdata(i).imageHeight = height;
- if (texdata[i].image == NULL) return TEXTUREBOX_ERROR;
+ if (texdata(i).image == NULL) return TEXTUREBOX_ERROR;
- texdata[i].status = status;
- texdata[i].type = status2type[status];
+ texdata(i).status = status;
+ texdata(i).type = status2type[status];
}
j = FindFreeTexture();
#ifdef PRINT
printf("GetTextureData::installation texture pour obj %d\n", j);
#endif
- textab[j].context_count = 0;
- textab[j].context_size = 0;
- textab[j].number = NULL;
- textab[j].drawable = NULL;
- textab[j].context = NULL;
- textab[j].use_bind_texture = NULL;
- textab[j].data = i;
- textab[j].status = TEX_ALLOCATED;
- texdata[i].share_count++;
+ textab(j).contextdata.Clear();
+ textab(j).data = i;
+ textab(j).status = TEX_ALLOCATED;
+ texdata(i).share_count++;
SetTextureDefaultParams(j);
#ifdef PRINT
- printf("GetTextureData::texture %s(%d) texture %d count=%d\n", texdata[i].imageFileName, i, j, texdata[i].share_count);
+ printf("GetTextureData::texture %s(%d) texture %d count=%d\n", texdata(i).imageFileName, i, j, texdata(i).share_count);
#endif
}
else
- if (texdata[i].share_count != 0)
- free(texdata[i].image);
+ if (texdata(i).share_count != 0)
+ delete [] texdata(i).image;
return j;
}
GLboolean IsTextureValid(TextureID ID)
{
- if ((ID<0) | (ID>=textures_count))
+ if ( (ID < 0) || (ID >= textab.Length()) )
return GL_FALSE;
- if (textab)
- return textab[ID].status == TEX_ALLOCATED;
+ if (textab.Length() > 0)
+ {
+ return textab(ID).status == TEX_ALLOCATED;
+ }
else
- return GL_TRUE;
+ {
+ return GL_FALSE;
+ }
}
/*----------------------------------------------------------------------*/
}
current_texture = ID;
- current_texture_data = textab[ID].data;
+ current_texture_data = textab(ID).data;
}
/*----------------------------------------------------------------------*/
if (!IsTextureValid(ID)) return;
- data = textab[ID].data;
- texdata[data].share_count--;
- if (texdata[data].share_count == 0)
+ data = textab(ID).data;
+ texdata(data).share_count--;
+ if (texdata(data).share_count == 0)
{
// liberation des datas de la textures
- free(texdata[data].image);
+ delete [] texdata(data).image;
// liberation de la texture dans tous les contextes
cur_drawable = GET_GLDEV_CONTEXT();
- for (i = 0; i < textab[ID].context_count; ++i)
+ for (i = 0; i < textab(ID).contextdata.Length(); ++i)
{
cur_context = 0;
bool isResource = false;
- if (textab[ID].use_bind_texture[i])
+ if (textab(ID).contextdata(i).use_bind_texture)
{
- if( !OpenGl_ResourceCleaner::GetInstance()->AddResource(textab[ID].context[i],
- new OpenGl_ResourceTexture(textab[ID].number[i])) )
+ if( !OpenGl_ResourceCleaner::GetInstance()->AddResource(textab(ID).contextdata(i).context,
+ new OpenGl_ResourceTexture(textab(ID).contextdata(i).number)) )
{
GL_MAKE_CURRENT((openglDisplay.IsNull() ? (Display* )NULL : (Display* )openglDisplay->GetDisplay()),
- textab[ID].drawable[i],
- textab[ID].context[i]);
+ textab(ID).contextdata(i).drawable,
+ textab(ID).contextdata(i).context);
// This check has been added to avoid exception,
// which is raised when trying to delete textures when no rendering context is available
cur_context = GET_GL_CONTEXT();
if (cur_context)
- glDeleteTextures (1, &textab[ID].number[i]);
+ glDeleteTextures (1, &textab(ID).contextdata(i).number);
notResource = true;
}
else
GL_MAKE_CURRENT((openglDisplay.IsNull() ? (Display* )NULL : (Display* )openglDisplay->GetDisplay()),
cur_drawable, cur_context);
- texdata[data].status = TEXDATA_NONE;
- if (data + 1 == textures_data_count)
- {
- --textures_data_count;
- }
+ texdata(data).status = TEXDATA_NONE;
- free(textab[ID].context);
- free(textab[ID].drawable);
- free(textab[ID].use_bind_texture);
- free(textab[ID].number);
+ textab(ID).contextdata.Clear();
}
- textab[ID].status = TEX_NONE;
- if (ID + 1 == textures_count)
- {
- --textures_count;
- }
+ textab(ID).status = TEX_NONE;
current_texture_data = TEXTUREDATA_ERROR;
}
{
if (!IsTextureValid(current_texture)) return;
- switch (texdata[current_texture_data].status)
+ switch (texdata(current_texture_data).status)
{
case TEXDATA_1D:
- if (textab[current_texture].Gen != GL_NONE)
+ if (textab(current_texture).Gen != GL_NONE)
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_1D);
break;
case TEXDATA_2D:
case TEXDATA_2DMM:
- if (textab[current_texture].Gen != GL_NONE)
+ if (textab(current_texture).Gen != GL_NONE)
{
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
if ( !IsTextureValid( current_texture ) )
return;
- switch (texdata[current_texture_data].status)
+ switch (texdata(current_texture_data).status)
{
case TEXDATA_1D:
- if (textab[current_texture].Gen != GL_NONE)
+ if (textab(current_texture).Gen != GL_NONE)
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_1D);
break;
case TEXDATA_2D:
case TEXDATA_2DMM:
- if (textab[current_texture].Gen != GL_NONE)
+ if (textab(current_texture).Gen != GL_NONE)
{
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
{
if (!IsTextureValid(ID)) return;
- textab[ID].Light = GL_MODULATE;
+ textab(ID).Light = GL_MODULATE;
}
/*----------------------------------------------------------------------*/
{
if (!IsTextureValid(ID)) return;
- textab[ID].Light = GL_DECAL;
+ textab(ID).Light = GL_DECAL;
}
/*----------------------------------------------------------------------*/
{
if (!IsTextureValid(ID)) return;
- textab[ID].Wrap = GL_CLAMP;
+ textab(ID).Wrap = GL_CLAMP;
}
/*----------------------------------------------------------------------*/
{
if (!IsTextureValid(ID)) return;
- textab[ID].Wrap = GL_REPEAT;
+ textab(ID).Wrap = GL_REPEAT;
}
/*----------------------------------------------------------------------*/
{
if (!IsTextureValid(ID)) return;
- textab[ID].Gen = GL_OBJECT_LINEAR;
- if (sparams != NULL) memcpy(textab[ID].Plane1, sparams, sizeof(sgenparams));
- else memcpy(textab[ID].Plane1, sgenparams, sizeof(sgenparams));
+ textab(ID).Gen = GL_OBJECT_LINEAR;
+ if (sparams != NULL) memcpy(textab(ID).Plane1, sparams, sizeof(sgenparams));
+ else memcpy(textab(ID).Plane1, sgenparams, sizeof(sgenparams));
- if (texdata[textab[ID].data].status != TEXDATA_1D) {
- if (tparams != NULL) memcpy(textab[ID].Plane2, tparams, sizeof(tgenparams));
- else memcpy(textab[ID].Plane2, tgenparams, sizeof(tgenparams));
+ if (texdata(textab(ID).data).status != TEXDATA_1D) {
+ if (tparams != NULL) memcpy(textab(ID).Plane2, tparams, sizeof(tgenparams));
+ else memcpy(textab(ID).Plane2, tgenparams, sizeof(tgenparams));
}
}
{
if (!IsTextureValid(ID)) return;
- textab[ID].Gen = GL_SPHERE_MAP;
+ textab(ID).Gen = GL_SPHERE_MAP;
}
/*----------------------------------------------------------------------*/
{
if (!IsTextureValid(ID)) return;
- textab[ID].Gen = GL_EYE_LINEAR;
- if (sparams != NULL) memcpy(textab[ID].Plane1, sparams, sizeof(sgenparams));
- else memcpy(textab[ID].Plane1, sgenparams, sizeof(sgenparams));
+ textab(ID).Gen = GL_EYE_LINEAR;
+ if (sparams != NULL) memcpy(textab(ID).Plane1, sparams, sizeof(sgenparams));
+ else memcpy(textab(ID).Plane1, sgenparams, sizeof(sgenparams));
- if (texdata[textab[ID].data].status != TEXDATA_1D) {
- if (tparams != NULL) memcpy(textab[ID].Plane2, tparams, sizeof(tgenparams));
- else memcpy(textab[ID].Plane2, tgenparams, sizeof(tgenparams));
+ if (texdata(textab(ID).data).status != TEXDATA_1D) {
+ if (tparams != NULL) memcpy(textab(ID).Plane2, tparams, sizeof(tgenparams));
+ else memcpy(textab(ID).Plane2, tgenparams, sizeof(tgenparams));
}
}
{
if (!IsTextureValid(ID)) return;
- textab[ID].Gen = GL_NONE;
+ textab(ID).Gen = GL_NONE;
}
/*----------------------------------------------------------------------*/
{
if (!IsTextureValid(ID)) return;
- textab[ID].Render = GL_NEAREST;
+ textab(ID).Render = GL_NEAREST;
}
/*----------------------------------------------------------------------*/
{
if (!IsTextureValid(ID)) return;
- textab[ID].Render = GL_LINEAR;
+ textab(ID).Render = GL_LINEAR;
}
/*----------------------------------------------------------------------*/
GLfloat transx, GLfloat transy,
GLfloat angle)
{
- textab[ID].scalex = scalex;
- textab[ID].scaley = scaley;
- textab[ID].transx = transx;
- textab[ID].transy = transy;
- textab[ID].angle = angle;
+ textab(ID).scalex = scalex;
+ textab(ID).scaley = scaley;
+ textab(ID).transx = transx;
+ textab(ID).transy = transy;
+ textab(ID).angle = angle;
}
/*----------------------------------------------------------------------*/
#endif
- textab[ID].scalex = 1.0;
- textab[ID].scaley = 1.0;
- textab[ID].transx = 0.0;
- textab[ID].transy = 0.0;
- textab[ID].angle = 0.0;
+ textab(ID).scalex = 1.0;
+ textab(ID).scaley = 1.0;
+ textab(ID).transx = 0.0;
+ textab(ID).transy = 0.0;
+ textab(ID).angle = 0.0;
- textab[ID].Gen = GL_OBJECT_LINEAR;
- textab[ID].Light = texdata[textab[ID].data].status == TEXDATA_1D ? GL_DECAL : GL_MODULATE;
- textab[ID].Wrap = texdata[textab[ID].data].status == TEXDATA_1D ? GL_CLAMP : GL_REPEAT;
- memcpy(textab[ID].Plane1, sgenparams, sizeof(sgenparams));
- memcpy(textab[ID].Plane2, tgenparams, sizeof(tgenparams));
- textab[ID].Render = texdata[textab[ID].data].status == TEXDATA_1D ? GL_NEAREST : GL_LINEAR;
+ textab(ID).Gen = GL_OBJECT_LINEAR;
+ textab(ID).Light = texdata(textab(ID).data).status == TEXDATA_1D ? GL_DECAL : GL_MODULATE;
+ textab(ID).Wrap = texdata(textab(ID).data).status == TEXDATA_1D ? GL_CLAMP : GL_REPEAT;
+ memcpy(textab(ID).Plane1, sgenparams, sizeof(sgenparams));
+ memcpy(textab(ID).Plane2, tgenparams, sizeof(tgenparams));
+ textab(ID).Render = texdata(textab(ID).data).status == TEXDATA_1D ? GL_NEAREST : GL_LINEAR;
}
/*----------------------------------------------------------------------*/
void TransferTexture_To_Data(TextureID ID, TextureData *TransfDt)
{
/* affectations */
- strcpy(TransfDt->path, texdata[textab[ID].data].imageFileName);
- TransfDt->gen = textab[ID].Gen;
- TransfDt->wrap = textab[ID].Wrap;
- TransfDt->render = textab[ID].Light;
- TransfDt->scalex = textab[ID].scalex;
- TransfDt->scaley = textab[ID].scaley;
- TransfDt->transx = textab[ID].transx;
- TransfDt->transy = textab[ID].transy;
- TransfDt->angle = textab[ID].angle;
- memcpy(TransfDt->plane1, textab[ID].Plane1, sizeof(SizeType));
- memcpy(TransfDt->plane2, textab[ID].Plane2, sizeof(SizeType));
+ strcpy(TransfDt->path, texdata(textab(ID).data).imageFileName);
+ TransfDt->gen = textab(ID).Gen;
+ TransfDt->wrap = textab(ID).Wrap;
+ TransfDt->render = textab(ID).Light;
+ TransfDt->scalex = textab(ID).scalex;
+ TransfDt->scaley = textab(ID).scaley;
+ TransfDt->transx = textab(ID).transx;
+ TransfDt->transy = textab(ID).transy;
+ TransfDt->angle = textab(ID).angle;
+ memcpy(TransfDt->plane1, textab(ID).Plane1, sizeof(SizeType));
+ memcpy(TransfDt->plane2, textab(ID).Plane2, sizeof(SizeType));
}
/*----------------------------------------------------------------------*/
*newID = ID;
/* Donnees concernant les caracteristiques de la texture */
- strcpy(texdata[textab[ID].data].imageFileName, TransfDt->path);
- textab[ID].Gen = TransfDt->gen;
- textab[ID].Wrap = TransfDt->wrap;
- textab[ID].Light = TransfDt->render;
- textab[ID].scalex = TransfDt->scalex;
- textab[ID].scaley = TransfDt->scaley;
- textab[ID].transx = TransfDt->transx;
- textab[ID].transy = TransfDt->transy;
- textab[ID].angle = TransfDt->angle;
- memcpy(textab[ID].Plane1, TransfDt->plane1, sizeof(SizeType));
- memcpy(textab[ID].Plane2, TransfDt->plane2, sizeof(SizeType));
+ strcpy(texdata(textab(ID).data).imageFileName, TransfDt->path);
+ textab(ID).Gen = TransfDt->gen;
+ textab(ID).Wrap = TransfDt->wrap;
+ textab(ID).Light = TransfDt->render;
+ textab(ID).scalex = TransfDt->scalex;
+ textab(ID).scaley = TransfDt->scaley;
+ textab(ID).transx = TransfDt->transx;
+ textab(ID).transy = TransfDt->transy;
+ textab(ID).angle = TransfDt->angle;
+ memcpy(textab(ID).Plane1, TransfDt->plane1, sizeof(SizeType));
+ memcpy(textab(ID).Plane2, TransfDt->plane2, sizeof(SizeType));
}
}
projects / occt.git / commitdiff