October 19, 2021, 09:44:12

Author Topic: [bb] Silo3D .obj import for B3D by Vorderman [ 1+ years ago ]  (Read 928 times)

Offline BlitzBot

  • Jr. Member
  • **
  • Posts: 1
Title : Silo3D .obj import for B3D
Author : Vorderman
Posted : 1+ years ago

Description : This import routine imports .obj files exported from Silo3D.
You must follow some naming conventions within Silo to allow textures to be auto-loaded and materials to be automatically setup:
SILO MATERIAL SETUP:

- MATERIAL NAME: <texture filename.png> number1 number2 number3 number4
----For example : to load a texture into B3D using default blend and texture flags name the material "<mytexture.png> 1 0 2 9"
----This is the material setup - <texture name.png> must be the filename + extension only, no path, no _s, no spaces. Supports .png, .tga, .dds, .bmp

----First number - Blitz3D BRUSH BLEND mode - refer to your B3D Docs (numbers valid = 1,2 or 3)
----Second number - Blitz3D BRUSH FX FLAGS - add the flags together to get this single number, refer to B3D docs.
----Third number - Blitz3D TEXTURE BLEND mode - refer to B3D docs.
----Fourth number - Blitz3D TEXTURE FLAGS - add them together, default is (1+8 = 9), refer to B3D docs for full list of flags.

- DIFFUSE = BRUSH COLOUR RGB
- AMBIENT = BRUSH ALPHA - use greyscale colour to define value (black = 0, white = 1)
- SPECULAR = unused
- EMISSIVE = unused
- SHININESS = BRUSH SHININESS (Silo value 0 to 127 = Blitz shininess 0 to 1)
- TEXTURE = texture filename

To Load a mesh in Blitz3D:

Include it with your program - best way is to save the routine to a seperate file and INCLUDE it at the start of your main program.

Instead of LoadMesH(), use the command FUNC_Import_Silo_OBJ( filename$ )


Code :
Code: BlitzBasic
  1. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  2. ;
  3. ; SILO .obj MESH IMPORTER
  4. ;
  5. ; Current state:
  6. ;       Import mesh : working as expected, Blitz and Silo's -X and X coords are reversed, but the import matches the visual in Silo.
  7. ;       Texture coords : working as expected, including proper UV splitting along texture mapping seams
  8. ;       Normals : working as expected
  9. ;       Smoothing groups : working if the object is split into multiple parts in Silo
  10. ;       Brush setup : working as expected
  11. ;       Loading textures : working as expected
  12. ;       Dummy child object : working as expected - use a 4-tri single quad object with the name "DUMMY name", positioned at average of the 4 vertices
  13. ;
  14. ;       Vertex colours : not yet implemented
  15. ;
  16. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  17.  
  18.  
  19.  
  20.  
  21.  
  22.  
  23. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  24. ;MATERIAL NAME = texture filename.ext  followed by 4 numbers seperated by spaces
  25. ;       TEXTURE.PNG             BRUSH_BLEND                     BRUSH_FX                        TEXTURE_BLEND                   TEXTURE_FLAGS
  26. ;
  27. ;DIFFUSE = BRUSH COLOUR RGB
  28. ;AMBIENT = BRUSH ALPHA (0 To 1)
  29. ;SPECULAR = unused
  30. ;EMISSIVE = unused
  31. ;SHININESS = BRUSH SHININESS (0 To 127 = 0 To 1)
  32. ;TEXTURE = texture filename
  33. ;
  34. ;
  35. ;
  36. ;BRUSH_BLEND                    1 = alpha (Default)            
  37. ;                                       2 = multiply
  38. ;                                       3 = add
  39. ;
  40. ;BRUSH_FX                               0 = nothing (Default)
  41. ;                                       1 = full-bright
  42. ;                                       2 = use vertex colours instead of brush colour
  43. ;                                       4 = flatshaded
  44. ;                                       8 = disable fog
  45. ;                                       16 = disable backface culling
  46. ;
  47. ;TEXTURE_BLEND                  0 = do Not blend
  48. ;                                       1 = no blend , Or alpha when texture loaded with alpha flag (2)
  49. ;                                       2 = multiply (Default)
  50. ;                                       3 = add
  51. ;                                       4 = dot3
  52. ;                                       5 = multiply2
  53. ;
  54. ;TEXTURE_FLAGS                  1 = colour (Default)
  55. ;                                       2 = alpha
  56. ;                                       4 = masked
  57. ;                                       8 = mipmapped (Default)
  58. ;                                       16 = clamp U
  59. ;                                       32 = clamp V
  60. ;                                       64 = environment map
  61. ;                                       128 = cube map
  62. ;                                       256 = store texture in vram
  63. ;                                       512 = force high-colour texture
  64. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  65.  
  66.  
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73.  
  74. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  75. ;OBJ import arrays
  76. Type TYPE_vertex
  77.         Field ID
  78.         Field pointer
  79.         Field x# , y# , z#
  80.         Field u# , v#
  81. End Type
  82.  
  83. Type TYPE_normal
  84.         Field ID
  85.         Field nx# , ny# , nz#
  86. End Type
  87.  
  88. Type TYPE_uvw
  89.         Field ID
  90.         Field u# , v#
  91. End Type
  92.  
  93. Type TYPE_surface
  94.         Field ID
  95.         Field pointer
  96.         Field materialID$
  97. End Type
  98.  
  99. Type TYPE_face
  100.         Field ID
  101.         Field pointer
  102.         Field materialID$
  103.        
  104.         Field number_of_vertices
  105.        
  106.         Field vertexID[ MAX_VERTS_PER_FACE ]
  107.         Field normalID[ MAX_VERTS_PER_FACE ]
  108.         Field uvwID[ MAX_VERTS_PER_FACE ]
  109. End Type
  110.  
  111. Type TYPE_material
  112.         Field ID
  113.         Field all_flags$
  114.         Field alpha#
  115.         Field red , green , blue
  116.         Field shininess#
  117.         Field texture_filename$
  118.        
  119.         Field FLAG_brush_blend
  120.         Field FLAGS_brush_FX
  121.         Field FLAG_texture_blend
  122.         Field FLAGS_texture_flags
  123. End Type
  124.        
  125. Const MAX_VERTS_PER_FACE                                                                                        = 10
  126. Const MAX_VERTS_PER_MESH                                                                                        = 10000
  127. Const MAX_UVW_PER_MESH                                                                                          = 20000
  128. Const MAX_FACES_PER_MESH                                                                                        = 5000
  129. Const MAX_SURFACES_PER_MESH                                                                                     = 100
  130. Const MAX_MATERIALS_PER_MESH                                                                                    = 10
  131. Const MAX_FACES_PER_DUMMY                                                                                       = 6
  132. Const VERTEX_MERGE_TOLLERANCE#                                                                          = 0.01
  133.  
  134. Global ARRAY_line_elements$[100]
  135. Global ARRAY_vertex.TYPE_vertex[MAX_VERTS_PER_MESH]
  136. Global ARRAY_normal.TYPE_normal[MAX_VERTS_PER_MESH]
  137. Global ARRAY_uvw.TYPE_uvw[MAX_UVW_PER_MESH]
  138. Global ARRAY_face.TYPE_face[MAX_FACES_PER_MESH]
  139. Global ARRAY_surface.TYPE_surface[MAX_SURFACES_PER_MESH]
  140. Global ARRAY_material.TYPE_material[MAX_MATERIALS_PER_MESH]
  141. Global ARRAY_dummy_face.TYPE_face[MAX_FACES_PER_DUMMY]
  142. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  143.  
  144.  
  145.  
  146.  
  147.  
  148.  
  149.  
  150.  
  151. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  152. Function FUNC_Import_Silo_OBJ( filename$ )
  153.  
  154.         mesh = 0
  155.         material_library$ = ""
  156.         object_name$ = ""
  157.         last_material$ = ""
  158.        
  159.         vertex_ID = 1
  160.         normal_ID = 1
  161.         uvw_ID = 1
  162.         face_ID = 1
  163.         dummy_face_ID = 1
  164.         surface_ID = 1
  165.  
  166.         ;process the filename to obtain the directoy and mesh name     
  167.         pos = Len(filename$)
  168.         Repeat
  169.                 char$ = Mid$( filename$ , pos , 1)
  170.                 pos = pos - 1
  171.         Until pos=0 Or char$=""
  172.         If (pos>0)
  173.                 stripped_meshname$ = Right$( filename$ , Len(filename$) - pos - 1)
  174.                 directory$ = Left$( filename$ , pos+1)
  175.         Else
  176.                 stripped_meshname$ = filename$
  177.                 directory$ = ""
  178.         EndIf
  179.  
  180.         ;open the file for reading
  181.         file = OpenFile( filename$ )
  182.        
  183.         ;check open success
  184.         If file
  185.  
  186.                 DebugLog "---- OBJ LOADER - "+filename$+" ------------------------------------------------------------"
  187.                
  188.                 ;create base mesh
  189.                 mesh = CreateMesh()    
  190.                 PositionEntity mesh,0,0,0
  191.                 RotateEntity mesh,0,0,0        
  192.  
  193.                 ;reset to start of file
  194.                 SeekFile( file , 0)
  195.  
  196.                 group_ignore = False
  197.                
  198.                 ;cycle through lines and parse each one
  199.                 Repeat
  200.                         ;parse line to obtain the individual elements
  201.                         txt$ = ReadLine$( file )
  202.                         FUNC_Parse_Line( txt$ , " ")
  203.                        
  204.                         ;process the stored words and store them
  205.                         Select ARRAY_line_elements[1]
  206.                         Case ""
  207. ;                               DebugLog "EMPTY ELEMENT"
  208.  
  209.                         Case "mtllib"
  210. ;                               DebugLog "MATERIAL LIBRARY"
  211.                                 material_library$ = ARRAY_line_elements[2]
  212.                         Case "o"
  213. ;                               DebugLog "OBJECT NAME"
  214.                                 object_name$ = ARRAY_line_elements[2]
  215.  
  216.                         Case "v"
  217. ;                               DebugLog "VERTEX COORDS"
  218.                                 ARRAY_vertex[vertex_ID] = New TYPE_vertex
  219.                                 ARRAY_vertex[vertex_ID]ID = vertex_ID
  220.                                 ARRAY_vertex[vertex_ID]x# = -Float#(ARRAY_line_elements[2])
  221.                                 ARRAY_vertex[vertex_ID]y# = Float#(ARRAY_line_elements[3])
  222.                                 ARRAY_vertex[vertex_ID]z# = Float#(ARRAY_line_elements[4])
  223.                                 ARRAY_vertex[vertex_ID]pointer = -1
  224.                                 vertex_ID = vertex_ID + 1
  225.                                
  226.                         Case "vn"
  227. ;                               DebugLog "VERTEX NORMAL"
  228.                                 ARRAY_normal[normal_ID] = New TYPE_normal
  229.                                 ARRAY_normal[normal_ID]ID = normal_ID
  230.                                 ARRAY_normal[normal_ID]
  231. x# = -Float#(ARRAY_line_elements[2])
  232.                                 ARRAY_normal[normal_ID]
  233. y# = Float#(ARRAY_line_elements[3])
  234.                                 ARRAY_normal[normal_ID]
  235. z# = Float#(ARRAY_line_elements[4])
  236.  
  237.                                 normal_ID = normal_ID + 1
  238.                                
  239.                         Case "vt"
  240. ;                               DebugLog "VERTEX TEXTURE COORDS"
  241.                                 ARRAY_uvw[uvw_ID] = New TYPE_uvw
  242.                                 ARRAY_uvw[uvw_ID]ID = uvw_ID
  243.                                 ARRAY_uvw[uvw_ID]u# = Float#(ARRAY_line_elements[2])
  244.                                 ARRAY_uvw[uvw_ID]v# = -Float#(ARRAY_line_elements[3])
  245.  
  246.                                 uvw_ID = uvw_ID + 1
  247.                                
  248.                         Case "g"
  249. ;                               DebugLog "GROUP"
  250.                                 groupname$ = ARRAY_line_elements[2]
  251.                                 If groupname$ = "DUMMY"
  252.                                         group_ignore = True
  253.                                         ;create a new child dummy object here
  254.                                         child = CreateSphere(4,mesh);CreatePivot(mesh)
  255.                                         ScaleMesh child,0.05,0.05,0.05
  256.                                         EntityColor child,255,0,0
  257.                                         NameEntity child , ARRAY_line_elements[3]
  258.                                         DebugLog "Child object "+EntityName$(child)+" created."
  259.                                 Else
  260.                                         group_ignore = False
  261.                                 EndIf
  262.  
  263.                         Case "usemtl"
  264.                                 If (group_ignore=False)
  265. ;                                       DebugLog "MATERIAL"
  266.                                         temp$ = (ARRAY_line_elements[2])
  267.  
  268.                                         ;seperate the texture filename from any flags / info
  269.                                         pos = 1
  270.                                         Repeat
  271.                                                 char$ = Mid$( temp$ , pos , 1)
  272.                                                 pos = pos + 1
  273.                                         Until (char$ = "_") Or (pos>Len(temp$))
  274.                                         last_material$ = Left$( temp$ , pos-2 )
  275. ;                                       DebugLog "last material : "+last_material$
  276.                                 EndIf
  277.  
  278.                         Case "f"
  279.                                 If (group_ignore=False)
  280. ;                                       DebugLog "FACE "+face_ID
  281.                                         ARRAY_face[face_ID] = New TYPE_face
  282.                                         ARRAY_face[face_ID]ID = face_ID
  283.                                         ARRAY_face[face_ID]materialID$ = last_material$
  284.                                        
  285.                                         num = 2
  286.                                         vertex_number = 1
  287.                                        
  288.                                         While ARRAY_line_elements[num] <> ""
  289.         ;                                       DebugLog "   Face element:"+ARRAY_line_elements[num]
  290.                                                
  291.                                                 ;extract vertex ID
  292.                                                 pos = 1
  293.                                                 char$ = ""
  294.                                                 number$ = ""
  295.                                                 Repeat
  296.                                                         char$ = Mid$(ARRAY_line_elements[num] , pos , 1)
  297.                                                         If (char$<>"/") number$ = number$ + char$
  298.                                                         pos = pos + 1
  299.                                                 Until char$="/"
  300.                                                 ARRAY_face[face_ID]vertexID[ num-1 ] = Int(number$)
  301.         ;                                       DebugLog "   Vertex ID:"+ARRAY_face[face_ID]vertexID[ num-1 ]
  302.        
  303.                                                 ;extract UVW id
  304.                                                 char$ = ""
  305.                                                 number$ = ""
  306.                                                 Repeat
  307.                                                         char$ = Mid$(ARRAY_line_elements[num] , pos , 1)
  308.                                                         If (char$<>"/") number$ = number$ + char$
  309.                                                         pos = pos + 1
  310.                                                 Until char$="/"
  311.                                                 ARRAY_face[face_ID]uvwID[ num-1 ] = Int(number$)
  312.         ;                                       DebugLog "   UVW ID:"+ARRAY_face[face_ID]uvwID[ num-1 ]
  313.        
  314.                                                 ;extract normal id
  315.                                                 char$ = ""
  316.                                                 number$ = ""
  317.                                                 Repeat
  318.                                                         char$ = Mid$(ARRAY_line_elements[num] , pos , 1)
  319.                                                         If (char$<>"/") number$ = number$ + char$
  320.                                                         pos = pos + 1
  321.                                                 Until char$="/" Or char$=""
  322.                                                 ARRAY_face[face_ID]
  323. ormalID[ num-1 ] = Int(number$)
  324.         ;                                       DebugLog "   Normal ID:"+ARRAY_face[face_ID]
  325. ormalID[ num-1 ]
  326.        
  327.                                                 num = num + 1
  328.                                         Wend
  329.                                                                        
  330.                                         ARRAY_face[face_ID]
  331. umber_of_vertices = (num - 2)
  332.         ;                               DebugLog "Face has "+ARRAY_face[face_ID]
  333. umber_of_vertices+" vertices."
  334.        
  335.                                         face_ID = face_ID + 1
  336.                                
  337.                                 Else
  338.                                
  339.                                 ;scan the face listsings to obtain an average centre position for the child marker
  340.                                         DebugLog "DUMMY OBJECT FACE FOUND"
  341.                                         ARRAY_dummy_face[1] = New TYPE_face
  342.                                        
  343.                                         num = 2
  344.                                        
  345.                                         While ARRAY_line_elements[num] <> ""
  346.                                                 ;extract vertex number
  347.                                                 pos = 1
  348.                                                 char$ = ""
  349.                                                 number$ = ""
  350.                                                 Repeat
  351.                                                         char$ = Mid$(ARRAY_line_elements[num] , pos , 1)
  352.                                                         If (char$<>"/") number$ = number$ + char$
  353.                                                         pos = pos + 1
  354.                                                 Until char$="/"
  355.                                                 ARRAY_dummy_face[1]vertexID[ num-1 ] = Int(number$)
  356.                
  357.                                                 num = num + 1
  358.                                         Wend
  359.                                        
  360.                                         ;average the four vertices
  361.                                         dummy_x# = 0.0
  362.                                         dummy_y# = 0.0
  363.                                         dummy_z# = 0.0
  364.                                         For a=1 To 4
  365.                                                 dummy_x# = dummy_x# + ARRAY_vertex[ ARRAY_dummy_face[1]vertexID[ a ] ]x#
  366.                                                 dummy_y# = dummy_y# + ARRAY_vertex[ ARRAY_dummy_face[1]vertexID[ a ] ]y#
  367.                                                 dummy_z# = dummy_z# + ARRAY_vertex[ ARRAY_dummy_face[1]vertexID[ a ] ]z#
  368.                                         Next
  369.                                         dummy_x# = dummy_x# / 4.0
  370.                                         dummy_y# = dummy_y# / 4.0
  371.                                         dummy_z# = dummy_z# / 4.0
  372.  
  373.                                         PositionEntity child , dummy_x# , dummy_y# , dummy_z# , True
  374.                                         DebugLog "dummy object position : "+dummy_x#+" , "+dummy_y#+" , "+dummy_z#
  375.                                 EndIf
  376.                                                                        
  377.                         Default
  378.                                 DebugLog "ERROR : MESH FILE : LINE NOT RECOGNIZED : "+txt$
  379.  
  380.                         End Select
  381.                        
  382.                 Until Eof( file )
  383.  
  384.  
  385.  
  386.                 ;cycle through faces and build vertices and polygons
  387.                 For f=1 To (face_ID-1)
  388.  
  389.                         ;reset current surf to zero
  390.                         surf = 0
  391.  
  392.                         ;check if surface using this material ID$ already exists
  393.                         For s.TYPE_surface = Each TYPE_surface
  394.                                 If smaterialID$ = ARRAY_face[f]materialID$
  395.                                         surf = spointer
  396.                                 EndIf
  397.                         Next
  398.                        
  399.                         ;if surface not found create new
  400.                         If surf=0
  401.                                 ;create new surface and store the material ID$ used
  402.                                 ARRAY_surface[surface_ID] = New TYPE_surface
  403.                                 ARRAY_surface[surface_ID]ID = surface_ID
  404.                                 ARRAY_surface[surface_ID]pointer = CreateSurface( mesh )
  405.                                 ARRAY_surface[surface_ID]materialID$ = ARRAY_face[f]materialID$
  406.                                 surf = ARRAY_surface[surface_ID]pointer
  407.                                 surface_ID = surface_ID + 1
  408.                         EndIf
  409.  
  410.                         ;cycle through this faces verts and create them if necessary
  411.                         For v=1 To ARRAY_face[f]
  412. umber_of_vertices
  413.                        
  414.                                 ;obtain relevant details
  415.                                 vert_number = ARRAY_face[f]vertexID[v]
  416.                                 normal_number = ARRAY_face[f]
  417. ormalID[v]
  418.                                 texcoord_number = ARRAY_face[f]uvwID[v]
  419.                                
  420.                                 ;if vert doesn't exists then create new
  421.                                 If ARRAY_vertex[vert_number]pointer = -1
  422.                                         ARRAY_vertex[vert_number]pointer = AddVertex( surf , ARRAY_vertex[vert_number]x# , ARRAY_vertex[vert_number]y# , ARRAY_vertex[vert_number]z# )
  423.                                         VertexNormal( surf , ARRAY_vertex[vert_number]pointer , ARRAY_normal[normal_number]
  424. x# , ARRAY_normal[normal_number]
  425. y# , ARRAY_normal[normal_number]
  426. z#)
  427.                                         VertexTexCoords( surf , ARRAY_vertex[vert_number]pointer , ARRAY_uvw[texcoord_number]u# , ARRAY_uvw[texcoord_number]v# )
  428.                                         ARRAY_vertex[vert_number]u# = ARRAY_uvw[texcoord_number]u#
  429.                                         ARRAY_vertex[vert_number]v# = ARRAY_uvw[texcoord_number]v#
  430.                                 Else
  431.                                         ;if it does exist, check that the UV coords match
  432.                                         new_U# = ARRAY_uvw[texcoord_number]u#
  433.                                         new_V# = ARRAY_uvw[texcoord_number]v#
  434. ;                                       DebugLog "New vertex UVs : "+new_U#+" , "+new_V#
  435.                                         ;existing UVs
  436.                                         existing_U# = ARRAY_vertex[vert_number]u#
  437.                                         existing_V# = ARRAY_vertex[vert_number]v#
  438. ;                                       DebugLog "Existing veretx UVs : "+existing_U#+" , "+existing_V#
  439.                                        
  440.                                         diff_U# = Abs(existing_U# - new_U#)
  441.                                         diff_V# = Abs(existing_V# - new_V#)
  442.                                         If (diff_U# > VERTEX_MERGE_TOLLERANCE#) Or (diff_V# > VERTEX_MERGE_TOLLERANCE#)
  443.                                                 ;create a new vertex here to avoid distorting texture coords
  444. ;                                               DebugLog "CREATE NEW VERTEX : "+vertex_ID
  445.  
  446.                                                 ARRAY_vertex[vertex_ID] = New TYPE_vertex
  447.                                                 ARRAY_vertex[vertex_ID]ID = vertex_ID
  448.                                                 ARRAY_vertex[vertex_ID]x# = ARRAY_vertex[vert_number]x#
  449.                                                 ARRAY_vertex[vertex_ID]y# = ARRAY_vertex[vert_number]y#
  450.                                                 ARRAY_vertex[vertex_ID]z# = ARRAY_vertex[vert_number]z#
  451.                                                 ARRAY_vertex[vertex_ID]pointer = AddVertex( surf , ARRAY_vertex[vertex_ID]x# , ARRAY_vertex[vertex_ID]y# , ARRAY_vertex[vertex_ID]z# )
  452.                                                 VertexNormal( surf , ARRAY_vertex[vertex_ID]pointer , ARRAY_normal[normal_number]
  453. x# , ARRAY_normal[normal_number]
  454. y# , ARRAY_normal[normal_number]
  455. z#)
  456.                                                 VertexTexCoords( surf , ARRAY_vertex[vertex_ID]pointer , ARRAY_uvw[texcoord_number]u# , ARRAY_uvw[texcoord_number]v# )
  457.                                                 ARRAY_vertex[vertex_ID]u# = ARRAY_uvw[texcoord_number]u#
  458.                                                 ARRAY_vertex[vertex_ID]v# = ARRAY_uvw[texcoord_number]v#
  459.                                                
  460.                                                 ARRAY_face[f]vertexID[v] = vertex_ID
  461.                                                 vertex_ID = vertex_ID + 1
  462.                                         EndIf
  463.                                 EndIf
  464.                         Next
  465.                        
  466.                         ;create tris if 3-sided polygon
  467.                         If (ARRAY_face[f]
  468. umber_of_vertices = 3)
  469.                                 v0 = ARRAY_face[f]vertexID[3]
  470.                                 v1 = ARRAY_face[f]vertexID[2]
  471.                                 v2 = ARRAY_face[f]vertexID[1]
  472.                                 tri1 = AddTriangle( surf , ARRAY_vertex[v0]pointer , ARRAY_vertex[v1]pointer , ARRAY_vertex[v2]pointer )
  473.                         EndIf
  474.  
  475.                         ;create tris if 4-sided polygon
  476.                         If (ARRAY_face[f]
  477. umber_of_vertices = 4)
  478.                                 v0 = ARRAY_face[f]vertexID[4]
  479.                                 v1 = ARRAY_face[f]vertexID[3]
  480.                                 v2 = ARRAY_face[f]vertexID[2]
  481.                                 v3 = ARRAY_face[f]vertexID[1]
  482.                                 tri1 = AddTriangle( surf , ARRAY_vertex[v0]pointer , ARRAY_vertex[v1]pointer , ARRAY_vertex[v2]pointer )
  483.                                 tr21 = AddTriangle( surf , ARRAY_vertex[v0]pointer , ARRAY_vertex[v2]pointer , ARRAY_vertex[v3]pointer )
  484.                         EndIf
  485.        
  486.                 Next           
  487.  
  488.                 ;output object stats
  489.                 DebugLog "   Mesh : surface count : "+CountSurfaces(mesh)
  490.                 For a=1 To CountSurfaces(mesh)
  491.                         DebugLog "      Mesh : Surface "+a+" - vertex count : "+CountVertices(GetSurface(mesh,a))+"    triangle count : "+CountTriangles(GetSurface(mesh,a))
  492.                 Next
  493.  
  494.  
  495.                
  496.                 ;process the material file and setup brushes and textures              
  497.                 file = ReadFile(directory$+material_library$)
  498.                 material_ID = 1
  499.  
  500.                 If file
  501.                         DebugLog "   Material file "+material_library$+" found."
  502.                        
  503.                         ;set to start of file
  504.                         SeekFile( file , 0)
  505.  
  506.                         ;cycle through lines and parse each one
  507.                         Repeat
  508.                                 ;parse line to obtain the individual elements
  509.                                 txt$ = ReadLine$( file )
  510.                                 FUNC_Parse_Line( txt$ , " ")
  511.  
  512.                                 ;process the stored words and store them
  513.                                 Select ARRAY_line_elements[1]
  514.                                 Case "newmtl"
  515. ;                                       DebugLog "      NEW MATERIAL"
  516.                                         ARRAY_material[material_ID] = New TYPE_material
  517.                                         ARRAY_material[material_ID]ID = material_ID
  518.                                         ARRAY_material[material_ID]all_flags$ = ARRAY_line_elements[2]
  519.                                 Case "Ka"
  520. ;                                       DebugLog "      Ka"
  521.                                         ARRAY_material[material_ID]alpha# = Float#(ARRAY_line_elements[2])
  522.                                 Case "Kd"
  523. ;                                       DebugLog "      Kd"
  524.                                         ARRAY_material[material_ID]
  525. ed = 255 * Float#(ARRAY_line_elements[2])
  526.                                         ARRAY_material[material_ID]green = 255 * Float#(ARRAY_line_elements[3])
  527.                                         ARRAY_material[material_ID]lue = 255 * Float#(ARRAY_line_elements[4])
  528.                                 Case "Ks"
  529. ;                                       DebugLog "      Ks"
  530.                                 Case "Ns"
  531. ;                                       DebugLog "      Ns"
  532.                                         ARRAY_material[material_ID]shininess# = (1.0 / 127.0) * Int(ARRAY_line_elements[2])
  533.                                         If (ARRAY_material[material_ID]shininess# > 1.0) ARRAY_material[material_ID]shininess# = 1.0
  534.                                 Case "map_Kd"
  535. ;                                       DebugLog "      map_Kd"
  536.                                         ARRAY_material[material_ID]     exture_filename$ = ARRAY_line_elements[2]
  537.                                 Default
  538.                                         DebugLog "ERROR : MATERIAL FILE : LINE NOT RECOGNIZED : "+txt$
  539.                                 End Select
  540.  
  541.                                 ;parse and store the flags segction                            
  542.                                 FUNC_Parse_Line( ARRAY_material[material_ID]all_flags$ , "_")
  543.                                 top_texture_filename$ = Replace$(ARRAY_line_elements[1],"_","")
  544.                                 ARRAY_material[material_ID]FLAG_brush_blend = Int(ARRAY_line_elements[2])
  545.                                 ARRAY_material[material_ID]FLAGS_brush_FX = Int(ARRAY_line_elements[3])
  546.                                 ARRAY_material[material_ID]FLAG_texture_blend = Int(ARRAY_line_elements[4])
  547.                                 ARRAY_material[material_ID]FLAGS_texture_flags = Int(ARRAY_line_elements[5])
  548.  
  549.                                 ;check for .DDS override
  550.                                 If (top_texture_filename$ <> ARRAY_material[material_ID]        exture_filename$)                      
  551.                                         ARRAY_material[material_ID]     exture_filename$ = top_texture_filename$
  552.                                         DebugLog "TEXTURE NAME OVERRIDE : Setting texture to "+ARRAY_material[material_ID]      exture_filename$
  553.                                 EndIf
  554.                                
  555.                         Until Eof(file)
  556.                        
  557. ;                       DebugLog "MATERIAL PROCESSING COMPLETE."
  558.                 Else
  559.                         DebugLog "ERROR : MATERIAL FILE : "+material_library$+" NOT FOUND."
  560.                 EndIf
  561.                
  562.                 ;create and assign brushes
  563.                 For m.TYPE_material = Each TYPE_material
  564.                         brush = CreateBrush( m
  565. ed , mgreen , mlue )
  566.                         BrushBlend brush , mFLAG_brush_blend
  567.                         BrushFX brush , mFLAGS_brush_FX
  568.                         BrushAlpha brush , malpha#
  569.                         BrushShininess brush , mshininess#
  570.                         BrushColor brush , m
  571. ed , mgreen , mlue
  572.                        
  573.                         ;load texture
  574.                         texture = LoadTexture(directory$ + m    exture_filename$ , mFLAGS_texture_flags)
  575.                         TextureBlend texture , mFLAG_texture_blend
  576.                         If texture
  577.                                 DebugLog "   Texture "+m        exture_filename$+" loaded : flags "+mFLAGS_texture_flags
  578.                                 BrushTexture brush , texture
  579.                         EndIf
  580.                        
  581.                         ;cycle through syrfaces and assign this brush
  582.                         For s.TYPE_surface = Each TYPE_surface
  583. ;                               DebugLog "Surface "+sID+" material="+smaterialID$
  584. ;                               DebugLog "Brush "+m     exture_filename$
  585.                                 If m    exture_filename$ = smaterialID$
  586.                                         PaintSurface spointer , brush
  587.                                 EndIf
  588.                         Next
  589.                 Next
  590.                
  591.  
  592.  
  593.                 FUNC_CleanUp()
  594.                
  595.                 Return mesh            
  596.         Else
  597.                 ;file open failed, return -1
  598.                 Return -1
  599.         EndIf
  600.  
  601. End Function
  602. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  603.  
  604.  
  605.  
  606.  
  607.  
  608.  
  609.  
  610. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  611. Function FUNC_CleanUp()
  612.         For v.TYPE_vertex = Each TYPE_vertex
  613.                 Delete v
  614.         Next
  615.         For n.TYPE_normal = Each TYPE_normal
  616.                 Delete n
  617.         Next
  618.         For u.TYPE_uvw = Each TYPE_uvw
  619.                 Delete u
  620.         Next
  621.         For f.TYPE_face = Each TYPE_face
  622.                 Delete f
  623.         Next
  624.         For s.TYPE_surface = Each TYPE_surface
  625.                 Delete s
  626.         Next
  627.         For m.TYPE_material = Each TYPE_material
  628.                 Delete m
  629.         Next
  630. End Function
  631. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  632.  
  633.  
  634.  
  635.  
  636.  
  637.  
  638. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  639. Function FUNC_Parse_Line( txt$ , break$ )
  640.  
  641.         ;clear the storage array
  642.         For a=1 To 100
  643.                 ARRAY_line_elements[a] = ""
  644.         Next
  645.  
  646. ;       DebugLog "FUNCTION : FUNC_Parse_Obtain_String( '"+txt$+"' )"
  647.  
  648.         ;cycle to correct word in line
  649.         startpos = 1
  650.         num = 1
  651.        
  652.         Repeat
  653.                 char$ = ""
  654.                 word$ = ""
  655.                 Repeat
  656.                         ;read line until space is found
  657.                         char$ = Mid$( txt$ , startpos , 1)
  658.                         startpos = startpos + 1
  659.                         If (char$<>" ") word$ = word$ + char$
  660.                 Until (char$ = break$) Or startpos>Len(txt$)
  661.                
  662.                 ;store the word
  663.                 ARRAY_line_elements[num] = word$
  664.                 num = num + 1
  665. ;               DebugLog "word extracted:"+word$+"."
  666.  
  667.         Until (startpos>Len(txt$))
  668.        
  669. End Function
  670. ;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


Comments : none...

 

SimplePortal 2.3.6 © 2008-2014, SimplePortal