TheGameCreators - CodeBase - Import AC3D object

Return to the CodeBase listing

Category: System Enhancements

Version: 1.0

Information

Uploaded: 8th Feb 2011 22:23

Modified: 1st Jan 1970 01:00

Author: moqzart

Summary

Load models from the popular AC3D modelling application

Full Description

With modification you can load as mesh or as object and then save in DarkBasic format

DarkBASIC Professional Source Code

` This code was downloaded from The Game Creators

` It is reproduced here with full permission

` http://www.thegamecreators.com

Rem Project: AC3D Importer

Rem Created: Wednesday, February 09, 2011

Rem ***** Main Source File *****

// NOTE: Requires EZRotate Module for calculating normals on vertices

// Things to do:

// 	1.	Convert ac3d model heirarchy to DarkBasic object w/ limbs

// 	2.	Convert surface material to vertice diffuse

// 	3.	Provide texture handling

type vertex

x             as float

y             as float

z             as float

nx            as float

ny            as float

nz            as float

diffuse       as dword

u             as float

v             as float

endtype

type rgbf

r as float

g as float

b as float

endtype

type vector2

x as float

y as float

endtype

type vector3

x as float

y as float

z as float

endtype

type ac3d_rotation_matrix

x as vector3

y as vector3

z as vector3

endtype

type ac3d_object

_type as string

_data as string

name as string

location as vector3

rotation as ac3d_rotation_matrix

vertices as integer

first_vertex as integer

surfaces as integer

first_surface as integer

texture as string

texture_repeat as vector2

url as string

kids as integer

endtype

type ac3d_surface

flags as integer

material as integer

references as integer

first_reference as integer

endtype

type ac3d_material

name as string

color as rgbf

ambience as rgbf

emissive as rgbf

specular as rgbf

shine as integer

transparency as float

endtype

type ac3d_reference

i as integer

u as float

v as float

endtype

global dim vbuffer()            as vertex

global dim polygons()           as dword

global default_polygon_diffuse  as dword

global dim ac3d_objects()       as ac3d_object

global dim ac3d_surfaces()      as ac3d_surface

global dim ac3d_materials()     as ac3d_material

global dim ac3d_textures()      as string

global dim ac3d_vertices()      as vector3

global dim ac3d_references()    as ac3d_reference

global dim deleted_objects()    as integer

global last_object              as integer

global dim deleted_memblocks()  as integer

global last_memblock            as integer

global dim deleted_meshes()     as integer

global last_mesh                as integer

input "Enter filename"; filename$

obj = ac3d_import(filename$)

TURN OBJECT LEFT obj, 0.2

LOOP

end

function ac3d_import(filename as string)

local object    as ac3d_object

local material  as ac3d_material

local surface   as ac3d_surface

local vector    as vector3

local reference as ac3d_reference

rem set array indices

array index to queue ac3d_objects()

array index to queue ac3d_surfaces()

array index to queue ac3d_materials()

array index to queue ac3d_textures()

array index to queue ac3d_vertices()

array index to queue ac3d_references()

file = 1

if not file exist(filename) then exitfunction

open to read file, filename

read string file, header$

if left$(header$,4) = "AC3D"

while not file end(file)

read string file, line$

token$ = first token$(line$, " ")

select token$

case "MATERIAL"

// MATERIAL %s rgb %f %f %f  amb %f %f %f  emis %f %f %f  spec %f %f %f  shi %d  trans %f

material.name = next token$(" ")

repeat

token$ = next token$(" ")

select token$

case "rgb"

material.color.r = val(next token$(" "))

material.color.b = val(next token$(" "))

material.color.g = val(next token$(" "))

endcase

case "amb"

material.ambience.r = val(next token$(" "))

material.ambience.b = val(next token$(" "))

material.ambience.g = val(next token$(" "))

endcase

case "emis"

material.emissive.r = val(next token$(" "))

material.emissive.b = val(next token$(" "))

material.emissive.g = val(next token$(" "))

endcase

case "spec"

material.specular.r = val(next token$(" "))

material.specular.b = val(next token$(" "))

material.specular.g = val(next token$(" "))

endcase

case "shi"

material.shine = val(next token$(" "))

endcase

case "trans"

material.transparency = val(next token$(" "))

endcase

endselect

until token$ = ""

rem add material to material library array

add to queue ac3d_materials()

ac3d_materials() = material

endcase

case "OBJECT"

// OBJECT %s

object._type = next token$(" ")

read string file, line$

token$ = first token$(line$, " ")

select token$

case "name"

// name %s

object.name = next token$(" ")

endcase

case "data"

// data %d

read string file, object._data

endcase

case "texture"

// texture %s

object.texture = next token$(" ")

endcase

case "texrep"

// texrep %f %f

object.texture_repeat.x = val(next token$(" "))

object.texture_repeat.y = val(next token$(" "))

endcase

case "rot"

// rot %f %f %f  %f %f %f  %f %f %f

object.rotation.x.x = val(next token$(" "))

object.rotation.x.y = val(next token$(" "))

object.rotation.x.z = val(next token$(" "))

object.rotation.y.x = val(next token$(" "))

object.rotation.y.y = val(next token$(" "))

object.rotation.y.z = val(next token$(" "))

object.rotation.z.x = val(next token$(" "))

object.rotation.z.y = val(next token$(" "))

object.rotation.z.z = val(next token$(" "))

endcase

case "loc"

// loc %f %f %f

object.location.x = val(next token$(" "))

object.location.y = val(next token$(" "))

object.location.z = val(next token$(" "))

endcase

case "url"

// url %s

object.url = next token$(" ")

endcase

case "numvert"

// numvert %d

object.vertices = val(next token$(" "))

object.first_vertex = array count(ac3d_vertices()) + 1

// numvert lines of %f %f %f

for i=1 to object.vertices

read string file, vert$

vector.x = val(first token$(vert$," "))

vector.y = val(next token$(" "))

vector.z = val(next token$(" "))

add to queue ac3d_vertices()

ac3d_vertices() = vector

endcase

case "numsurf"

// numsurf %d

object.surfaces = val(next token$(" "))

object.first_surface = array count(ac3d_surfaces()) + 1

for i = 1 to object.surfaces

read string file, line$

token$ = first token$(line$, " ")

select token$

case "SURF"

// SURF %d

surface.flags = val(next token$(" "))

endcase

case "mat"

// mat %d

surface.material = val(next token$(" "))

endcase

case "refs"

// refs %d

surface.references = val(next token$(" "))

surface.first_reference = array count(ac3d_references()) + 1

// refs lines of %d %f %f

for j = 1 to surface.references

read string file, ref$

reference.i = val(first token$(ref$," "))

reference.u = val(next token$(" "))

reference.v = val(next token$(" "))

add to queue ac3d_references()

ac3d_references() = reference

add to queue ac3d_surfaces()

ac3d_surfaces() = surface

exit

endcase

endselect

loop

endcase

case "kids"

// kids %d

object.kids = val(next token$(" "))

add to queue ac3d_objects()

ac3d_objects() = object

exit    // poop de loop

endcase

endselect

loop

endcase

endselect

endwhile

else

close file file

exitfunction

endif

close file file

// perform conversion of ac3d data to DarkBasic Object/s or Mesh/es

// =========================================================================

// THIS SECTION USES TYPES AND FUNCTIONS FOUND IN DARK_MODELLER.DBA

// As denoted with ***

// =========================================================================

local v1 as vertex // ***

local v2 as vertex // ***

local v3 as vertex // ***

array index to queue ac3d_objects()

while array index valid(ac3d_objects())

object = ac3d_objects()

if object.surfaces > 0

for j = 0 to object.surfaces - 1

surface_index = j + object.first_surface

if surface_index > array count(ac3d_surfaces()) then exit

fr = ac3d_surfaces(surface_index).first_reference

nr = ac3d_surfaces(surface_index).references

i = fr

// Convert surface to polygons

// NOTE: complex surfaces i.e. surfaces made of concave polygons may

// not convert well. It is best make sure that complex surfaces are

// made up of smaller convex polygons.

v = ac3d_references(i).i + object.first_vertex

if v > array count(ac3d_vertices()) then exit

v1.x = ac3d_vertices(v).x

v1.y = ac3d_vertices(v).y

v1.z = ac3d_vertices(v).z

v1.u = ac3d_references(i).u

v1.v = ac3d_references(i).v

if i + 2 > array count(ac3d_references()) then exit

v = ac3d_references(i + 1).i + object.first_vertex

if v > array count(ac3d_vertices()) then exit

v2.x = ac3d_vertices(v).x

v2.y = ac3d_vertices(v).y

v2.z = ac3d_vertices(v).z

v2.u = ac3d_references(i + 1).u

v2.v = ac3d_references(i + 1).v

v = ac3d_references(i + 2).i + object.first_vertex

if v > array count(ac3d_vertices()) then exit

v3.x = ac3d_vertices(v).x

v3.y = ac3d_vertices(v).y

v3.z = ac3d_vertices(v).z

v3.u = ac3d_references(i + 2).u

v3.v = ac3d_references(i + 2).v

poly = add_poly(v1,v2,v3) // ***

inc i

if i + 2 = fr + nr then exit

loop

// for multiple objects use generate_object() or genrate_mesh() here

// NOTE: you will have to include some additional code

//       to keep track of all objects/meshes

// obj = generate_object()

// always clear the vertice buffer between object/mesh generation

// clear_vbuffer()

endif

next array index ac3d_objects()

endwhile

// create mesh or object

obj = generate_object() // ***

clear_vbuffer() // ***

rem free up strings in defined type arrays

array index to queue ac3d_objects()

while array index valid(ac3d_objects())

ac3d_objects()._type   = free string$()

ac3d_objects()._data   = free string$()

ac3d_objects().name    = free string$()

ac3d_objects().texture = free string$()

ac3d_objects().url     = free string$()

next array index ac3d_objects()

endwhile

array index to queue ac3d_materials()

while array index valid(ac3d_materials())

ac3d_materials().name    = free string$()

next array index ac3d_materials()

endwhile

rem empty out all arrays

empty array ac3d_objects()

empty array ac3d_surfaces()

empty array ac3d_materials()

empty array ac3d_textures()

empty array ac3d_vertices()

empty array ac3d_references()

endfunction obj

function add_poly(v1 as vertex, v2 as vertex, v3 as vertex)

EZro_FindNormal v1.x,v1.y,v1.z,v2.x,v2.y,v2.z,v3.x,v3.y,v3.z

v1.nx = EZro_GetNormalX()

v1.ny = EZro_GetNormalY()

v1.nz = EZro_GetNormalZ()

v2.nx = EZro_GetNormalX()

v2.ny = EZro_GetNormalY()

v2.nz = EZro_GetNormalZ()

v3.nx = EZro_GetNormalX()

v3.ny = EZro_GetNormalY()

v3.nz = EZro_GetNormalZ()

v1.diffuse = default_polygon_diffuse

v2.diffuse = default_polygon_diffuse

v3.diffuse = default_polygon_diffuse

array index to queue vbuffer()

poly = array count(vbuffer()) + 1

add to queue vbuffer()

vbuffer() = v1

add to queue vbuffer()

vbuffer() = v2

add to queue vbuffer()

vbuffer() = v3

endfunction poly

function generate_object()

mesh = generate_mesh()

object = generate_object_from_mesh(mesh)

endfunction object

function generate_object_from_mesh(mesh as integer)

object = allocate_object()

make object object,mesh,0

lock vertexdata for limb object,0

for i = 0 to array count(polygons())

set indexdata i,polygons(i)

unlock vertexdata

destroy_mesh(mesh)

endfunction object

function generate_mesh()

mb = copy_buffer_to_memblock()

mesh = allocate_mesh()

make mesh from memblock mesh,mb

destroy_memblock(mb)

endfunction mesh

function allocate_object()

local o as integer

if array count(deleted_objects())>-1

o = deleted_objects(0)

array delete element deleted_objects(0)

else

inc last_object

o = last_object

endif

endfunction o

function destroy_object(obj as integer)

if object exist(obj) then delete object obj

if obj > last_object then exitfunction

if obj = last_object

dec last_object

else

array index to queue deleted_objects()

add to queue deleted_objects()

deleted_objects() = obj

endif

endfunction

function allocate_memblock()

local m as integer

if array count(deleted_memblocks())>-1

m = deleted_memblocks(0)

array delete element deleted_memblocks(0)

else

inc last_memblock

m = last_memblock

endif

endfunction m

function destroy_memblock(mb as integer)

if memblock exist(mb) then delete memblock mb

if mb > last_memblock then exitfunction

if mb = last_memblock

dec last_memblock

else

array index to queue deleted_memblocks()

add to queue deleted_memblocks()

deleted_memblocks() = mb

endif

endfunction

function clear_vbuffer()

empty array vbuffer()

empty array polygons()

endfunction

function copy_buffer_to_memblock()

v as vertex

vertices = array count(vbuffer()) + 1

mb = allocate_memblock()

make_memblock_mesh(mb,vertices)

pos = 12

array index to queue vbuffer()

while array index valid(vbuffer())

v = vbuffer()

pos = write_memblock_vertice(mb,pos,v)

next array index vbuffer()

endwhile

endfunction mb

function make_memblock_mesh(mem_blk as integer,vertices as integer)

mem_size = 12 + vertices * 36

make memblock mem_blk,mem_size

write memblock dword mem_blk,0,338

write memblock dword mem_blk,4,36

write memblock dword mem_blk,8,vertices

endfunction

function write_memblock_vertice(mem_blk as integer,mem_pos as integer,v as vertex)

mbSize = get memblock size(mem_blk)

end_pos = mem_pos + 36

if end_pos > mbSize then exitfunction end_pos

write memblock float mem_blk,mem_pos,v.x

inc mem_pos,4

write memblock float mem_blk,mem_pos,v.y

inc mem_pos,4

write memblock float mem_blk,mem_pos,v.z

inc mem_pos,4

write memblock float mem_blk,mem_pos,v.nx

inc mem_pos,4

write memblock float mem_blk,mem_pos,v.ny

inc mem_pos,4

write memblock float mem_blk,mem_pos,v.nz

inc mem_pos,4

write memblock dword mem_blk,mem_pos,v.diffuse

inc mem_pos,4

write memblock float mem_blk,mem_pos,v.u

inc mem_pos,4

write memblock float mem_blk,mem_pos,v.v

endfunction end_pos

function allocate_mesh()

local m as integer

if array count(deleted_meshes())>-1

m = deleted_meshes(0)

array delete element deleted_meshes(0)

else

inc last_mesh

m = last_mesh

endif

endfunction m

function destroy_mesh(m as integer)

if mesh exist(m) then delete mesh m

if m > last_mesh then exitfunction

if m = last_mesh

dec last_mesh

else

array index to queue deleted_meshes()

add to queue deleted_meshes()

deleted_meshes() = m

endif

endfunction

Download

Please login to download

Comments

No comments yet.

Author Name:	moqzart
CodeBase Entries:	7

CodeBase - Import AC3D object

Information

Summary

Full Description

DarkBASIC Professional Source Code

Download

Screen Shot

Author

Comments