tools/assignVertexShaderConstants.pl

   1 #!/perl/bin
   2
   3 die "usage: perl assignVertexShaderConstants.pl input_template hlsl.inc dx.inc shaderBuilder.inc\n" if (@ARGV != 4);
   4
   5 my $register = 0;
   6
   7 # define the sizes of some intrinsic types
   8 my %size;
   9 $size{"float"}    = 1;
  10 $size{"float2"}   = 1;
  11 $size{"float3"}   = 1;
  12 $size{"float4"}   = 1;
  13 $size{"float4x4"} = 4;
  14
  15 # open all the files
  16 open(INPUT, shift);
  17 open(HLSL, ">".shift);
  18 open(CPP, ">".shift);
  19 open(SB, ">".shift);
  20
  21 while (<INPUT>)
  22 {
  23         chomp;
  24
  25         if (/^struct/)
  26         {
  27                 # begin recording information about a struct
  28                 print HLSL "$_\n";
  29                 s/^struct\s+//;
  30                 $struct = $_;
  31         }
  32         elsif ($struct ne "" && /^};/ )
  33         {
  34                 # end recording information about a struct
  35                 print HLSL "$_\n";
  36                 undef $struct;
  37         }
  38         elsif (/^\/\// || /^#pragma/ || /^{/ || /^\s*$/)
  39         {
  40                 # copy any comments, pragmas, open curly braces, or blank lines
  41                 print HLSL "$_\n";
  42         }
  43         elsif (/^static const int /)
  44         {
  45                 # record global integer values for array sizes
  46                 print HLSL "$_\n";
  47                 s/^static const int //;
  48                 s/;//;
  49                 s/=//;
  50                 ($variable, $value) = split;
  51                 $variable{$variable} = $value;
  52         }
  53         else
  54         {
  55                 # assume this is a global variable or structure member
  56                 s/;//;
  57
  58                 my $array = 0;
  59                 my $count = 1;
  60
  61                 if (/\[(.+)\]/)
  62                 {
  63                         if (defined $variable{$1})
  64                         {
  65                                 $count = $variable{$1};
  66                         }
  67                         else
  68                         {
  69                                 $count = $1;
  70                         }
  71                         $array = 1;
  72                 }
  73
  74                 ($type, $variable) = split;
  75
  76                 die "unknown size for $type\n" if (!defined $size{$type});
  77
  78                 if (defined $struct)
  79                 {
  80                         print HLSL "$_;\n";
  81                         $size{$struct} += $size{$type} * $count;
  82
  83                         @array = ( "" );
  84                         @array = (0 .. $count-1) if ($array);
  85                         $variable =~ s/\[.*//;
  86
  87                         foreach $index (@array)
  88                         {
  89                                 # handle structure members
  90
  91                                 $index = "[$index]" if ($index ne "");
  92                                 if (defined $members{$type})
  93                                 {
  94                                         my @members = split (/\s+/, $members{$type});
  95                                         while (@members)
  96                                         {
  97                                                 my $member = shift @members;
  98                                                 my $size = shift @members;
  99                                                 $members{$struct} .= " " if (defined $members{$struct});
 100                                                 $members{$struct} .= "$variable$index.$member $size";
 101                                         }
 102                                 }
 103                                 else
 104                                 {
 105                                         $members{$struct} .= " " if (defined $members{$struct});
 106                                         $members{$struct} .= "$variable$index $size{$type}";
 107                                 }
 108                         }
 109                 }
 110                 else
 111                 {
 112                         # handle global variables
 113
 114                         s/;//;
 115
 116                         if (defined $members{$type})
 117                         {
 118                                 # emit registers for all the stucture members
 119                                 my $offset = 0;
 120                                 my @members = split (/\s+/, $members{$type});
 121                                 while (@members)
 122                                 {
 123                                         my $member = shift @members;
 124                                         print SB "\t\taddConstantRegister(\"$variable.$member\", ", $register + $offset, ");\n";
 125                                         $offset += shift @members;
 126                                 }
 127                         }
 128                         else
 129                         {
 130                                 # emit register for the variable
 131                                 print SB "\t\taddConstantRegister(\"$variable\", $register);\n";
 132                         }
 133
 134                         print CPP "\tVSCR_$variable = $register,\n";
 135                         print HLSL "$_ : register(c$register);\n";
 136                         $register += $size{$type} * $count;
 137                 }
 138         }
 139 }
 140
 141 print CPP "\tVSCR_MAX", " = $register\n";
 142
 143 close(INPUT);
 144 close(HLSL);
 145 close(CPP);
 146 close(SB);
 147