Generated: Mon Aug 29 19:34:09 2016 from ac3d2threejs.pl 2014/11/01 30.2 KB. text copy
#!/usr/bin/perl # ======================================================================== #< ac3d2threejs.pl - 12/05/2013 # AC3D parser and converter to three.js json format # Based on ac3d2Horde3D format by Niek Albers, circa 13/11/2009 # 24/10/2014 - revisit - default to add normals to off # 12/05/2013 geoff mclane http://geoffair.net/mperl # TODO: # 1: There are several TODO items noted, mainly where a more strict # parsing would help. # 2: At present a rought fix in output to ensure a "faces" : [ ] index is # not out of range of the vertices or normals lists, but should address # why this happens. # 3: Should dig into the calculation of the normals. Original code expected # only 3 refs, but have over-ridden this, but with what consequence? # 4: Would be nice if some of the 'options' below were available on the command # line, including for example the output file name. # ========================================================================== my $os = $^O; # This need to be adjusted to suit your environment my $perl_dir = '/home/geoff/bin'; my $PATH_SEP = '/'; my $temp_dir = '/tmp'; if ($os =~ /win/i) { $perl_dir = 'C:\GTools\perl'; $temp_dir = $perl_dir; $PATH_SEP = "\\"; } unshift(@INC, $perl_dir); # add location of lib_vec3.pm my $VERSION = 0.8; # 01/11/2014 - more fixes - geoff #my $VERSION = 0.7; # 12/05/2013 - lots of fixes - geoff #my $VERSION = 0.6; # last by Niek Albers, circa 13/11/2009 use strict; use warnings; #no strict 'refs'; #no warnings; use Data::Dumper; use Carp; use File::Copy; # note: in the original this 'package' was included, but I prefer it separated require 'lib_vec3.pm' or die "Unable to load 'lib_vec3.pm' Check paths in \@INC...\n"; my $pgmname = $0; if ($pgmname =~ /(\\|\/)/) { my @tmpsp = split(/(\\|\/)/,$pgmname); $pgmname = $tmpsp[-1]; } my $AC3D_FILE_VERSION = 11; my $strict_triangluation = 0; # 0=allow any number of SURF refs my $out_file = $temp_dir.$PATH_SEP."tempscene.xml"; # not used my $json_file = ''; # options my $do_welding = 0; # not sure what all this was about - it increases the vertices... my $show_welding = 0; # now not done - see $do_welding = 0; my $show_unwelding = 0; # now not done - see $do_welding = 0; my $show_objects = 1; # turn off to reduce noise my $show_calc_norms = 0; # additional noise my $show_parse_kid = 0; # mainly for diagnostics my $show_parse_numvert = 0; # likewise my $show_out_of_range = 0; # show when an index is 'fixed' my $add_line_sep = 1; # add extra line to the json my $add_normals = 0; # generate normals my $verbosity = 0; sub VERB1() { return $verbosity >= 1; } sub VERB2() { return $verbosity >= 2; } sub VERB5() { return $verbosity >= 5; } sub VERB9() { return $verbosity >= 9; } my $normal = 0; # grep { $_ eq '-n' } @ARGV; my $scene_basename; my $source = ''; my $ac3dfile; # input file my $scenefile; my $geofile; my @VERTICES; my @INDICES; my @NORMALS; my @INDPERSURF = (); my @warnings = (); my $warn_count = 0; # also used as final exit level my $index_offset = 0; my $batch_offset = 0; my $world = {}; my $material_files = {}; my $last_name = ''; # my $vertice_count = 0; # 12/05/2013 - Added token 'subdiv' and 'texoff', # and changed 'data' to what I understand it does my $TOKENIZER = { 'MATERIAL' => \&parse_material, 'OBJECT' => \&parse_object, 'kids' => \&parse_kids, 'name' => \&parse_name, 'texture' => \&parse_value, 'crease' => \&parse_value, 'numvert' => \&parse_numvert, 'numsurf' => \&parse_numsurf, 'SURF' => \&parse_surf, 'mat' => \&parse_mat, 'refs' => \&parse_refs, 'texrep' => \&parse_texrep, 'rot' => \&parse_rot, 'loc' => \&parse_loc, 'url' => \&parse_value, 'data' => \&parse_data, 'subdiv' => \&parse_value, 'texoff' => \&parse_texoff, }; # ### DEBUG ### # Just some vey specific 'test' files, so I can run the script from my editor # with a blank command line... should be OFF for release my $debug_on = 0; #my $def_file = 'C:\FG\18\blendac3d\cube.ac'; #my $def_file = 'C:\FG\18\blendac3d\f16.ac'; #my $def_file = 'C:\FG\fgdata\Aircraft\A380\Models\FlightDeck\Glareshield\efis_c.ac'; # has 'subdiv 1' #my $def_file = 'C:\FG\fgdata\Aircraft\a4\Models\attitude-mod1.ac'; # has 'texoff -0.5 0.5' #14398: ac_to_gl: Unrecognised token 'light', line 'OBJECT light' #my $def_file = 'C:\FG\fgdata\Aircraft\dhc8\Models\dhc8.ac'; #ac_to_gl: Illegal ref record. actually has several blank lines!!! could overlook, but NO! # Also fails with blender ac importer until blank lines are removed #my $def_file = 'C:\FG\fgdata\Aircraft\Dromader\Models\DropSystem.ac'; my $def_file = 'C:\FG\ac3d\DropSystem.ac'; # fixed file - no warnings ############################################################################ eval { main(@ARGV) }; die($@) if ($@); exit($warn_count); sub prt($) { print shift; } sub prtw($) { my $t = shift; push(@warnings,$t); prt($t); } # simple vector3 class - now an external package sub vec3 { vec3->new(@_) } sub basename { my $path = shift; $path =~ s/.*[\/\\]//; return [ split( /\./, $path ) ]->[0]; } sub filename { my $path = shift; $path =~ s/.*[\/\\]//; return $path; } # load a file line, and 'tokenise' it, removing # any double quotes... sub parse_line { my $line = <$ac3dfile>; return if ( !$line ); my @items = ( $line =~ /(".*?"|\S+)/g ); map { s/(^"|"$)//g } @items; return \@items; } # individual opcode parsers sub parse_header { my $items = shift; $items->[0] =~ m/^AC3D(\w)/; die "not minimally an AC3D version $AC3D_FILE_VERSION file\n" if ( hex($1) < $AC3D_FILE_VERSION ); } sub parse_roc { my $items = shift; return [ [ $items->[1], $items->[2], $items->[3] ], [ $items->[4], $items->[5], $items->[6] ], [ $items->[7], $items->[8], $items->[9] ] ]; } sub parse_value { my $items = shift; return $items->[1]; } sub parse_name { my $items = shift; $last_name = $items->[1]; return $items->[1]; } sub parse_texrep { my $items = shift; return { x => $items->[1], y => $items->[2] }; } # 12/05/2013 - added sub parse_texoff { my $items = shift; return { x => $items->[1], y => $items->[2] }; } sub parse_surf { my $items = shift; my $param = hex( $items->[1] ); my $type = $param & 0xF; my $types = { 0 => 'polygon', 1 => 'closedline', 2 => 'line' }; my $shading_sides = $param >> 4; my $shading = $shading_sides & 0x1 ? 'smooth' : 'flat'; my $sides = $shading_sides & 0x2 ? 2 : 1; my $result = { type => $types->{$type}, shading => $shading, sides => $sides, }; return $result; } # 12/05/2013 - my 'understanding' is just take the next line, BUT if # given a large 'len' could maybe be several lines, but what exactly is # the spec on this? sub parse_data { my $items = shift; my $len = $items->[1]; my $next = parse_line(); # TODO: if $strict_ac3d could check the length of the following line = len my $result = { data => $next }; return $result; } sub parse_mat { my $items = shift; my $index = $items->[1]; # TODO: if $strict_ac3d could check the index is within range return $world->{MATERIAL}->[$index]; } sub parse_loc { my $items = shift; # TODO: if $strict_ac3d could check it is 3 floats return vec3( $items->[1], $items->[2], $items->[3] ); } sub parse_numvert { my $items = shift; my $numverts = $items->[1]; my @vertices = (); # TODO: if $strict_ac3d could check it is 3 floats for ( 1 .. $numverts ) { my $itm = parse_line(); push @vertices, vec3( $itm->[0], $itm->[1], $itm->[2] ); } my $cnt = scalar @vertices; warn "parse_numvert: collected $cnt vertices ($numverts)\n" if ($show_parse_numvert); return \@vertices; } sub parse_refs { my $items = shift; my $numrefs = $items->[1]; # TODO: since source expects just 3 refs, perhaps normals calculation # also needs to be 'fixed' if this is off! if ($strict_triangluation) { die("model is not triangulated: $last_name numrefs=$numrefs\n") if ( $numrefs != 3 ); } my @indices = (); # TODO: if $strict_ac3d could check it is integer, in range, and 2 floats for ( 1 .. $numrefs ) { my $items = parse_line(); push @indices, { index => $items->[0], u => $items->[1], v => $items->[2] }; } return \@indices; } # SURF 0x10 # mat 1 # refs 3 # 1 0.8 1 # 0 1 1 # 5 0.8 0 sub parse_surface { my $items = shift; my $surface = {}; # TODO: if $strict_ac3d could check opcode order, and # index into vertices is valid! while ( my $items = parse_line() ) { my $opcode = $items->[0]; if ( exists( $TOKENIZER->{$opcode} ) ) { $surface->{$opcode} = $TOKENIZER->{$opcode}($items); } else { my $line = join(" ",@{$items}); prtw("WARNING: $.: parse_surface: unrecognised opcode [$opcode] in '$line'\n"); } last if ( $surface->{refs} ); } return $surface; } sub parse_numsurf { my $items = shift; my $numsurfs = $items->[1]; my @surfaces = (); for ( 1 .. $numsurfs ) { push @surfaces, parse_surface($items); } return \@surfaces; } sub parse_kids { my $items = shift; my $amount = $items->[1]; my @objects = (); warn "parse_kids: $amount...\n" if ($show_parse_kid && $amount); for ( 1 .. $amount ) { my $items = parse_line(); push @objects, parse_object($items); } warn "parse_kids: $amount done\n" if ($show_parse_kid && $amount); return \@objects; } sub parse_object { my $items = shift; my $type = $items->[1]; my $object = {}; my $error; $last_name = ''; $object->{type} = $type; while ( my $items = parse_line() ) { my $opcode = $items->[0]; if ( exists( $TOKENIZER->{$opcode} ) ) { $object->{$opcode} = $TOKENIZER->{$opcode}($items); $error = $@ if ($@); } else { $error = join(" ",@{$items}); prtw("WARNING: $.: parse_object: unrecognised opcode [$opcode] in '$error'\n"); } last if ( $opcode eq 'kids' ); } if ($show_objects && defined $object->{numvert}) { prt("parsed object: "); prt("$object->{name} ") if (defined $object->{name}); prt("type: $type "); prt("vertices: ".int( @{ $object->{numvert} } )." ") if (defined $object->{numvert}); prt("surfaces: ".int( @{ $object->{numsurf} } )." ") if (defined $object->{numsurf}); prt("\n"); } #if (defined $object->{name} && defined $object->{numvert}) { # warn "parsed object: $object->{name}, type: $type, vertices: " # . int( @{ $object->{numvert} } ) . "\n" if ($show_objects); #} return $object; } sub parse_material { my $items = shift; # TODO: if $strict_ac3d could check length, and verify tokens return { name => $items->[1], rgb => [ $items->[3], $items->[4], $items->[5] ], amb => [ $items->[7], $items->[8], $items->[9] ], emis => [ $items->[11], $items->[12], $items->[13] ], spec => [ $items->[15], $items->[16], $items->[17] ], shi => $items->[19], trans => $items->[21], }; } sub parse { while ( my $items = parse_line() ) { my $command = $items->[0]; if ( exists( $TOKENIZER->{$command} ) ) { push @{ $world->{$command} }, $TOKENIZER->{$command}($items); } else { my $line = join(" ",@{$items}); prtw("WARNING: $.: parse: unrecognised command [$command] in '$line'\n"); } } return $world; } # find lowest and highest vertex index sub get_min_max_count_index { my $object = shift; my $min_index = 0xffffffff; my $max_index = 0; my $index_count = 0; my ($ind,$surface,$ref); foreach $surface ( @{ $object->{numsurf} } ) { foreach $ref ( @{ $surface->{refs} } ) { $ind = $ref->{index}; $max_index = $ind if ( $max_index < $ind ); $min_index = $ind if ( $min_index > $ind ); $index_count++; } } return ( $min_index, $max_index, $index_count ); } sub trim_double($) { my $d = shift; while ($d =~ /0$/) { $d =~ s/0$//; } $d =~ s/\.$//; return $d; } # ================================================================================= ################################################################################### # my three.js replacement fucntions ################################################################################### sub write_js2 { my ($cnt,$i,$itm,@arr,$filename,$face_flag); my $QuadBit = 1; # isBitSet( $type, 0 ); my $MatBit = 2; # isBitSet( $type, 1 ); my $FUvBit = 4; # isBitSet( $type, 2 ); my $VUvBit = 8; # isBitSet( $type, 3 ); my $FNorms = 16; # isBitSet( $type, 4 ); my $VNorms = 32; # isBitSet( $type, 5 ); my $FColor = 64; # isBitSet( $type, 6 ); my $VColor = 128; # isBitSet( $type, 7 ); if (length($json_file)) { $filename = $json_file; } else { $filename = $temp_dir.$PATH_SEP."temp.$scene_basename.js"; } open( $geofile, ">$filename" ) || die("cannot write to $filename\n"); ###warn "writing to: $filename\n"; my $vertcnt = scalar @VERTICES; my $normcnt = scalar @NORMALS; my $surfcnt = scalar @INDPERSURF; my $json = "{\n"; $json .= "\n" if ($add_line_sep); $json .= "\t\"metadata\" : {\n"; $json .= "\t\t\"formatVersion\" : 3.1,\n"; $json .= "\t\t\"generatedBy\" : \"ac3d2threejs.pl $VERSION\",\n"; $json .= "\t\t\"vertices\" : $vertcnt,\n"; $json .= "\t\t\"faces\" : $surfcnt,\n"; $json .= "\t\t\"normals\" : $normcnt,\n"; $json .= "\t\t\"colors\" : 0,\n"; $json .= "\t\t\"uvs\" : [],\n"; $json .= "\t\t\"materials\" : 0,\n"; ### $json .= "\t\t\"materials\" : 1,\n"; $json .= "\t\t\"morphTargets\" : 0,\n"; $json .= "\t\t\"bones\" : 0\n"; $json .= "\t},\n"; $json .= "\n" if ($add_line_sep); $json .= "\t\"scale\" : 1.000000,\n"; $json .= "\n" if ($add_line_sep); $json .= "\t\"vertices\" : ["; for ($i = 0; $i < $vertcnt; $i++) { my $vertex = $VERTICES[$i]; $json .= trim_double($vertex->x); $json .= ','; $json .= trim_double($vertex->y); $json .= ','; $json .= trim_double($vertex->z); $json .= "," if (($i + 1) < $vertcnt); } $json .= "],\n"; $json .= "\n" if ($add_line_sep); $json .= "\t\"morphTargets\" : [],\n"; $json .= "\n" if ($add_line_sep); # Normals - positions magic = 1 $json .= "\t\"normals\" : ["; for ($i = 0; $i < $normcnt; $i++) { my $normal = $NORMALS[$i]; next if (!defined $normal); $json .= $normal->x; $json .= ','; $json .= $normal->y; $json .= ','; $json .= $normal->z; $json .= ',' if (($i + 1) < $normcnt); } $json .= "],\n"; $json .= "\n" if ($add_line_sep); $json .= "\t\"colors\" : [],\n"; $json .= "\n" if ($add_line_sep); $json .= "\t\"uvs\" : [],\n"; $json .= "\n" if ($add_line_sep); $face_flag = $QuadBit; $face_flag += $MatBit; $face_flag += $VNorms if ($normcnt > 0); my ($tmp,$cnt2,$j,$k); my ($ind,$emsg); $json .= "\t\"faces\" : ["; for ($i = 0; $i < $surfcnt; $i++) { $tmp = $INDPERSURF[$i]; $json .= ',' if ($i); $cnt2 = scalar @{$tmp}; $json .= "$face_flag"; # 35 $k = 0; for ($j = 0; $j < $cnt2; $j++) { $ind = ${$tmp}[$j]; if (($ind < 0)||($ind >= $vertcnt)) { $emsg .= "$i:$j: V $ind/$vertcnt "; $ind = $vertcnt - 1; } $json .= ",$ind"; $k++; last if ($k == 4); } while ($k < 4) { $json .= ',0'; $k++; } $json .= ',0'; $k = 0; if ($normcnt > 0) { for ($j = 0; $j < $cnt2; $j++) { $ind = ${$tmp}[$j]; if (($ind < 0)||($ind >= $normcnt)) { $emsg .= "$i:$j: N $ind/$normcnt "; $ind = $normcnt - 1; } $json .= ",$ind"; $k++; last if ($k == 4); } while ($k < 4) { $json .= ',0'; $k++; } } } $json .= "],\n"; prtw("WARNING: Out of range index: $emsg\n") if (length($emsg) && $show_out_of_range); $json .= "\n" if ($add_line_sep); $json .= "\t\"bones\" : [],\n"; $json .= "\n" if ($add_line_sep); $json .= "\t\"skinIndices\" : [],\n"; $json .= "\n" if ($add_line_sep); $json .= "\t\"skinWeights\" : [],\n"; $json .= "\n" if ($add_line_sep); $json .= "\t\"animation\" : {}"; $json .= "\n"; $json .= "\n" if ($add_line_sep); $json .= "}\n"; print $geofile $json; close($geofile); prt("Three.js json written to [$filename]\n"); } sub write_object2 { my $object = shift; my $tag = ''; my $params = {}; if ( $object->{loc} ) { $params->{tx} = $object->{loc}->x; $params->{ty} = $object->{loc}->y; $params->{tz} = $object->{loc}->z; } if ( $object->{type} eq 'world' ) { $tag = 'Group'; $params->{name} = 'world'; } elsif ( $object->{type} eq 'group' ) { $tag = 'Model'; $params->{name} = $object->{name}; $params->{geometry} = "$scene_basename/$scene_basename.geo"; $object->{in_model} = 1; } elsif ( $object->{type} eq 'poly' ) { if ( !$object->{in_model} ) { # whoops not in a model yet, create one first my %wrapper = %$object; $wrapper{kids} = [$object]; $wrapper{type} = 'group'; delete $object->{loc}; # set location for model in this case write_object2( \%wrapper ); return; } else { $tag = 'Mesh'; calc_vertex_normals($object); ### warn Dumper($object); ### my $material = basename( $object->{texture} ) || 'standard'; my $material = 'standard'; if (defined $object->{texture} ) { $material = basename( $object->{texture} ); } $params->{material} = "$scene_basename/$material.material.xml"; $params->{name} = $object->{name}; my ( $min_index, $max_index, $index_count ) = get_min_max_count_index($object); $params->{vertRStart} = $min_index + $index_offset; $params->{vertREnd} = $max_index + $index_offset; $params->{batchCount} = $index_count; $params->{batchStart} = $batch_offset; push @VERTICES, @{ $object->{numvert} }; push @NORMALS, @{ $object->{normals} }; ##push @TANGENTS, @{ $object->{tangents} }; ##push @BITANGENTS, @{ $object->{bitangents} }; ##push @TCOORDS0, @{ $object->{tcoords} }; # @INDPERSURF my @inds = (); foreach my $surface ( @{ $object->{numsurf} } ) { @inds = (); foreach my $ref ( @{ $surface->{refs} } ) { push @INDICES, $ref->{index} + $index_offset; push @inds, $ref->{index} + $index_offset; } push(@INDPERSURF, [@inds]); # keep on a per face basis } $index_offset += int( @{ $object->{numvert} } ); $batch_offset += $index_count; } } my $attributes = ''; foreach my $key ( sort keys(%$params) ) { $attributes .= qq~ $key="$params->{$key}"~; } ##print $scenefile qq~<$tag$attributes>\n~; ###print qq~<$tag$attributes>\n~; foreach my $kid ( @{ $object->{kids} } ) { $kid->{in_model} = $object->{in_model}; write_object2($kid); } ###print qq~</$tag>\n~; ###print $scenefile qq~</$tag>\n~; delete $object->{kids}; } sub write_object { my $tree = shift; write_object2( $tree->{OBJECT}->[0] ); } # ================================================================================= ################################################################################### sub uv_sub { my $uv1 = shift; my $uv2 = shift; return { u => $uv1->{u} - $uv2->{u}, v => $uv1->{v} - $uv2->{v} }; } # find vertices with same coordinates, this is for normal smoothing, return of list of matching indices sub find_same_vertices { my $object = shift; my $indices_map = shift; my $index = shift; my @indices = (); if (defined $object->{numvert}->[$index] && defined $indices_map) { my $vertex = $object->{numvert}->[$index]; my $vstring = $vertex->as_string; if (defined $indices_map->{ $vstring }) { @indices = @{ $indices_map->{ $vstring } }; push( @indices, $index ) if ( !grep { $_ == $index } @indices ); } } return @indices; } # create map of indices with same vertices sub make_indices_map { my $object = shift; my %indices_map; foreach my $surface ( @{ $object->{numsurf} } ) { # only average out smooth vertex normals next if ( $surface->{SURF}->{shading} ne 'smooth' ); foreach my $ref ( @{ $surface->{refs} } ) { my $v = $object->{numvert}->[ $ref->{index} ]; push @{ $indices_map{ $v->as_string } }, $ref->{index}; } } # warn Dumper(\%indices_map); return \%indices_map; } sub calc_vertex_normals { my $object = shift; my $vcnt = scalar @{ $object->{numvert} }; my $scnt = scalar @{ $object->{numsurf} }; my @normals = (); if (!$add_normals) { warn "no normals: $object->{name} v=$vcnt, s=$scnt\n" if ($show_calc_norms); $object->{normals} = \@normals; return; } warn "calculating normals: $object->{name} v=$vcnt, s=$scnt\n" if ($show_calc_norms); my ($i,$surface,$refs,$index0,$index1,$index2); my ($v0,$v1,$v2); my ($d0,$d1,$v); foreach my $surface ( @{ $object->{numsurf} } ) { $refs = scalar @{ $surface->{refs} }; if ($refs >= 3) { for ($i = 0; $i < $refs; $i++) { $index0 = $surface->{refs}->[$i]->{index}; # wrapping if (($i + 1) >= $refs) { $index1 = $surface->{refs}->[0]->{index}; $index2 = $surface->{refs}->[1]->{index}; } elsif (($i + 2) >= $refs) { $index1 = $surface->{refs}->[$i+1]->{index}; $index2 = $surface->{refs}->[0]->{index}; } else { $index1 = $surface->{refs}->[$i+1]->{index}; $index2 = $surface->{refs}->[$i+2]->{index}; } # get the three vertices $v0 = $object->{numvert}->[$index0]; $v1 = $object->{numvert}->[$index1]; $v2 = $object->{numvert}->[$index2]; # get difference $d0 = $v1 - $v0; $d1 = $v2 - $v0; # get normal $v = ( $d0 x $d1 )->normalized; $normals[$index0] = $v; # store at index } } } $object->{normals} = \@normals; } sub calc_vertex_normals_OLD { my $object = shift; my $vcnt = scalar @{ $object->{numvert} }; my $scnt = scalar @{ $object->{numsurf} }; warn "calculating normals: $object->{name} v=$vcnt, s=$scnt\n" if ($show_calc_norms); my @normals; my @tangents; my @bitangents; my $indices_map = make_indices_map($object); foreach my $surface ( @{ $object->{numsurf} } ) { my $index0 = $surface->{refs}->[0]->{index}; my $index1 = $surface->{refs}->[1]->{index}; my $index2 = $surface->{refs}->[2]->{index}; my $v0 = $object->{numvert}->[$index0]; my $v1 = $object->{numvert}->[$index1]; my $v2 = $object->{numvert}->[$index2]; my $d0 = $v1 - $v0; my $d1 = $v2 - $v0; my $v = ( $d0 x $d1 )->normalized; # # Calculate the normal for this face and add it # to the running sum of normals for each of the # three vertices involved # # and now tangents and bitangents my $Edge0uv = uv_sub( $surface->{refs}->[1], $surface->{refs}->[0] ); my $Edge1uv = uv_sub( $surface->{refs}->[2], $surface->{refs}->[0] ); my $cp = $Edge0uv->{u} * $Edge1uv->{v} - $Edge1uv->{u} * $Edge0uv->{v}; my $r = 0; if ( $cp != 0 ) { $r = 1.0 / $cp; } my $tangent = ( $d0 * $Edge1uv->{v} - $d1 * $Edge0uv->{v} ) * $r; my $bitangent = ( $d1 * $Edge0uv->{u} - $d0 * $Edge1uv->{u} ) * $r; my @indices; push @indices, find_same_vertices( $object, $indices_map, $index0 ); push @indices, find_same_vertices( $object, $indices_map, $index1 ); push @indices, find_same_vertices( $object, $indices_map, $index2 ); foreach my $index (@indices) { $normals[$index] ||= vec3(); $tangents[$index] ||= vec3(); $bitangents[$index] ||= vec3(); $normals[$index] += $v; $tangents[$index] += $tangent; $bitangents[$index] += $bitangent; } } # Normalize and fixup the vertex normal vectors, tangents en bitangents my $numVerts = int( @{ $object->{numvert} } ); for ( my $j = 0 ; $j < $numVerts ; $j++ ) { next if (! defined $normals[$j]); my $n = $normals[$j]->normalized; my $t = $tangents[$j]; # orthogonalize $tangents[$j] = ( $t - $n * ( $n * $t ) )->normalized; $normals[$j] = $n; if ( ( $n x $t ) * $bitangents[$j] < 0 ) { $bitangents[$j] = ( ( $n * -1 ) x $t )->normalized; } else { $bitangents[$j] = ( $n x $t )->normalized; } } $object->{normals} = \@normals; $object->{tangents} = \@tangents; $object->{bitangents} = \@bitangents; } sub round { my $number = shift; return int( $number + .5 * ( $number <=> 0 ) ); } # TODO: Add more command line options sub main { my @av = @_; parse_command(@av); open( $ac3dfile, "<$source" ) || die "cannot open [$source]\n"; $scene_basename = basename($source); my $header = parse_line(); parse_header($header); my $tree = parse(); write_object($tree); write_js2(); $warn_count = scalar @warnings; if ($warn_count) { foreach my $w (@warnings) { prt($w); } } warn "Done file [$source], lines $., exit $warn_count\n"; close($ac3dfile); } sub give_help() { warn "AC3D2Threejs.pl $VERSION - Convert AC3D .ac file to three.js json file.\n"; warn "usage: $pgmname [options] file.ac\n"; warn "options:\n"; warn " --help (-h or -?) = This help and exit.\n"; warn " --norm 0|1 (-n) = Disable/Enable normals generation. (def=$add_normals)\n"; warn " --out file (-o) = Give three.js json output file name.\n"; warn "If no out file given it will default to [".$temp_dir.$PATH_SEP."temp.<ac_base>.js]\n"; prt(" --verb[n] (-v) = Bump [or set] verbosity. def=$verbosity\n"); die "enjoy!\n"; } sub need_arg { my ($arg,@av) = @_; die "ERROR: [$arg] must have a following argument!\n" if (!@av); } sub get_bool($) { my $txt = shift; return 1 if ($txt eq '1'); return 0 if ($txt eq '0'); return 1 if ($txt =~ /on/i); return 0 if ($txt =~ /off/i); return 1 if ($txt =~ /yes/i); return 0 if ($txt =~ /no/i); die "Unable to parse bool 1|0 on|off yes|no from $txt\n"; } sub parse_command() { my (@av) = @_; my ($arg,$sarg); #$arg = scalar @av; #warn "Parsing $arg commands...\n"; while (@av) { $arg = $av[0]; #warn "arg [$arg]\n"; if ($arg =~ /^-/) { $sarg = substr($arg,1); $sarg = substr($sarg,1) while ($sarg =~ /^-/); if (($sarg =~ /^h/)||($sarg =~ /^\?/)) { give_help(); } elsif ($sarg =~ /^n/) { need_arg(@av); shift @av; $sarg = $av[0]; $add_normals = get_bool($sarg); } elsif ($sarg =~ /^o/) { need_arg(@av); shift @av; $json_file = $av[0]; } elsif ($sarg =~ /^v/) { if ($sarg =~ /^v.*(\d+)$/) { $verbosity = $1; } else { while ($sarg =~ /^v/) { $verbosity++; $sarg = substr($sarg,1); } } prt("Verbosity = $verbosity\n") if (VERB1()); } else { die "Unknown arg $arg. Use -h for help\n"; } } else { $source = $arg; warn "Set source to [$source]\n"; } shift @av; } if ($debug_on) { if (length($source) == 0) { $source = $def_file; } } if (length($source) == 0) { die "Need to give AC3D file to convert. Use -h for help\n"; } } # eof - ac3d2threejs.pl