Folgende Strukturen:

struct KOPOS
{
	float fx,fy,fz;
	float ftx,fty;
};

struct TRIANGLE
{
	KOPOS kopos[3];
	int iTex;
	float alpha;
	float r,g,b;
};

struct CIRCLE
{
	KOPOS kopos;
	float rad;
	int iTex;
	float alpha;
	float r,g,b;
};

struct CYLINDER
{
	KOPOS kopos;
	float inrad;
	float outrad;
	float length;
	int iTex;
	float alpha;
	float r,g,b;
};

struct SECTOR
{
	long lnumTriangle;
	long lnumCircle;
	long lnumCylinder;
	long lnumObjects;

	TRIANGLE *triangle;
	CIRCLE *circle;
	CYLINDER *cylinder;

};

dann wird das so initialisiert:

int lnumTriangle=2;
int lnumCircle=2;
int lnumCylinder=2;

sSector0.triangle= new TRIANGLE[lnumTriangle];
sSector0.circle= new CIRCLE[lnumCircle];
sSector0.cylinder= new CYLINDER[lnumCylinder];

und dann gibt es folgendes problem:
wenn ich dann die dreiecke usw. zeichnen will und auf die struktur zugreife wie folgt,
funktioniert es:

[...]
int i=0;

	for(i=0; i<sSector0.lnumTriangle; ++i)
	{
		float get=sSector0.triangle[i].r;
[...]

aber so:

[...]
int i=0;
float get=sSector0.triangle[i].r;

	for(i=0; i<sSector0.lnumTriangle; ++i)
	{

[...]

stürtzt das Programm ab!!!
Warum?
Ich kanns drehen und wenden wie ichs will es geht nicht?
Ich weiß echt nicht mehr weiter... wenn ich sofort statische arrays nim, funkt es normal, aber da ich die anzahl der arrays eigentlich aus einer datei lese sollten sie dynamisch sein aber es workt hintn und vorne nicht.
Was muss ich anders machen?

danke schonmal
mfg

wenn ich dann die dreiecke usw. zeichnen will und auf die struktur zugreife wie folgt,
funktioniert es:

[...]
int i=0;

	
	for(i=0; i<sSector0.lnumTriangle; ++i)
	{
		float get=sSector0.triangle[i].r;
[...]

aber so:

[...]
int i=0;
float get=sSector0.triangle[i].r;
	
	for(i=0; i<sSector0.lnumTriangle; ++i)
	{
		
[...]

stürtzt das Programm ab!!!

der erste code verwendet das 'i' aus der schleife, der zweite ein anderes 'i', das möglicherweise so gross ist, dass du über die arraygrenze hinaus zugreifst.

Danke,
mfg

@CodeFinder:
Ja beim debuggen bekomm ich immer AccessViolation errors... genau an der Stelle wos sonst immer abstürzt...

Und an welcher Stelle genau ist das? (hast du mal überprüft, ob lnumTriangle nicht gleich 0 ist?)

was meinst du mit std::vector? wos soll ich das verwenden?

Anstelle deiner blanken Arrays:

struct SECTOR
{
    vector<TRIANGLE> triangle;
    vector<CIRCLE> circle;
    vector<CYLINDER> cylinder;

/*  long lnumTriangle;
    long lnumCircle;
    long lnumCylinder;
    long lnumObjects;

    TRIANGLE *triangle;
    CIRCLE *circle;
    CYLINDER *cylinder;
*/  
};

int lnumTriangle=2;
int lnumCircle=2;
int lnumCylinder=2;
sSector0.triangle.resize(lnumTriangle);
sSector0.circle.resize(lnumCircle);
sSector0.cylinder.resize(lnumCylinder)];

(btw, beim Durchsehen deines Codes ist mir noch etwas aufgefallen - du hast die Zähler-Werte 'lnum...' deines SECTOR nicht initialisiert)

wenn ich den code abändere:

struct SECTOR
{
long lnumTriangle;
long lnumCircle;
long lnumCylinder;
long lnumObjects;

vector<TRIANGLE> triangle;
vector<CIRCLE> circle;
vector<CYLINDER> cylinder;

/TRIANGLE triangle[10];
CIRCLE circle[10];
CYLINDER cylinder[10];/

};

sSector0.triangle.resize(inumTriangle);
sSector0.circle.resize(inumCircle);
sSector0.cylinder.resize(inumCylinder);

bekomm ich 85 fehler; von wegen triangle sei kein object von sector usw...

Ich würde spontan tippen auf "nicht deklarierter Bezeichner vector" - wenn ich richtig liege: du mußt <vector> includen und an den Namensraum std:: denken:

#include <vector>
using std::vector;
...//der Rest wie gehabt

(btw, die lnum... Member brauchst du nicht wirklich - die Anzahl deiner Dreiecke etc kannst du besser über sSector0.triangles.size() ermitteln (das macht weniger Aufwand als wenn du ständig von Hand nachzählen müsstest)

ich hab aber auch probiert auf die in der Sector struktur deklarierten lnum... zuzugreifen, das funktioniert, nur ebm auf die dynamischen will er einfach nicht.

(ein default-konstruierter vector<> ist leer - also ist es in dem Zustand verboten, irgendwas aus seinen Innereien herauszulesen)

struct KOPOS
{
	float fx,fy,fz;
	float ftx,fty;
};

struct TRIANGLE
{
	KOPOS kopos[3];
	int iTex;
	float alpha;
	float r,g,b;
};

struct CIRCLE
{
	KOPOS kopos;
	float rad;
	int iTex;
	float alpha;
	float r,g,b;
};

struct CYLINDER
{
	KOPOS kopos;
	float inrad;
	float outrad;
	float length;
	int iTex;
	float alpha;
	float r,g,b;
};

struct SECTOR
{
	long lnumTriangle;
	long lnumCircle;
	long lnumCylinder;
	long lnumObjects;

	TRIANGLE *triangle;
	CIRCLE *circle;
	CYLINDER *cylinder;

};

SECTOR sSector0;

dann die zuweisung:

char* fgetsN(FILE* fFile)
{
	char* cbuffer=(char*)malloc(256);
	while(!feof(fFile))
	{
		fgets(cbuffer,255,fFile);
		if((cbuffer[0]!='\n')&&(cbuffer[0]!='/')&&(cbuffer[0]!=' '))
			return (char*)cbuffer;
	}

	return (char*)"_eof_";

}

GLvoid GL_Load_Objects()
{
	FILE* fObjects;
	fObjects = fopen("data\\model.txt", "r");
	char* buffer=(char*)malloc(256);
	char cObject[256];
	char cBitmapPathBuf[256];

	while(!feof(fObjects))
	{

		 buffer=fgetsN(fObjects);

		 sscanf(buffer,"NUMTRIANGLE %d\n",&inumTriangle);
		 sSector0.lnumTriangle=inumTriangle;

		 buffer=fgetsN(fObjects);
		 sscanf(buffer,"NUMCIRCLE %d\n",&inumCircle);
		 sSector0.lnumCircle=inumCircle;

		 buffer=fgetsN(fObjects);
		 sscanf(buffer,"NUMCYLINDER %d\n",&inumCylinder);
		 sSector0.lnumCylinder=inumCylinder;

		break;

	}

	sSector0.triangle= new TRIANGLE[inumTriangle];
	sSector0.circle= new CIRCLE[inumCircle];
	sSector0.cylinder= new CYLINDER[inumCylinder];

	int numtriangle=0;
	int numcircle=0;
	int numcylinder=0;

	sSector0.lnumObjects=sSector0.lnumTriangle+sSector0.lnumCircle+sSector0.lnumCylinder;

	while(!feof(fObjects))
	{

		 buffer=fgetsN(fObjects);

		 sscanf(buffer,"BITNUM %i",&bitnum);

		 for(int i=0; i<bitnum; i++)
		 {
			buffer=fgetsN(fObjects);
			sscanf(buffer,"BITTEX %s\n",&cBitmapPathBuf);
			strcpy(cBitmapPath[i],cBitmapPathBuf);

		 }

		break;

	}

	float fx,fy,fz;
	float ftx,fty;
	float r,g,b;
	float alpha;
	int itex;
	float rad,inrad,outrad,length;

	while(true)
	{
		buffer=fgetsN(fObjects);

		if(!strcmp(buffer,"_eof_"))
			break;

		strcpy(cObject,"");
		sscanf(buffer,"OBJECT %s\n",&cObject);

		if(!strcmp(cObject,"TRIANGLE"))
		{
			buffer=fgetsN(fObjects);
			sscanf(buffer,"TEX %i\n",&itex);
			sSector0.triangle[numtriangle].iTex=itex;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"ALPHA %f\n",&alpha);
			sSector0.triangle[numtriangle].alpha=alpha;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"RGB %f %f %f\n",&r,&g,&b);

			sSector0.triangle[numtriangle].r=r;
			sSector0.triangle[numtriangle].g=g;
			sSector0.triangle[numtriangle].b=b;

			for(int i=0; i<3; i++)
			{
				buffer=fgetsN(fObjects);
				sscanf(buffer, "%f %f %f %f %f", &fx, &fy, &fz, &ftx, &fty);
				sSector0.triangle[numtriangle].kopos[i].fx=fx;
				sSector0.triangle[numtriangle].kopos[i].fy=fy;
				sSector0.triangle[numtriangle].kopos[i].fz=fz;

				sSector0.triangle[numtriangle].kopos[i].ftx=ftx;
				sSector0.triangle[numtriangle].kopos[i].fty=fty;
			}

			numtriangle++;

		}
		else if(!strcmp(cObject,"CIRCLE"))
		{
			buffer=fgetsN(fObjects);
			sscanf(buffer,"TEX %i\n",&itex);
			sSector0.circle[numcircle].iTex=itex;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"ALPHA %f\n",&alpha);
			sSector0.circle[numcircle].alpha=alpha;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"RGB %f %f %f\n",&r,&g,&b);

			sSector0.circle[numcircle].r=r;
			sSector0.circle[numcircle].g=g;
			sSector0.circle[numcircle].b=b;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"RAD %f\n",&rad);
			sSector0.circle[numcircle].rad=rad;

			buffer=fgetsN(fObjects);
			sscanf(buffer, "%f %f %f %f %f", &fx, &fy, &fz, &ftx, &fty);
			sSector0.circle[numcircle].kopos.fx=fx;
			sSector0.circle[numcircle].kopos.fy=fy;
			sSector0.circle[numcircle].kopos.fz=fz;

			sSector0.circle[numcircle].kopos.ftx=ftx;
			sSector0.circle[numcircle].kopos.fty=fty;

			numcircle++;	

		}
		else if(!strcmp(cObject,"CYLINDER"))
		{
			buffer=fgetsN(fObjects);
			sscanf(buffer,"TEX %i\n",&itex);
			sSector0.cylinder[numcylinder].iTex=itex;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"ALPHA %f\n",&alpha);
			sSector0.cylinder[numcylinder].alpha=alpha;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"RGB %f %f %f\n",&r,&g,&b);

			sSector0.cylinder[numcylinder].r=r;
			sSector0.cylinder[numcylinder].g=g;
			sSector0.cylinder[numcylinder].b=b;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"INRAD %f\n",&inrad);
			sSector0.cylinder[numcylinder].inrad=inrad;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"OUTRAD %f\n",&outrad);
			sSector0.cylinder[numcylinder].outrad=outrad;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"LENGTH %f\n",&length);
			sSector0.cylinder[numcylinder].length=length;

			buffer=fgetsN(fObjects);
			sscanf(buffer, "%f %f %f %f %f", &fx, &fy, &fz, &ftx, &fty);
			sSector0.cylinder[numcylinder].kopos.fx;
			sSector0.cylinder[numcylinder].kopos.fy;
			sSector0.cylinder[numcylinder].kopos.fz;

			sSector0.cylinder[numcylinder].kopos.ftx;
			sSector0.cylinder[numcylinder].kopos.fty;

			numcylinder++;	
		}
		else
			break;

	}

	fclose(fObjects);

}

dann die verwendung:

GLvoid GL_Load_Lists()
{
	GL_Delete_Lists();
	GL_Reset();

	lListPos=glGenLists(sSector0.lnumObjects);
	lListRunner=lListPos;

	int i=0;
	GLfloat fpx,fpy,fpz,ftpx,ftpy,frad,finrad,foutrad,flength; 
	for(i=0; i<sSector0.lnumTriangle; i++)
	{
		glNewList(lListRunner,GL_COMPILE);
		glColor4f(sSector0.triangle[i].r,sSector0.triangle[i].g,sSector0.triangle[i].b,sSector0.triangle[i].alpha);
		if(sSector0.triangle[i].iTex>0)
		{
			glEnable(GL_TEXTURE_2D);
			glBindTexture(GL_TEXTURE_2D, texture[sSector0.triangle[i].iTex]);
		}
		else
			glDisable(GL_TEXTURE_2D);

		glBegin(GL_TRIANGLES);
		glNormal3f( 0.0f, 0.0f, 1.0f);
		for (int j=0; j<3; j++)
		{

				fpx = sSector0.triangle[i].kopos[j].fx;
				fpy = sSector0.triangle[i].kopos[j].fy;
				fpz = sSector0.triangle[i].kopos[j].fz;
				ftpx = sSector0.triangle[i].kopos[j].ftx;
				ftpy = sSector0.triangle[i].kopos[j].fty;
				glTexCoord2f(ftpx,ftpy); glVertex3f(fpx,fpy,fpz);

		}
		glEnd();
		glEndList();
		lListRunner++;
	}

	for(i=0; i<sSector0.lnumCircle; i++)
	{
		glNewList(lListRunner,GL_COMPILE);
		glColor4f(sSector0.circle[i].r,sSector0.circle[i].g,sSector0.circle[i].b,sSector0.circle[i].alpha);
		if(sSector0.circle[i].iTex>0)
		{
			glEnable(GL_TEXTURE_2D);
			glBindTexture(GL_TEXTURE_2D, texture[sSector0.circle[i].iTex]);
		}
		else
			glDisable(GL_TEXTURE_2D);

		fpx = sSector0.circle[i].kopos.fx;
		fpy = sSector0.circle[i].kopos.fy;
		fpz = sSector0.circle[i].kopos.fz;
		ftpx = sSector0.circle[i].kopos.ftx;
		ftpy = sSector0.circle[i].kopos.fty;
		frad = sSector0.circle[i].rad;

		glTexCoord2f(ftpx,ftpy);
		glTranslatef(fpx,fpy,fpz);
		gluSphere(gluobjects,frad,32,32);

		glEndList();
		lListRunner++;
	}

	for(i=0; i<sSector0.lnumCylinder; i++)
	{
		glNewList(lListRunner,GL_COMPILE);
		glColor4f(sSector0.cylinder[i].r,sSector0.cylinder[i].g,sSector0.cylinder[i].b,sSector0.cylinder[i].alpha);
		if(sSector0.cylinder[i].iTex>0)
		{
			glEnable(GL_TEXTURE_2D);
			glBindTexture(GL_TEXTURE_2D, texture[sSector0.cylinder[i].iTex]);
		}
		else
			glDisable(GL_TEXTURE_2D);

		fpx = sSector0.cylinder[i].kopos.fx;
		fpy = sSector0.cylinder[i].kopos.fy;
		fpz = sSector0.cylinder[i].kopos.fz;
		ftpx = sSector0.cylinder[i].kopos.ftx;
		ftpy = sSector0.cylinder[i].kopos.fty;
		finrad = sSector0.cylinder[i].inrad;
		foutrad = sSector0.cylinder[i].outrad;
		flength = sSector0.cylinder[i].length;

		glTexCoord2f(ftpx,ftpy);
		glTranslatef(fpx,fpy,fpz);
		gluCylinder(gluobjects,finrad,foutrad,flength,32,32);	

		glEndList();
		lListRunner++;
	}

	lListRunner=lListPos;
}

und schließlich die zeichenroutine:

GLvoid GL_Render_Scene()
{

	GL_Cls();
	GL_Reset();

	gluobjects=gluNewQuadric();
	gluQuadricNormals(gluobjects, GLU_SMOOTH);
	gluQuadricTexture(gluobjects, GL_TRUE);

	glPolygonMode(GL_BACK, GL_POLY_MODE);                     
	glPolygonMode(GL_FRONT, GL_POLY_MODE);

	glRotatef(ydrehwinkel,0,1,0);
	glRotatef(xdrehwinkel,1,0,0);

	GL_Set3DPos(xweg/iRunFactor-2.0f,yweg/iRunFactor+0.0f,zweg/iRunFactor-12.0f);     

	int i=0;

    // wenn dieser teil ausklammert ist, läuft es, wenn nicht, stürtzt es ab...
       glColor4f(sSector0.triangle[i].r,
                      sSector0.triangle[i].g,
                      sSector0.triangle[i].b,
                      sSector0.triangle[i].alpha);

   //
	for(i=lListPos; i<=sSector0.lnumObjects; i++)
	{
		glCallList(i);
	}

}

sonst wird nirgend darauf zugegriffen, wenn die variablen statisch deklariert sind, läufts auch perfekt...

danke,mfg

PS: globale Variablen sind Böse

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{

	MSG		msg;

	if (!GL_CreateWindow("OpenGLWindow",false,640,480,16,0,30,0))
		return 0;

	CreateThread(NULL, 0, Action_Thread, NULL, 0, NULL);

	while(true) 
	{
		if(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) 
		{
			if(msg.message==WM_QUIT||msg.message==WM_CLOSE||msg.message==WM_DESTROY)
				break;
			else
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg); 
			}
		}
		else 
		{
			if(GetForegroundWindow()==hWnd) 
			{
				if (bkeys[VK_ESCAPE]) 
					break;
				else if(bkeys[VK_F5])
				{
					GL_Load_Objects();
					GL_Load_Lists();
					bkeys[VK_F5]=false;
				}
				else
				{
					GL_Render_Scene();
					GL_SwapBuffers(); 
					Sleep(iDelay);
				}

			}

			if(bkeys[VK_F1]) 
			{
				bkeys[VK_F1]=FALSE; 
    			GL_DestroyWindow(szAppName); 
				bFullScr=!bFullScr; 

				if (!GL_CreateWindow(szAppName,bFullScr,640,480,16,0,40,0))    
					return 0; 

			}

		}
	}

	GL_DestroyWindow(szAppName);
	return (msg.wParam);
}

Unter GL_CreateWindow wird die initglfunktion aufgerufen hier im detail:

int GL_InitGraphics(GLvoid)
{ 

	GL_Load_Objects();
	GL_Load_Textures();
	GL_Load_Lists();

	return TRUE;
}

mfg