openGL::Normals

[x2nop]

was bisher geschah: aufgrund eines sehr schicken tutorials (das sei hier gleich ma erwähnt: http://www.lighthouse3d.com/opengl/glsl/) hab ich mal ein wenig mit den shadern rumgespielt. was auch hübsche ergebnisse brachte, solange ich die gl.glutSolid*s verwende. nun wollte ich meine eignen modelle (ganz simple geometrien, wie kegel und kugeln) verwenden und siehe da: jede beleuchtung war futsch.
was ich sicher weiß, ist, daß ich die normals irgendwie definieren muß. nur wie? nachdem ich diese zeile:

Code: Alles auswählen

  gl_Normal = normalize(gl_Vertex);

in den vertexshader eingefügt hab, sahs wieder aus wie vorher. soweit ich das verstehe, würden diese ja aber für jeden vertex zu jedem frame neu berechnet. das muß ja nun aber, solange die modelle unveränderlich sind, wirklich nicht sein!?!
also kurz gefragt: wie berechne ich die normals via opengl? oder komme ich da irgendwie drum herum?
das näxte wäre:
das ergebnis sieht eigentl auch nur gut aus, solange ich runde formen darstellen möchte. will ich eine fläche darstelln, werden die normals ja auch interpoliert, was dann beispielsweise einen würfel zu ner art eckiger kugel macht.
hmm.. also, ich glaube, das sind eher theoretische fragen, dh hab ich hier mal keinen code eingefügt. aber bei bedarf..

so long ~$10

[veers]

Ich glaube du verwechselst da das normalisieren eines Vektors mit den Normals einer Oberfläche. Das Normalisieren eines Vektors geht sehr schnell vermutlich sogar schneller als das Laden eines Wertes aus dem RAM . Die Normals einer Oberfläche hingegen (also die Ausrichtung) gibst du beim erstellen an:
glNormal3f(0.0, 1.0, 0.0) bedeutet dann zum Beispiel das die Oberfläche nach oben zeigt

[x2nop]

nünja.. das is schon wahr. ganz so sicher bin ich mir noch nicht, was ich da eigentl. mache. . .. drum hier mal das konkrete beispiel:

Code: Alles auswählen

def assemblyCone(detail=0, radius=1.0, height=1.0):
	vertices = [[0.0, height, 0.0]]	# startpunkt (mittelpunkt für TriAngleFan)
	corners = (detail+1) * 3
	angle = 360.0 / corners
	for c in range(corners):
		alpha = m.radians(angle * c)
		vertices.append([m.sin(alpha)*radius, 0.0, m.cos(alpha)*radius])
	return vertices

def renderCone(pointList):
	# primo: 'n kegel
	glBegin(GL_TRIANGLE_FAN)
	for p in pointList:
		glVertex3f(p[0], p[1], p[2])
	# um den kegel zu schließen, den ersten kreispunkt nochmal
	p = pointList[1]
	glVertex3f(p[0], p[1], p[2])
	glEnd()

das sind noch sehr rudimentere funktionen, nur mal so zum frickeln..
der shader sieht so aus:

Code: Alles auswählen

// Vertex program
// directLight
varying vec4 ambient, diffuse;
varying vec3 normal, lightDir, halfVector;
void main()	{
	// ganz furchbar..: besagte verlegenheitslösung. gehört garnicht hier her!
	gl_Normal = normalize(gl_Vertex);
	// first transform the normal into eye space and normalize the result
	normal = normalize(gl_NormalMatrix * gl_Normal);
	
	// now normalize the light's direction
	lightDir = normalize(vec3(gl_LightSource[0].position));
	
	// Normalize the halfVector to pass it to the fragment shader
	halfVector = normalize(gl_LightSource[0].halfVector.xyz);
	
	/* Compute the diffuse, ambient and globalAmbient terms */
	diffuse = gl_FrontMaterial.diffuse * gl_LightSource[0].diffuse;
	ambient = gl_FrontMaterial.ambient * gl_LightSource[0].ambient;
	ambient += gl_LightModel.ambient * gl_FrontMaterial.ambient;
	
	gl_Position = ftransform();
}

also eigentl. will ich ja gar keine vektoren normalisieren. nur ohne diese gruslige zeile is das ding einfach nur flach. ohne licht und schatten. das mag vleicht nen zen-buddhisten erfreuen, ich aber will den dualismus !!!
wie könnte ich nun rauskriegen, wo die fläche denn so hinzeigt? ich kann mir ja schon vorstellen, wozu das gut ist, nur hängts bei mir irgendwie, wie ichs konktret bewerkstelligen soll..

(worauf hab ich mich da nur eingelassen..?!)

**..aufmerksam aber ohne verständnis folgte er dem unterricht..**