UpdateNormals: unerwartetes Ergebnis

Übersicht BlitzBasic Blitz3D

Neue Antwort erstellen

 

Kruemelator

Betreff: UpdateNormals: unerwartetes Ergebnis

 BeitragMo, Jan 18, 2010 23:25
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich habe bei einem Mesh die Vertex selbst gesetzt und Triangles erstellt. Dann natürlich Updatenormals benutzt, aber das scheint irgendwie zu spinnen. Und ich habe noch nicht mal annähernd eine Idee warum.
Mehrere Triangles benutzen den selben Vertex, aber dass dürfte dann doch nicht so extrem ausfallen oder irre ich mich da?
Hier noch ein Bild was es gut verdeutlicht.
user posted image

hectic

Sieger des IS Talentwettbewerb 2006

BeitragMo, Jan 18, 2010 23:50
Antworten mit Zitat
Benutzer-Profile anzeigen
UpdateNormals richtet die Normalen aus, nicht jedoch die Zeichenrichtung der Triangles. Wenn du nun willkürlich deine Triangles gezeichnet hast, dann kann UpdateNormals nicht bestimmen, wie die Normalen zu deiner Zufriedenheit ausgerichtet werden sollen.

Ich hab aber eine ganz dunkle Ahnung im Hinterkopf, dass es im Codearchiv eine Funktion geben könnte, die genau das macht. Nämlich alle Triangles eines Meshes so ausrichtet, wie man es als Benutzer zu erwarten hätte. Ob meine Ahnung nur ein Traum von mir war, oder es tatsächlich gibt, kann ich nicht sagen. Auch nicht, wonach man suchen sollte.

Alternativ bleibt dir natürlich das Mesh entsprechend nachzubearbeiten, oder dir eine Funktion zu schreiben, die das selbst überprüft und ggf. ändert. Wichtig ist also die Drehrichtung (im Uhrzeigersinn / gegen den Uhrzeigersinn) wie ein Triangle gezeichnet wurde. Denn diese entscheidet nicht nur das Backface-Culling, sondern liefert eben die ''Nahrung'' für UpdateNormals aus einem Geflecht die Normalen auszurichten.
Download der Draw3D2 V.1.1 für schnelle Echtzeiteffekte über Blitz3D
 

Kruemelator

 BeitragDi, Jan 19, 2010 0:06
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich bin mir nicht sicher ob ich dich verstanden habe, aber die Triangles sind alle "richtig herum gedreht". Ich nutze kein EntityFx 16. Die Dunklen Stellen bleiben auch immer so dunkel, egal wie das Entity gedreht ist, die hellen passen sich jedoch entsprechen an. Und wenn ich die Vertexe nur leicht verschiebe im Mesh dann entstehen komplett neue "Muster".
Wenn ich für jedes Triangle eigene Vertexe nutze, würde es dann einen großen Leistungsunterschied geben? Vor allem bei mehreren Objekten?

hectic

Sieger des IS Talentwettbewerb 2006

BeitragDi, Jan 19, 2010 0:19
Antworten mit Zitat
Benutzer-Profile anzeigen
Hmmm, nee, sorry, dann fällt mir auch erstmal nichts weiteres dazu ein. Ich hätte ja noch gesagt, dass ein möglicher Grund noch sein könnte, das nicht jede Bindestelle durch nur einen Vertice besteht. Aber dann müsste man harte Kanten erkennen, die die einzelne Triangles abbilden. Das ist aber nicht der Fall. Lediglich etwas schleierhaft finde ich die Stelle unten/links. Da sieht es so aus, als ob ein zusätzliches Quad über den Mesh gezeichnet wurde. Also doppelt gemoppelt.

Was sagt den der:
- Polygon-Count
- Vertices-Count
?
Download der Draw3D2 V.1.1 für schnelle Echtzeiteffekte über Blitz3D

Noobody

 BeitragDi, Jan 19, 2010 1:28
Antworten mit Zitat
Benutzer-Profile anzeigen
Hm, das ist sehr eigenartig.

Kann es sein, dass die Vertices/Dreiecke nicht alle auf einer Surface liegen? Ansonsten poste mal deinen Code, nur so fällt mir grade auch nichts mehr ein.
Man is the best computer we can put aboard a spacecraft ... and the only one that can be mass produced with unskilled labor. -- Wernher von Braun

Silver_Knee

 BeitragDi, Jan 19, 2010 11:19
Antworten mit Zitat
Benutzer-Profile anzeigen
hast du evtl vertexfarben verwendet bzw nicht und texturkoordinaten nicht richtig gesetzt?

NightPhoenix

 BeitragDi, Jan 19, 2010 12:36
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich hab mal bisschen rumgekramt und den Code gefunden Smile ich wusste dass dieser irgendwo rumschwirrt.

Er ist von sswift.
Zitat:
This function calculates both the face and vertex normals for a mesh using a method which does NOT smooth across vertcies that sit at the same location in space. If two faces do not share a vertex, no smoothing will take place. This allows you to more easily build levels which have sharp corners. For exmaple, if you make a cube which has six seperate sides, with no vertcies shared between sides, this function will smooth it properly, whereas the built in function will not.


BlitzBasic: [AUSKLAPPEN] 
Dim Face_NX#(32768)
Dim Face_NY#(32768)
Dim Face_NZ#(32768)
		
Dim Vertex_ConnectedTris(32768)
Dim Vertex_TriList(32768, 32)


; -------------------------------------------------------------------------------------------------------------------
; This function calculates and sets the normals for a mesh.
;
; Should probably update this so that it can recursively loop through all of an entities children as well.
; -------------------------------------------------------------------------------------------------------------------
Function Calculate_Normals(ThisMesh)
	
	; Loop through all surfaces of the mesh.
	Surfaces = CountSurfaces(ThisMesh)
	For LOOP_Surface = 1 To Surfaces

		Surface_Handle = GetSurface(ThisMesh, LOOP_Surface)

		; Reset the number of connected polygons for each vertex.
		For LoopV = 0 To 32767	
			Vertex_ConnectedTris(LoopV) = 0
		Next	
	
		; Loop through all triangles in this surface of the mesh.
		Tris = CountTriangles(Surface_Handle)
		For LOOP_Tris = 0 To Tris-1

			; Get the vertices that make up this triangle.
				Vertex_0 = TriangleVertex(Surface_Handle, LOOP_Tris, 0)
				Vertex_1 = TriangleVertex(Surface_Handle, LOOP_Tris, 1)
				Vertex_2 = TriangleVertex(Surface_Handle, LOOP_Tris, 2)
	
			; Adjust the number of triangles each vertex is connected to and
			; store this triangle in each vertex's list of triangles it is connected to.
				ConnectedTris = Vertex_ConnectedTris(Vertex_0)
				Vertex_TriList(Vertex_0, ConnectedTris) = LOOP_Tris
				Vertex_ConnectedTris(Vertex_0) = ConnectedTris + 1

				ConnectedTris = Vertex_ConnectedTris(Vertex_1)
				Vertex_TriList(Vertex_1, ConnectedTris) = LOOP_Tris
				Vertex_ConnectedTris(Vertex_1) = ConnectedTris + 1

				ConnectedTris = Vertex_ConnectedTris(Vertex_2)
				Vertex_TriList(Vertex_2, ConnectedTris) = LOOP_Tris
				Vertex_ConnectedTris(Vertex_2) = ConnectedTris + 1

			; Calculate the normal for this face.

				; Get the corners of this face:
				Ax# = VertexX#(Surface_Handle, Vertex_0)
				Ay# = VertexY#(Surface_Handle, Vertex_0)
				Az# = VertexZ#(Surface_Handle, Vertex_0)

				Bx# = VertexX#(Surface_Handle, Vertex_1)
				By# = VertexY#(Surface_Handle, Vertex_1)
				Bz# = VertexZ#(Surface_Handle, Vertex_1)

				Cx# = VertexX#(Surface_Handle, Vertex_2)
				Cy# = VertexY#(Surface_Handle, Vertex_2)
				Cz# = VertexZ#(Surface_Handle, Vertex_2)

				; Triangle 1
				; Get the vectors for two edges of the triangle.
				Px# = Ax#-Bx#
				Py# = Ay#-By#
				Pz# = Az#-Bz#

				Qx# = Bx#-Cx#
				Qy# = By#-Cy#
				Qz# = Bz#-Cz#

				; Compute their cross product.
				Nx# = Py#*Qz# - Pz#*Qy#
				Ny# = Pz#*Qx# - Px#*Qz#
				Nz# = Px#*Qy# - Py#*Qx#

				; Store the face normal.
				Face_NX#(LOOP_Tris) = Nx#
				Face_NY#(LOOP_Tris) = Ny#
				Face_NZ#(LOOP_Tris) = Nz#

		Next

		; Now that all the face normals for this surface have been calculated, calculate the vertex normals.
		Vertices = CountVertices(Surface_Handle)
		For LOOP_Vertices = 0 To Vertices-1

			; Reset this normal.
			Nx# = 0
			Ny# = 0
			Nz# = 0

			; Add the normals of all polygons which are connected to this vertex.
			Polys = Vertex_ConnectedTris(LOOP_Vertices)
				
			For LOOP_Polys = 0 To Polys-1

				ThisPoly = Vertex_TriList(LOOP_Vertices, LOOP_Polys)

				Nx# = Nx# + Face_NX#(ThisPoly)
				Ny# = Ny# + Face_NY#(ThisPoly)
				Nz# = Nz# + Face_NZ#(ThisPoly)			
				
			Next	
				
			; Normalize the new vertex normal.
			; (Normalizing is scaling the vertex normal down so that it's length = 1)

				Nl# = Sqr(Nx#^2 + Ny#^2 + Nz#^2)

				; Avoid a divide by zero error if by some freak accident, the vectors add up to 0.
				; If Nl# = 0 Then Nl# = 0.1

				Nx# = Nx# / Nl#
				Ny# = Ny# / Nl#
				Nz# = Nz# / Nl#

			; Set the vertex normal.
			
				VertexNormal Surface_Handle, LOOP_Vertices, Nx#, Ny#, Nz#
				;VertexColor Surface_Handle, LOOP_Vertices, polys*127, polys*127, polys*127
		
		Next

	Next

End Function


Ist das Ergebnis in Ordnung?
 

Kruemelator

 BeitragDi, Jan 19, 2010 17:00
Antworten mit Zitat
Benutzer-Profile anzeigen
@hectic:
Triangle: 3072
Vertexe: 1266
Surface: 1
@Noobody:
Die Vertexe und Triangles sind alle in einem Surface.
@Silver_Knee:
EntityColor ist das einzige mit dem ich das Entity einfärbe. Weder Texture noch Vertexfarben.
@NightPhoenix:
Mit der Funktion wird alles korrekt dargestellt.

Worin unterscheidet sich diese dann von UpdateNormals? Ich dachte immer das ist genau das was UpdateNormals macht.

NightPhoenix

 BeitragDi, Jan 19, 2010 18:02
Antworten mit Zitat
Benutzer-Profile anzeigen
Die Funktion setzt für alle Vertex die Normalen einzeln neu. Sie setzt sie dabei senkrecht zur Ausrichtung jedes Vertex, so kommt auch die richtige Beleuchtung zustande. Die Funktion baut auf Vektoren auf.

Mr.Keks

 BeitragDi, Jan 19, 2010 18:14
Antworten mit Zitat
Benutzer-Profile anzeigen
Nein. Ein Vertex hat per se keine "Richtung". Die Funktion von sswift berechnet die Vertexnormale einfach aus den Normalen (also "Richtungen") der Dreiecke, zu denen ein Vertex gehört. Das UpdateNormals von B3d macht dasselbe; als zusätzliches Feature smootht es die Normalen dabei jedoch. Das bedeutet, dass Vertices, die an derselben Stelle im Raum sind, behandelt werden, als wären sie einer. Also die Normale nicht mehr auf dem Dreieck, sondern auf den Ecken/Kanten steht, die zwischen den Dreiecken verlaufen. Meistens ist das cool, manchmal - wie in diesem Fall hier - ungewollt.
MrKeks.net
 

Kruemelator

 BeitragDi, Jan 19, 2010 19:15
Antworten mit Zitat
Benutzer-Profile anzeigen
@Mr.Keks:
Das würde voraussetzen dass mehrere Vertexe auf der selben Position sind, dies ist aber bei dem Mesh nie der Fall. Und es erklärt leider auch nicth weshalb bei einer minimalen Verschiebung der Vertexe ein komplett neues "Muster" entsteht oder auch alles wieder richtig dargestellt wird. Es dürfte dann doch nur eine minimale Abweichung entstehen.
Außerdem ist der Vertex immer so dunkel egal wie das Entity gedreht wird. So als hätte der Vertex keine Normale.

Mr.Keks

 BeitragDi, Jan 19, 2010 23:41
Antworten mit Zitat
Benutzer-Profile anzeigen
naja, es sei denn, du hast, wie hier schon mehrfach vermutet, irgendwo verkehrt gedrehte oder unendlich schmale tris drin, die du eben nicht wahrnimmst und die dafür sorgen, dass da 0-vektoren als normalen entstehen (was eigentlich von blitz abgefangen werden sollte...) mit denen funktioniert beleuchtung naheliegenderweise auch nicht ordentlich.

aber wir haben halt etwas wenig infos darüber, was du da wirklich machst.
MrKeks.net
 

BIG BUG

 BeitragDi, Jan 19, 2010 23:43
Antworten mit Zitat
Benutzer-Profile anzeigen
Benutzt Du EntityFx 16 oder doppelseitige Polygone? Klingt als wäre die Struktur Deines Meshs nicht ganz sauber.
Jedes Vertex müsste nach UpdateNormals eine Normale besitzen - die Frage ist nur in welche Richtung diese ausgerichtet ist. So würde z.B. bei einer entgegengesetzten Normalen die vom Licht abgewandte Seite beleuchtet.

Wobei, vielleicht könnte sich die Berechnung gegenseitig aufheben so dass 0 als Normale rauskommt? Wie auch immer - wenn Du meine Eingangsfrage mit Ja beantwortest könnte das solche Auswirkungen haben.
B3D-Exporter für Cinema4D!(V1.4)
MD2-Exporter für Cinema4D!(final)
 

Kruemelator

 BeitragMi, Jan 20, 2010 20:13
Antworten mit Zitat
Benutzer-Profile anzeigen
Hier mal der Code, vielleicht findet ihr ja den Grund, aufjedenfall setze ich jetzt die Vertexnormals selber, so dass es funktioniert. Trotzdem danke für die Hilfe. Smile
Code: [AUSKLAPPEN]
;Variablen--------------------------------
Global xfenster = 800
Global yfenster = 600
Global farbtiefe = 16
Global windowmod = 2

;Globale----------------------------------
Global mxs#
Global mys#
Global mzs#
Global mht1
Global mht2

;3D Welt----------------------------------
Graphics3D xfenster,yfenster,farbtiefe,windowmod
SetBuffer BackBuffer()
WireFrame 0
ClsColor 255,255,255
Color 0,0,0
SeedRnd MilliSecs()

Global camera = CreateCamera()
CameraRange camera,0.001,100
CameraClsColor camera,255,255,255
PositionEntity camera,0,1,-3

Local light = CreateLight()

;Welt-------------------------------------
Global monster = CreateCube()
For a=0 To -1
   mesh2 = CreateCube()
   PositionMesh mesh2,Rand(-1,1)*2,Rand(-1,1)*2,Rand(-1,1)*2
   AddMesh mesh2,monster
   FreeEntity mesh2
Next
ScaleMesh monster,0.5,0.5,0.5
ScaleEntity monster,1,1,1
PositionEntity monster,0,1,0
EntityColor monster,150,150,150

;Start------------------------------------
einflaechenmesh(monster)
For a=0 To 200
   teilen(monster,0.3)
Next
glaetten(monster,0.2)

;Ende-------------------------------------

fpsrate = CreateTimer(60)
While Not KeyHit(1)
   WaitTimer(fpsrate)
   Cls
   mxs# = MouseXSpeed()
   mys# = MouseYSpeed()
   mzs# = MouseZSpeed()
   mht1 = MouseHit(1)
   mht2 = MouseHit(2)
   
   cammove()
   aendern()
   TurnEntity monster,0,04,0
   
   UpdateWorld
   RenderWorld
   
   Flip 0
Wend
End

;Funktionen-------------------------------
Function aendern()
   WireFrame MouseDown(1)
   If KeyDown(57) Then teilen(monster,0.2)
   If KeyHit(28) Then
      glaetten(monster,0.2)
   EndIf
End Function

Function einflaechenmesh(mesh)
   Local surface
   Local a,b,c,on,wert,anzahl
   Local v1,v2,v3,va,vb
   Local xwert#,ywert#,zwert#
   Local xwert2#,ywert2#,zwert2#
   Local bank
   Local tribank
   bank = CreateBank(0)
   tribank = CreateBank(0)
   For a=1 To CountSurfaces(mesh)
      surface = GetSurface(mesh,a)
      anzahl = 0
      ;bank = CreateBank(0)
      For b=0 To CountVertices(surface)-1
         xwert# = VertexX(surface,b)
         ywert# = VertexY(surface,b)
         zwert# = VertexZ(surface,b)
         xwert2# = xwert#+1
         ywert2# = ywert#
         zwert2# = zwert#
         on = 0
         For c=0 To anzahl
            If anzahl <> 0 Then
               xwert2# = PeekFloat(bank,c*12+0)
               ywert2# = PeekFloat(bank,c*12+4)
               zwert2# = PeekFloat(bank,c*12+8)
            EndIf
            If (xwert=xwert2) + (ywert=ywert2) + (zwert=zwert2) <> 3 Then
               on = 1
               Exit
            EndIf
         Next
         If on = 1 Then
            wert = BankSize(bank)
            ResizeBank bank,wert+12
            PokeFloat bank,wert+0,xwert#
            PokeFloat bank,wert+4,ywert#
            PokeFloat bank,wert+8,zwert#
            anzahl = anzahl + 1
         EndIf
      Next
      ;tribank = CreateBank(banksize(tribank)+CountTriangles(surface)*12)
      wert = BankSize(tribank)
      ResizeBank tribank,wert+CountTriangles(surface)*12
      For b=0 To CountTriangles(surface)-1
         v1 = TriangleVertex(surface,b,0)
         v2 = TriangleVertex(surface,b,1)
         v3 = TriangleVertex(surface,b,2)
         v1 = neuvertexindex(surface,bank,v1)
         v2 = neuvertexindex(surface,bank,v2)
         v3 = neuvertexindex(surface,bank,v3)
         PokeInt tribank,wert+b*12+0,v1
         PokeInt tribank,wert+b*12+4,v2
         PokeInt tribank,wert+b*12+8,v3
      Next
      ClearSurface surface
      ;For b=0 To BankSize(bank)/12-1
      ;   AddVertex(surface,PeekFloat(bank,b*12+0),PeekFloat(bank,b*12+4),PeekFloat(bank,b*12+8))
      ;Next
      ;For b=0 To BankSize(tribank)/12-1
      ;   AddTriangle(surface,PeekInt(tribank,b*12+0),PeekInt(tribank,b*12+4),PeekInt(tribank,b*12+8))
      ;Next
      ;FreeBank bank
      ;FreeBank tribank
   Next
   For b=0 To BankSize(bank)/12-1
      AddVertex(surface,PeekFloat(bank,b*12+0),PeekFloat(bank,b*12+4),PeekFloat(bank,b*12+8))
   Next
   For b=0 To BankSize(tribank)/12-1
      AddTriangle(surface,PeekInt(tribank,b*12+0),PeekInt(tribank,b*12+4),PeekInt(tribank,b*12+8))
   Next
   FreeBank bank
   FreeBank tribank
   UpdateNormals mesh
End Function

Function neuvertexindex(surface,bank,v)
   Local xwert#,ywert#,zwert#
   Local xwert2#,ywert2#,zwert2#
   Local a
   xwert# = VertexX(surface,v)
   ywert# = VertexY(surface,v)
   zwert# = VertexZ(surface,v)
   For a=0 To BankSize(bank)/12-1
      xwert2# = PeekFloat(bank,a*12+0)
      ywert2# = PeekFloat(bank,a*12+4)
      zwert2# = PeekFloat(bank,a*12+8)
      If (xwert=xwert2) + (ywert=ywert2) + (zwert=zwert2) = 3 Then
         Return a
      EndIf
   Next
   RuntimeError "Vertex ist bei der Suche nciht gefunden worden.!"
End Function

Function glaetten(mesh,staerke#=0.2)
   Local surface
   Local a,b,c,on
   Local v1,v2,v3,va,vb
   Local xwert#,ywert#,zwert#,anzahl
   Local bank
   For a=1 To CountSurfaces(mesh)
      surface = GetSurface(mesh,a)
      bank = CreateBank(CountVertices(surface)*16)
      ;0 x
      ;4 y
      ;8 z
      ;anzahl
      For b=0 To CountVertices(surface)-1
         PokeFloat bank,b*16+0,0.0
         PokeFloat bank,b*16+4,0.0
         PokeFloat bank,b*16+8,0.0
         PokeInt  bank,b*16+12,0
         For c=0 To CountTriangles(surface)-1
            v1 = TriangleVertex(surface,c,0)
            v2 = TriangleVertex(surface,c,1)
            v3 = TriangleVertex(surface,c,2)
            on = 1
            Select b
               Case v1
                  va = v2
                  vb = v3
               Case v2
                  va = v1
                  vb = v3
               Case v3
                  va = v1
                  vb = v2
               Default
                  on = 0
            End Select
            If on Then
               xwert# = PeekFloat(bank,b*16+0) + VertexX(surface,va)-VertexX(surface,b)
               ywert# = PeekFloat(bank,b*16+4) + VertexY(surface,va)-VertexY(surface,b)
               zwert# = PeekFloat(bank,b*16+8) + VertexZ(surface,va)-VertexZ(surface,b)
               anzahl = PeekInt(bank,b*16+12)
               PokeFloat bank,b*16+0,xwert#
               PokeFloat bank,b*16+4,ywert#
               PokeFloat bank,b*16+8,zwert#
               PokeInt  bank,b*16+12,anzahl+1
               xwert# = PeekFloat(bank,b*16+0) + VertexX(surface,vb)-VertexX(surface,b)
               ywert# = PeekFloat(bank,b*16+4) + VertexY(surface,vb)-VertexY(surface,b)
               zwert# = PeekFloat(bank,b*16+8) + VertexZ(surface,vb)-VertexZ(surface,b)
               anzahl = PeekInt(bank,b*16+12)
               PokeFloat bank,b*16+0,xwert#
               PokeFloat bank,b*16+4,ywert#
               PokeFloat bank,b*16+8,zwert#
               PokeInt  bank,b*16+12,anzahl+1
            EndIf
         Next
      Next
      For b=0 To CountVertices(surface)-1
         anzahl = PeekInt(bank,b*16+12)
         xwert# = PeekFloat(bank,b*16+0)/Float(anzahl)*staerke# + VertexX(surface,b)
         ywert# = PeekFloat(bank,b*16+4)/Float(anzahl)*staerke# + VertexY(surface,b)
         zwert# = PeekFloat(bank,b*16+8)/Float(anzahl)*staerke# + VertexZ(surface,b)
         VertexCoords surface,b,xwert#,ywert#,zwert#
      Next
      FreeBank bank
   Next
   UpdateNormals mesh
End Function

Function teilen(mesh,minlaenge# = 0.00)
   Local surzahl
   Local surface
   Local trizahl
   Local a
   Local b
   Local v1,v2,v3
   Local mv1,mv2,mlaenge#,msurface
   Local nv
   Local wert#
   surzahl = CountSurfaces(mesh)
   For a=1 To surzahl
      surface = GetSurface(mesh,a)
      trizahl = CountTriangles(surface)
      For b=0 To trizahl-1
         v1 = TriangleVertex(surface,b,0)
         v2 = TriangleVertex(surface,b,1)
         v3 = TriangleVertex(surface,b,2)
         wert# = vertexentf#(surface,v1,v2)
         If wert# > mlaenge# Then
            mlaenge# = wert#
            msurface = surface
            mv1 = v1
            mv2 = v2
         EndIf
         wert# = vertexentf#(surface,v2,v3)
         If wert# > mlaenge# Then
            mlaenge# = wert#
            msurface = surface
            mv1 = v2
            mv2 = v3
         EndIf
         wert# = vertexentf#(surface,v3,v1)
         If wert# > mlaenge# Then
            mlaenge# = wert#
            msurface = surface
            mv1 = v3
            mv2 = v1
         EndIf
      Next
   Next
   If minlaenge# >= mlaenge# Then Return
   ;Liste der Triangle mit beiden Punkte
   Local deltribank = CreateBank(0)
   surzahl = CountSurfaces(mesh)
   surface = msurface
   trizahl = CountTriangles(surface)
   For b=0 To trizahl-1
      v1 = TriangleVertex(surface,b,0)
      v2 = TriangleVertex(surface,b,1)
      v3 = TriangleVertex(surface,b,2)
      If (v1 = mv1)+(v2 = mv1)+(v3 = mv1)+(v1 = mv2)+(v2 = mv2)+(v3 = mv2) = 2 Then
         wert = BankSize(deltribank)
         ResizeBank deltribank,wert+4
         PokeInt deltribank,wert,b
      EndIf
   Next
   ;liste mit triangles erstellen
   Local tribank = CreateBank(0)
   Local on
   Local x#,y#,z#
   Local art,v
   surzahl = CountSurfaces(mesh)
   surface = msurface
   trizahl = CountTriangles(surface)
   x# = (VertexX(surface,mv1)+VertexX(surface,mv2))/2.0
   y# = (VertexY(surface,mv1)+VertexY(surface,mv2))/2.0
   z# = (VertexZ(surface,mv1)+VertexZ(surface,mv2))/2.0
   nv = AddVertex(surface,x#,y#,z#)
   For b=0 To trizahl-1
      v1 = TriangleVertex(surface,b,0)
      v2 = TriangleVertex(surface,b,1)
      v3 = TriangleVertex(surface,b,2)
      on = 0
      For a=0 To BankSize(deltribank)/4-1
         If PeekInt(deltribank,a*4) = b Then
            on = 1
            Exit
         EndIf
      Next
      If on = 0 Then
         wert = BankSize(tribank)
         ResizeBank tribank,wert+12
         PokeInt tribank,wert+ 0,v1
         PokeInt tribank,wert+ 4,v2
         PokeInt tribank,wert+ 8,v3
      Else
         If v1 <> mv1 And v1 <> mv2 Then
            art = 1
         EndIf
         If v2 <> mv1 And v2 <> mv2 Then
            art = 2
         EndIf
         If v3 <> mv1 And v3 <> mv2 Then
            art = 3
         EndIf
         If art = 1 Then
            wert = BankSize(tribank)
            ResizeBank tribank,wert+12
            PokeInt tribank,wert+ 0,v1
            PokeInt tribank,wert+ 4,v2
            PokeInt tribank,wert+ 8,nv
            wert = BankSize(tribank)
            ResizeBank tribank,wert+12
            PokeInt tribank,wert+ 0,v1
            PokeInt tribank,wert+ 4,nv
            PokeInt tribank,wert+ 8,v3
         EndIf
         If art = 2 Then
            wert = BankSize(tribank)
            ResizeBank tribank,wert+12
            PokeInt tribank,wert+ 0,nv
            PokeInt tribank,wert+ 4,v2
            PokeInt tribank,wert+ 8,v3
            wert = BankSize(tribank)
            ResizeBank tribank,wert+12
            PokeInt tribank,wert+ 0,v1
            PokeInt tribank,wert+ 4,v2
            PokeInt tribank,wert+ 8,nv
         EndIf
         If art = 3 Then
            wert = BankSize(tribank)
            ResizeBank tribank,wert+12
            PokeInt tribank,wert+ 0,nv
            PokeInt tribank,wert+ 4,v2
            PokeInt tribank,wert+ 8,v3
            wert = BankSize(tribank)
            ResizeBank tribank,wert+12
            PokeInt tribank,wert+ 0,v1
            PokeInt tribank,wert+ 4,nv
            PokeInt tribank,wert+ 8,v3
         EndIf
      EndIf
   Next
   ;surface loeschen
   ClearSurface surface,0,1
   ;neue triangle erstellen
   For a=0 To BankSize(tribank)/12-1
      AddTriangle(surface,PeekInt(tribank,a*12),PeekInt(tribank,a*12+4),PeekInt(tribank,a*12+8))
   Next
   UpdateNormals mesh
   FreeBank tribank
   FreeBank deltribank
End Function

Function vertexentf#(surface,v1,v2)
   Local xwert# = VertexX(surface,v1)-VertexX(surface,v2)
   Local ywert# = VertexY(surface,v1)-VertexY(surface,v2)
   Local zwert# = VertexZ(surface,v1)-VertexZ(surface,v2)
   Return (xwert*xwert+ywert*ywert+zwert*zwert)^0.5
End Function

Function cammove()
   TurnEntity camera,mys#/20,mxs#/-20,0
   RotateEntity camera,EntityPitch(camera),EntityYaw(camera),0
   MoveMouse 400,300
   If KeyDown(17) Then MoveEntity camera,0,0,0.1
   If KeyDown(31) Then MoveEntity camera,0,0,-0.1
   If KeyDown(30) Then MoveEntity camera,-0.1,0,0
   If KeyDown(32) Then MoveEntity camera,0.1,0,0
   TranslateEntity camera,0,mzs#/2,0
End Function

Neue Antwort erstellen


Übersicht BlitzBasic Blitz3D

Nach Oben

Gehe zu:

Powered by phpBB © 2001 - 2006, phpBB Group