compling error in Visual c++

[yanwan]

Hello
I am now compling a project, but in one source file of this project, I met
this problem. It seems very strange.

Below is this source file:
----------------------------------------
#include "icarus_types.h"

#ifdef WIN32
#include <GL/glu.h>
#include <GL/glext.h>
extern PFNGLCONVOLUTIONFILTER2DPROC glConvolutionFilter2D;
extern PFNGLCONVOLUTIONPARAMETERIPROC glConvolutionParameteri;
#endif

extern Form *form;
extern Project *project;
extern psRand myrand;
extern int can_convolve;

SpecularPatch::SpecularPatch(Patch *patch, int i0, int i1, int i2)
{
this->index[0]= i0;
this->index[1]= i1;
this->index[2]= i2;

// sum radiance
this->L[0]= patch->E[0]+patch->B[0];
this->L[1]= patch->E[1]+patch->B[1];
this->L[2]= patch->E[2]+patch->B[2];
}

SpecularPatch::~SpecularPatch()
{
}

void Project::buildSpecularEnvironment()
{
Octree *octree;
OctreeVertex *ov;
Object *obj;
int face;
Patch *patch;
SpecularPatch *spatch;
int i,j,i0,i1,i2;

// count max vertices and patches
i= 0;
this->num_specular_patches= 0;
for (obj= this->objects; obj; obj= obj->next)
for (face= 0; face< obj->num_faces; face++)
{
this->num_specular_patches += obj->faces[face].num_patches;
i += 3*obj->faces[face].num_patches;
}

// initialise
this->specular_patches=
(SpecularPatch**)calloc(this->num_specular_patches,sizeof(SpecularPatch*));
this->specular_index_array= (unsigned
int*)calloc(this->num_specular_patches*3,sizeof(unsigned int));

// allocate octree vertex storage
octree= new Octree(this->bb.min,this->bb.max,i);

// place all patch vertices into an octree
this->num_specular_patches= 0;
int k= 0;
for (obj= this->objects; obj; obj= obj->next)
for (face= 0; face< obj->num_faces; face++)
for (i= 0; i< obj->faces[face].num_patches; i++)
{
patch= obj->faces[face].patches[i];

// insert vertices into the octree
i0= octree->addVertex(patch->vertex[0],patch->normal,0,0,0,0);
i1= octree->addVertex(patch->vertex[1],patch->normal,0,0,0,0);
i2= octree->addVertex(patch->vertex[2],patch->normal,0,0,0,0);

// make a new specular patch
spatch= new SpecularPatch(patch,i0,i1,i2);
this->specular_patches[this->num_specular_patches++]= spatch;

// store indices
this->specular_index_array[k++]= i0;
this->specular_index_array[k++]= i1;
this->specular_index_array[k++]= i2;
}

// allocate specular vertex storage
this->num_specular_vertices= octree->num_vertices;
this->specular_radiances=
(SpecularRadiance*)calloc(this->num_specular_vertices,sizeof(SpecularRadiance)) ;
this->specular_vertices=
(SpecularVertex*)calloc(this->num_specular_vertices,sizeof(SpecularVertex));

// store data
for (i= 0; i< this->num_specular_vertices; i++)
{
// fetch octree vertex
ov= octree->vertices[i];

// make a new specular vertex
this->specular_vertices[i].pos= VectorSet(ov->x,ov->y,ov->z);

this->specular_vertices[i].col[0]= (unsigned char)(myrand.rand(255));
this->specular_vertices[i].col[1]= (unsigned char)(myrand.rand(255));
this->specular_vertices[i].col[2]= (unsigned char)(myrand.rand(255));
this->specular_vertices[i].col[3]= 255;
}

// delete the octree
delete octree;

for (j= 0; j< this->num_specular_patches; j++)
{
spatch= this->specular_patches[j];

// average patch radiance at vertices
for (i= 0; i< 3; i++)
{
this->specular_radiances[spatch->index[i]].L[0] += spatch->L[0];
this->specular_radiances[spatch->index[i]].L[1] += spatch->L[1];
this->specular_radiances[spatch->index[i]].L[2] += spatch->L[2];
this->specular_radiances[spatch->index[i]].count++;
}

// calculate surface normal
spatch->normal=
VectorNormalize(VectorCrossProduct(VectorSub(this->specular_vertices[spatch->index[1]].pos,this->specular_vertices[spatch->index[0]].pos),VectorSub(this->specular_vertices[spatch->index[2]].pos,this->specular_vertices[spatch->index[0]].pos)));
}

for (i= 0; i< this->num_specular_vertices; i++)
if (this->specular_radiances[i].count > 0)
{
this->specular_radiances[i].L[0] /=
(float)(M_PI*this->specular_radiances[i].count);
this->specular_radiances[i].L[1] /=
(float)(M_PI*this->specular_radiances[i].count);
this->specular_radiances[i].L[2] /=
(float)(M_PI*this->specular_radiances[i].count);
}
}

static void setMat(Vector right, Vector up, Vector view, Vector eye)
{
float mat[16];

mat[0]= right.x;
mat[1]= up.x;
mat[2]= view.x;
mat[3]= 0.0;

mat[4]= right.y;
mat[5]= up.y;
mat[6]= view.y;
mat[7]= 0.0;

mat[8]= right.z;
mat[9]= up.z;
mat[10]= view.z;
mat[11]= 0.0;

mat[12]= 0.0;
mat[13]= 0.0;
mat[14]= 0.0;
mat[15]= 1.0;

glLoadMatrixf(mat);
glTranslatef(-eye.x, -eye.y, -eye.z);
}

//#define __DUMP

void Frame::buildEnvMaps()
{
if (project->model_type!=MODEL_ILLUMINATION &&
project->model_type!=MODEL_RTT_ILL) return;

Material *mat;
int i,j;
float mvm[16];
Instance *inst;

// loop over each instance
for (j= 0, inst= project->instances; inst; j++, inst= inst->next)
if (inst->bti)
{
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glDisable(GL_LIGHTING);
glClearColor(0,0,0,0);

// prepare projection
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluPerspective(90.0, 1.0, 0.01, 100.0);

glMatrixMode(GL_MODELVIEW);
glPushMatrix();

glPushAttrib(GL_VIEWPORT_BIT);
glViewport(0,0, _ENVMAP_SIZE,_ENVMAP_SIZE);

// loop over each specular material
for (i= 0; i< inst->prim->num_materials; i++)
if (inst->bti[i] > 0)
{
mat= inst->prim->materials[i];

glMatrixMode(GL_MODELVIEW);
glGetFloatv(GL_MODELVIEW_MATRIX, mvm);
Vector right= VectorSet(mvm[0], mvm[4], mvm[8]);
Vector up= VectorSet(mvm[1], mvm[5], mvm[9]);
Vector view= VectorSet(mvm[2], mvm[6], mvm[10]);
Vector eye= inst->material_centres[i];
glLoadIdentity();

// tone-map the scene to match this material
project->toneMapSpecular(this,mat);

// bind this texture map
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, inst->bti[i]);

#define MAX_BLUR 8

// what's the filter size?
int filter_size;
if (mat->shi == 256.0)
filter_size= 0;
else
filter_size= (int)(MAX_BLUR*(1.0-mat->shi/256.0));

if (filter_size > 0)
{
if (filter_size > MAX_BLUR)
filter_size= MAX_BLUR;

// build an NxN convolution filter
int sz= filter_size*filter_size;
float *filter= (float*)malloc(sz*sizeof(float));
for (int n= 0; n< sz; n++)
filter[n]= 1.0/(float)sz;

if (can_convolve)
{
glConvolutionFilter2D(GL_CONVOLUTION_2D,GL_LUMINAN CE,filter_size,filter_size,GL_LUMINANCE,GL_FLOAT,f ilter);
glConvolutionParameteri(GL_CONVOLUTION_2D,GL_CONVO LUTION_BORDER_MODE,GL_REPLICATE_BORDER_HP);
}
glEnable(GL_CONVOLUTION_2D);

free(filter);
}

// draw each face
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setMat(right, VectorScalar(up,-1), VectorScalar(view,-1), eye);
project->drawSpecular(inst,mat);
glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z _ARB, 0, 0, 0, 0,
0, _ENVMAP_SIZE,_ENVMAP_SIZE);

#ifdef __DUMP
{
glDisable(GL_CONVOLUTION_2D);
unsigned char buf[4*_ENVMAP_SIZE*_ENVMAP_SIZE];
glReadPixels(0,0,_ENVMAP_SIZE,_ENVMAP_SIZE,GL_RGBA ,GL_UNSIGNED_BYTE,buf);
FILE *f= fopen("m1.ppm","w");
fprintf(f,"P6\n%d %d\n255\n",_ENVMAP_SIZE,_ENVMAP_SIZE);
for (int j= 0; j< _ENVMAP_SIZE*_ENVMAP_SIZE; j++)
{
unsigned char c= buf[4*j+0];
fwrite(&c,1,1,f);
c= buf[4*j+1];
fwrite(&c,1,1,f);
c= buf[4*j+2];
fwrite(&c,1,1,f);
}
fclose(f);
glEnable(GL_CONVOLUTION_2D);
}
#endif

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setMat(VectorScalar(right,-1), VectorScalar(up,-1), view, eye);
project->drawSpecular(inst,mat);
glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z _ARB, 0, 0, 0, 0,
0, _ENVMAP_SIZE,_ENVMAP_SIZE);

#ifdef __DUMP
{
glDisable(GL_CONVOLUTION_2D);
unsigned char buf[4*_ENVMAP_SIZE*_ENVMAP_SIZE];
glReadPixels(0,0,_ENVMAP_SIZE,_ENVMAP_SIZE,GL_RGBA ,GL_UNSIGNED_BYTE,buf);
FILE *f= fopen("m2.ppm","w");
fprintf(f,"P6\n%d %d\n255\n",_ENVMAP_SIZE,_ENVMAP_SIZE);
for (int j= 0; j< _ENVMAP_SIZE*_ENVMAP_SIZE; j++)
{
unsigned char c= buf[4*j+0];
fwrite(&c,1,1,f);
c= buf[4*j+1];
fwrite(&c,1,1,f);
c= buf[4*j+2];
fwrite(&c,1,1,f);
}
fclose(f);
glEnable(GL_CONVOLUTION_2D);
}
#endif

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setMat(view, VectorScalar(up,-1), right, eye);
project->drawSpecular(inst,mat);
glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X _ARB, 0, 0, 0, 0,
0, _ENVMAP_SIZE,_ENVMAP_SIZE);

#ifdef __DUMP
{
glDisable(GL_CONVOLUTION_2D);
unsigned char buf[4*_ENVMAP_SIZE*_ENVMAP_SIZE];
glReadPixels(0,0,_ENVMAP_SIZE,_ENVMAP_SIZE,GL_RGBA ,GL_UNSIGNED_BYTE,buf);
FILE *f= fopen("m3.ppm","w");
fprintf(f,"P6\n%d %d\n255\n",_ENVMAP_SIZE,_ENVMAP_SIZE);
for (int j= 0; j< _ENVMAP_SIZE*_ENVMAP_SIZE; j++)
{
unsigned char c= buf[4*j+0];
fwrite(&c,1,1,f);
c= buf[4*j+1];
fwrite(&c,1,1,f);
c= buf[4*j+2];
fwrite(&c,1,1,f);
}
fclose(f);
glEnable(GL_CONVOLUTION_2D);
}
#endif

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setMat(VectorScalar(view,-1), VectorScalar(up,-1),
VectorScalar(right,-1), eye);
project->drawSpecular(inst,mat);
glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X _ARB, 0, 0, 0, 0,
0, _ENVMAP_SIZE,_ENVMAP_SIZE);

#ifdef __DUMP
{
glDisable(GL_CONVOLUTION_2D);
unsigned char buf[4*_ENVMAP_SIZE*_ENVMAP_SIZE];
glReadPixels(0,0,_ENVMAP_SIZE,_ENVMAP_SIZE,GL_RGBA ,GL_UNSIGNED_BYTE,buf);
FILE *f= fopen("m4.ppm","w");
fprintf(f,"P6\n%d %d\n255\n",_ENVMAP_SIZE,_ENVMAP_SIZE);
for (int j= 0; j< _ENVMAP_SIZE*_ENVMAP_SIZE; j++)
{
unsigned char c= buf[4*j+0];
fwrite(&c,1,1,f);
c= buf[4*j+1];
fwrite(&c,1,1,f);
c= buf[4*j+2];
fwrite(&c,1,1,f);
}
fclose(f);
glEnable(GL_CONVOLUTION_2D);
}
#endif

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setMat(right, VectorScalar(view,-1), up, eye);
project->drawSpecular(inst,mat);
glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y _ARB, 0, 0, 0, 0,
0, _ENVMAP_SIZE,_ENVMAP_SIZE);

#ifdef __DUMP
{
glDisable(GL_CONVOLUTION_2D);
unsigned char buf[4*_ENVMAP_SIZE*_ENVMAP_SIZE];
glReadPixels(0,0,_ENVMAP_SIZE,_ENVMAP_SIZE,GL_RGBA ,GL_UNSIGNED_BYTE,buf);
FILE *f= fopen("m5.ppm","w");
fprintf(f,"P6\n%d %d\n255\n",_ENVMAP_SIZE,_ENVMAP_SIZE);
for (int j= 0; j< _ENVMAP_SIZE*_ENVMAP_SIZE; j++)
{
unsigned char c= buf[4*j+0];
fwrite(&c,1,1,f);
c= buf[4*j+1];
fwrite(&c,1,1,f);
c= buf[4*j+2];
fwrite(&c,1,1,f);
}
fclose(f);
glEnable(GL_CONVOLUTION_2D);
}
#endif

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setMat(right, view, VectorScalar(up,-1), eye);
project->drawSpecular(inst,mat);
glCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y _ARB, 0, 0, 0, 0,
0, _ENVMAP_SIZE,_ENVMAP_SIZE);

#ifdef __DUMP
{
glDisable(GL_CONVOLUTION_2D);
unsigned char buf[4*_ENVMAP_SIZE*_ENVMAP_SIZE];
glReadPixels(0,0,_ENVMAP_SIZE,_ENVMAP_SIZE,GL_RGBA ,GL_UNSIGNED_BYTE,buf);
FILE *f= fopen("m6.ppm","w");
fprintf(f,"P6\n%d %d\n255\n",_ENVMAP_SIZE,_ENVMAP_SIZE);
for (int j= 0; j< _ENVMAP_SIZE*_ENVMAP_SIZE; j++)
{
unsigned char c= buf[4*j+0];
fwrite(&c,1,1,f);
c= buf[4*j+1];
fwrite(&c,1,1,f);
c= buf[4*j+2];
fwrite(&c,1,1,f);
}
fclose(f);
glEnable(GL_CONVOLUTION_2D);
}
#endif

if (filter_size > 0)
glDisable(GL_CONVOLUTION_2D);
}

glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);

glPopAttrib();
}
}

void Project::toneMapSpecular(Frame *fr, Material *mat)
{
int i;
float L[3];
float k;

// find specular scaling factor
k= 1.0/M_PI;

for (i= 0; i< this->num_specular_vertices; i++)
{
// reflect radiance at the surface
L[0]= mat->spe[0]*k*this->specular_radiances[i].L[0];
L[1]= mat->spe[1]*k*this->specular_radiances[i].L[1];
L[2]= mat->spe[2]*k*this->specular_radiances[i].L[2];

// tone-map
fr->img->toneMap(fr->img->method,fr->img->exptime,L,this->specular_vertices[i].col,true);

// gamma correct
this->specular_vertices[i].col[0]=
this->gamma[this->specular_vertices[i].col[0]];
this->specular_vertices[i].col[1]=
this->gamma[this->specular_vertices[i].col[1]];
this->specular_vertices[i].col[2]=
this->gamma[this->specular_vertices[i].col[2]];
}
}

----------------------------------------------------------------
It seems very well in linux complie enivronment(Told by my friends). But in
Visual Studio, after build it, it appears:
--------------------------------
Compiling...
icarus_specular.cpp
D:\cvs\icarus\render\icarus_specular.cpp(8) : error C2146: syntax error :
missing ';' before identifier 'glConvolutionFilter2D'
D:\cvs\icarus\render\icarus_specular.cpp(8) : fatal error C1004: unexpected
end of file found
Error executing cl.exe.

icarus_specular.obj - 2 error(s), 0 warning(s)
-------------------------------------------------------

And after I add a header file "# include <GL/glew.h> "
the error appears as:
-------------------------------------
Compiling...
icarus_specular.cpp
D:\cvs\icarus\render\icarus_specular.cpp(8) : warning C4273:
'__glewConvolutionFilter2D' : inconsistent dll linkage. dllexport assumed.
D:\cvs\icarus\render\icarus_specular.cpp(9) : warning C4273:
'__glewConvolutionParameteri' : inconsistent dll linkage. dllexport
assumed.
D:\cvs\icarus\render\icarus_specular.cpp(236) : error C2065:
'GL_REPLICATE_BORDER_HP' : undeclared identifier
Error executing cl.exe.

icarus_specular.obj - 1 error(s), 2 warning(s)
-----------------------------------------------------

It is strange, becuase 'GL_REPLICATE_BORDER_HP' has been defined in file
"GL/glext.h". And I have also included this header file.
I don't know why. Is it becuase the opengl library I added was not proper?
Or because something else? Something similar also happens in the other file.
I hope someone can give me some advice.

Cheers
yanwan

[Joona I Palaste]

yanwan <ya********@postgrad.manchester.ac.uk> scribbled the following:

Hello
I am now compling a project, but in one source file of this project, I met
this problem. It seems very strange.

Why are you asking a C++ question in a C newsgroup? Try comp.lang.c++
instead. They'll either fix your problem or refer you to a Visual C++
newsgroup.

--
/-- Joona Palaste (pa*****@cc.helsinki.fi) ------------- Finland --------\
\-------------------------------------------------------- rules! --------/
"The day Microsoft makes something that doesn't suck is probably the day they
start making vacuum cleaners."
- Ernst Jan Plugge

[CBFalconer]

yanwan wrote:

I am now compling a project, but in one source file of this
project, I met this problem. It seems very strange.

Below is this source file:
----------------------------------------
#include "icarus_types.h"
Non-standard C header file.

#ifdef WIN32
undefined ID
#include <GL/glu.h>
Non-standard C header file.
#include <GL/glext.h>
Non-standard C header file.
extern PFNGLCONVOLUTIONFILTER2DPROC glConvolutionFilter2D;
undefined ID
extern PFNGLCONVOLUTIONPARAMETERIPROC glConvolutionParameteri;
undefined ID
#endif

extern Form *form;
undefined ID
extern Project *project;
undefined ID
extern psRand myrand;
undefined ID
extern int can_convolve;
undefined ID

SpecularPatch::SpecularPatch(Patch *patch, int i0, int i1, int i2)

Now this is totally ridiculous. There is no :: operator in the C
language. Methinks you are in the wrong newsgroup, besides dealing
in all sorts of system specific nonsense.

--
Chuck F (cb********@yahoo.com) (cb********@worldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net> USE worldnet address!

[Martin Ambuhl]

yanwan wrote:

Hello
I am now compling a project, but in one source file of this project, I met
this problem. It seems very strange.

C++ questions belong in comp.lang.c++ or some other C++ newsgroup, not
comp.lang.c.

Questions involving non-standard headers like "icarus_types.h",
<GL/glu.h>, and <GL/glext.h> need sufficient information for a
compilable example for those not using those.

Questions specific to Windows linkage belong in a Windows-specific
newsgroup. Questions specific to Visual Studio belong in some other
Gatesware-specific newsgroup.

Excessively long code is unwelcome everywhere. When you find the
appropriate newsgroup for your question, post only as long a program as
required to illustrate you program. But check that group's backtraffic
and FAQ before posting.

It is unusual to see a post in comp.lang.c that is off-topic for as many
reasons as yours is.

[Guillaume]

This is obviously a strictly "OpenGL on Windows"-related problem.

Just ask in an OpenGL and/or a Windows development newsgroup.