559 lines
11 KiB
Perl
559 lines
11 KiB
Perl
sub BackToForwardSlash
|
|
{
|
|
my( $path ) = shift;
|
|
$path =~ s,\\,/,g;
|
|
return $path;
|
|
}
|
|
|
|
sub RemoveFileName
|
|
{
|
|
my( $in ) = shift;
|
|
$in = &BackToForwardSlash( $in );
|
|
$in =~ s,/[^/]*$,,;
|
|
return $in;
|
|
}
|
|
|
|
sub RemovePath
|
|
{
|
|
my( $in ) = shift;
|
|
$in = &BackToForwardSlash( $in );
|
|
$in =~ s,^(.*)/([^/]*)$,$2,;
|
|
return $in;
|
|
}
|
|
|
|
sub MakeDirHier
|
|
{
|
|
my( $in ) = shift;
|
|
# print "MakeDirHier( $in )\n";
|
|
$in = &BackToForwardSlash( $in );
|
|
my( @path );
|
|
while( $in =~ m,/, ) # while $in still has a slash
|
|
{
|
|
my( $end ) = &RemovePath( $in );
|
|
push @path, $end;
|
|
# print $in . "\n";
|
|
$in = &RemoveFileName( $in );
|
|
}
|
|
my( $i );
|
|
my( $numelems ) = scalar( @path );
|
|
my( $curpath );
|
|
for( $i = $numelems - 1; $i >= 0; $i-- )
|
|
{
|
|
$curpath .= "/" . $path[$i];
|
|
my( $dir ) = $in . $curpath;
|
|
if( !stat $dir )
|
|
{
|
|
# print "mkdir $dir\n";
|
|
mkdir $dir, 0777;
|
|
}
|
|
}
|
|
}
|
|
|
|
sub FileExists
|
|
{
|
|
my $filename = shift;
|
|
my @statresult = stat $filename;
|
|
my $iswritable = @statresult != 0;
|
|
return $iswritable;
|
|
}
|
|
|
|
sub MakeFileWritable
|
|
{
|
|
my $filename = shift;
|
|
if ( &FileExists( $filename ) )
|
|
{
|
|
chmod 0666, $filename || die;
|
|
}
|
|
}
|
|
|
|
sub MakeFileReadOnly
|
|
{
|
|
my $filename = shift;
|
|
chmod 0444, $filename || die;
|
|
}
|
|
|
|
# Run a command and get stdout and stderr to an array
|
|
sub RunCommand
|
|
{
|
|
my $cmd = shift;
|
|
# print STDERR "command: $cmd\n";
|
|
system "$cmd > cmdout.txt 2>&1" || die;
|
|
local( *FILE );
|
|
open FILE, "<cmdout.txt" || die;
|
|
my @output = <FILE>;
|
|
# print STDERR "command output: @output\n";
|
|
close FILE;
|
|
unlink "cmdout.txt" || die;
|
|
return @output;
|
|
}
|
|
|
|
sub PerforceEditOrAdd
|
|
{
|
|
return;
|
|
my $filename = shift;
|
|
my $changelistarg = shift;
|
|
|
|
# Is the file on the client?
|
|
my $cmd = "p4 fstat \"$filename\"";
|
|
my @p4output = &RunCommand( $cmd );
|
|
my $p4output = join "", @p4output;
|
|
if( $p4output =~ m/no such file/ )
|
|
{
|
|
# not on client. . add
|
|
my $cmd = "p4 add $changelistarg $filename";
|
|
my @p4output = &RunCommand( $cmd );
|
|
my $p4output = join "", @p4output;
|
|
if( $p4output =~ m/opened for add/ )
|
|
{
|
|
print $p4output;
|
|
return;
|
|
}
|
|
print "ERROR: $p4output";
|
|
return;
|
|
}
|
|
|
|
# The file is known to be on the client at this point.
|
|
|
|
# Is it open for edit?
|
|
if( $p4output =~ m/action edit/ )
|
|
{
|
|
# Is is open for edit, let's see if it's still different.
|
|
# check for opened files that are not different from the revision in the depot.
|
|
my $cmd = "p4 diff -sr \"$filename\"";
|
|
my @p4output = &RunCommand( $cmd );
|
|
my $outputstring = join "", @p4output;
|
|
# check for empty string
|
|
if( !( $outputstring =~ m/^\s*$/ ) )
|
|
{
|
|
my $cmd = "p4 revert \"$filename\"";
|
|
my @p4output = &RunCommand( $cmd );
|
|
my $outputstring = join "", @p4output;
|
|
print $outputstring;
|
|
return;
|
|
}
|
|
}
|
|
|
|
# check for unopened files that are different from the revision in the depot.
|
|
my $cmd = "p4 diff -se \"$filename\"";
|
|
my @p4output = &RunCommand( $cmd );
|
|
my $outputstring = join "", @p4output;
|
|
# check for empty string
|
|
if( $outputstring =~ m/^\s*$/ )
|
|
{
|
|
&MakeFileReadOnly( $filename );
|
|
return;
|
|
}
|
|
|
|
# We need to edit the file since it is known to be different here.
|
|
my $cmd = "p4 edit $changelistarg \"$filename\"";
|
|
my @p4output = &RunCommand( $cmd );
|
|
|
|
my $line;
|
|
foreach $line ( @p4output )
|
|
{
|
|
if( $line =~ m/not on client/ )
|
|
{
|
|
#print "notonclient...";
|
|
print "ERROR: @p4output\n";
|
|
return;
|
|
}
|
|
if( $line =~ m/currently opened for edit/ )
|
|
{
|
|
return;
|
|
}
|
|
if( $line =~ m/opened for edit/ )
|
|
{
|
|
print $line;
|
|
}
|
|
}
|
|
}
|
|
|
|
sub FileIsWritable
|
|
{
|
|
local( $filename ) = shift;
|
|
local( @statresult ) = stat $filename;
|
|
local( $mode, $iswritable );
|
|
$mode = oct( $statresult[2] );
|
|
$iswritable = ( $mode & 2 ) != 0;
|
|
return $iswritable;
|
|
}
|
|
|
|
sub TouchFile
|
|
{
|
|
my $filename = shift;
|
|
if( !&FileExists( $filename ) )
|
|
{
|
|
if( !open FILE, ">$filename" )
|
|
{
|
|
die;
|
|
}
|
|
close FILE;
|
|
}
|
|
my $now = time;
|
|
local( *FILE );
|
|
utime $now, $now, $filename;
|
|
}
|
|
|
|
sub FileExistsInPerforce
|
|
{
|
|
my $filename = shift;
|
|
my @output = &RunCommand( "p4 fstat $filename" );
|
|
my $line;
|
|
foreach $line (@output)
|
|
{
|
|
if( $line =~ m/no such file/ )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
sub PerforceWriteFile
|
|
{
|
|
my $filename = shift;
|
|
my $filecontents = shift;
|
|
# my $changelistname = shift;
|
|
|
|
# Get the changelist number for the Shader Auto Checkout changelist. Will create the changelist if it doesn't exist.
|
|
# my $changelistnumber = `valve_p4_create_changelist.cmd . \"$changelistname\"`;
|
|
# Get rid of the newline
|
|
# $changelistnumber =~ s/\n//g;
|
|
|
|
# my $changelistarg = "";
|
|
# if( $changelistnumber != 0 )
|
|
# {
|
|
# $changelistarg = "-c $changelistnumber"
|
|
# }
|
|
|
|
# Make the target vcs writable if it exists
|
|
MakeFileWritable( $filename );
|
|
|
|
# Write the file.
|
|
local( *FP );
|
|
open FP, ">$filename";
|
|
print FP $filecontents;
|
|
close FP;
|
|
|
|
# Do whatever needs to happen with perforce for this file.
|
|
# &PerforceEditOrAdd( $filename, $changelistarg );
|
|
}
|
|
|
|
sub WriteFile
|
|
{
|
|
my $filename = shift;
|
|
my $filecontents = shift;
|
|
|
|
# Make the target vcs writable if it exists
|
|
MakeFileWritable( $filename );
|
|
|
|
# Write the file.
|
|
local( *FP );
|
|
open FP, ">$filename";
|
|
print FP $filecontents;
|
|
close FP;
|
|
}
|
|
|
|
sub PrintCleanPerforceOutput
|
|
{
|
|
my $line;
|
|
while( $line = shift )
|
|
{
|
|
if( $line =~ m/currently opened/i )
|
|
{
|
|
next;
|
|
}
|
|
if( $line =~ m/already opened for edit/i )
|
|
{
|
|
next;
|
|
}
|
|
if( $line =~ m/also opened/i )
|
|
{
|
|
next;
|
|
}
|
|
if( $line =~ m/add of existing file/i )
|
|
{
|
|
next;
|
|
}
|
|
print $line;
|
|
}
|
|
}
|
|
|
|
# HACK!!!! Need to pass something in to do this rather than hard coding.
|
|
sub NormalizePerforceFilename
|
|
{
|
|
my $line = shift;
|
|
|
|
# remove newlines.
|
|
$line =~ s/\n//;
|
|
# downcase.
|
|
$line =~ tr/[A-Z]/[a-z]/;
|
|
# backslash to forwardslash
|
|
$line =~ s,\\,/,g;
|
|
|
|
# for inc files HACK!
|
|
$line =~ s/^.*(fxctmp9.*)/$1/i;
|
|
$line =~ s/^.*(vshtmp9.*)/$1/i;
|
|
|
|
# for vcs files. HACK!
|
|
$line =~ s,^.*game/hl2/shaders/,,i;
|
|
|
|
return $line;
|
|
}
|
|
|
|
sub MakeSureFileExists
|
|
{
|
|
local( $filename ) = shift;
|
|
local( $testexists ) = shift;
|
|
local( $testwrite ) = shift;
|
|
|
|
local( @statresult ) = stat $filename;
|
|
if( !@statresult && $testexists )
|
|
{
|
|
die "$filename doesn't exist!\n";
|
|
}
|
|
local( $mode, $iswritable );
|
|
$mode = oct( $statresult[2] );
|
|
$iswritable = ( $mode & 2 ) != 0;
|
|
if( !$iswritable && $testwrite )
|
|
{
|
|
die "$filename isn't writable!\n";
|
|
}
|
|
}
|
|
|
|
sub LoadShaderListFile_GetShaderType
|
|
{
|
|
my $shadername = shift;
|
|
my $shadertype;
|
|
if( $shadername =~ m/\.vsh/i )
|
|
{
|
|
$shadertype = "vsh";
|
|
}
|
|
elsif( $shadername =~ m/\.psh/i )
|
|
{
|
|
$shadertype = "psh";
|
|
}
|
|
elsif( $shadername =~ m/\.fxc/i )
|
|
{
|
|
$shadertype = "fxc";
|
|
}
|
|
else
|
|
{
|
|
die;
|
|
}
|
|
return $shadertype;
|
|
}
|
|
|
|
sub LoadShaderListFile_GetShaderSrc
|
|
{
|
|
my $shadername = shift;
|
|
if ( $shadername =~ m/^(.*)-----/i )
|
|
{
|
|
return $1;
|
|
}
|
|
else
|
|
{
|
|
return $shadername;
|
|
}
|
|
}
|
|
|
|
sub LoadShaderListFile_GetShaderBase
|
|
{
|
|
my $shadername = shift;
|
|
if ( $shadername =~ m/-----(.*)$/i )
|
|
{
|
|
return $1;
|
|
}
|
|
else
|
|
{
|
|
my $shadertype = &LoadShaderListFile_GetShaderType( $shadername );
|
|
$shadername =~ s/\.$shadertype//i;
|
|
return $shadername;
|
|
}
|
|
}
|
|
|
|
sub LoadShaderListFile
|
|
{
|
|
my $inputbase = shift;
|
|
|
|
my @srcfiles;
|
|
&MakeSureFileExists( "$inputbase.txt", 1, 0 );
|
|
|
|
open SHADERLISTFILE, "<$inputbase.txt" || die;
|
|
my $line;
|
|
while( $line = <SHADERLISTFILE> )
|
|
{
|
|
$line =~ s/\/\/.*$//; # remove comments "//..."
|
|
$line =~ s/^\s*//; # trim leading whitespace
|
|
$line =~ s/\s*$//; # trim trailing whitespace
|
|
next if( $line =~ m/^\s*$/ );
|
|
if( $line =~ m/\.fxc/ || $line =~ m/\.vsh/ || $line =~ m/\.psh/ )
|
|
{
|
|
my $shaderbase = &LoadShaderListFile_GetShaderBase( $line );
|
|
|
|
if( $ENV{"DIRECTX_FORCE_MODEL"} =~ m/^30$/i ) # forcing all shaders to be ver. 30
|
|
{
|
|
my $targetbase = $shaderbase;
|
|
$targetbase =~ s/_ps2x/_ps30/i;
|
|
$targetbase =~ s/_ps20b/_ps30/i;
|
|
$targetbase =~ s/_ps20/_ps30/i;
|
|
$targetbase =~ s/_vs20/_vs30/i;
|
|
$targetbase =~ s/_vsxx/_vs30/i;
|
|
push @srcfiles, ( $line . "-----" . $targetbase );
|
|
}
|
|
else
|
|
{
|
|
if( $shaderbase =~ m/_ps2x/i )
|
|
{
|
|
my $targetbase = $shaderbase;
|
|
$targetbase =~ s/_ps2x/_ps20/i;
|
|
push @srcfiles, ( $line . "-----" . $targetbase );
|
|
|
|
$targetbase = $shaderbase;
|
|
$targetbase =~ s/_ps2x/_ps20b/i;
|
|
push @srcfiles, ( $line . "-----" . $targetbase );
|
|
}
|
|
elsif( $shaderbase =~ m/_vsxx/i )
|
|
{
|
|
my $targetbase = $shaderbase;
|
|
$targetbase =~ s/_vsxx/_vs11/i;
|
|
push @srcfiles, ( $line . "-----" . $targetbase );
|
|
|
|
$targetbase = $shaderbase;
|
|
$targetbase =~ s/_vsxx/_vs20/i;
|
|
push @srcfiles, ( $line . "-----" . $targetbase );
|
|
}
|
|
else
|
|
{
|
|
push @srcfiles, ( $line . "-----" . $shaderbase );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
close SHADERLISTFILE;
|
|
return @srcfiles;
|
|
}
|
|
|
|
sub ReadInputFileWithIncludes
|
|
{
|
|
local( $filename ) = shift;
|
|
# print STDERR "ReadInputFileWithIncludes: $filename\n";
|
|
|
|
local( *INPUT );
|
|
local( $output );
|
|
|
|
# print STDERR "before open\n";
|
|
open INPUT, "<$filename" || die;
|
|
# print STDERR "after open\n";
|
|
|
|
local( $line );
|
|
while( $line = <INPUT> )
|
|
{
|
|
# print STDERR $line;
|
|
if( $line =~ m/\#include\s+\"(.*)\"/i )
|
|
{
|
|
$output.= ReadInputFileWithIncludes( $1 );
|
|
}
|
|
else
|
|
{
|
|
$output .= $line;
|
|
}
|
|
}
|
|
|
|
close INPUT;
|
|
return $output;
|
|
}
|
|
|
|
sub GetCRCFromSourceFile
|
|
{
|
|
my $filename = shift;
|
|
my $data = &ReadInputFileWithIncludes( $filename );
|
|
# print STDERR $data;
|
|
$crc = crc32( $data );
|
|
# print STDERR "GetCRCFromSourceFile: $crc\n";
|
|
return $crc;
|
|
}
|
|
|
|
sub GetCRCFromVCSFile
|
|
{
|
|
my $filename = shift;
|
|
# print STDERR "GetCRCFromVCSFile $filename\n";
|
|
local( *FP );
|
|
open FP, "<$filename" || die "GetCRCFromVCSFile: can't open file $filename\n";
|
|
binmode( FP );
|
|
|
|
# unpack arguments
|
|
my $sInt = "i";
|
|
my $uInt = "I";
|
|
if( $filename =~ m/\.360\./ )
|
|
{
|
|
# Change arguments to "big endian long"
|
|
$sInt = "N";
|
|
$uInt = "N";
|
|
}
|
|
|
|
my $header;
|
|
read FP, $header, 7 * 4 || die "updateshaders.pl:GetCRCFromVCSFile: can't read header for $filename\n";
|
|
my $version,$numCombos,$numDynamicCombos,$flags,$centroidMask,$refSize,$crc;
|
|
($version,$numCombos,$numDynamicCombos,$flags,$centroidMask,$refSize,$crc) = unpack "$sInt$sInt$sInt$uInt$uInt$uInt$uInt", $header;
|
|
unless( $version == 4 || $version == 5 || $version == 6 )
|
|
{
|
|
print STDERR "ERROR: GetCRCFromVCSFile: $filename is version $version\n";
|
|
return 0;
|
|
}
|
|
# print STDERR "version: $version\n";
|
|
# print STDERR "numCombos: $numCombos\n";
|
|
# print STDERR "numDynamicCombos: $numDynamicCombos\n";
|
|
# print STDERR "flags: $flags\n";
|
|
# print STDERR "centroidMask: $centroidMask\n";
|
|
# print STDERR "refSize: $refSize\n";
|
|
# print STDERR "GetCRCFromVCSFile: $crc\n";
|
|
close( FP );
|
|
return $crc;
|
|
}
|
|
|
|
sub CheckCRCAgainstTarget
|
|
{
|
|
my $srcFileName = shift;
|
|
my $vcsFileName = shift;
|
|
my $warn = shift;
|
|
|
|
# Make sure both files exist.
|
|
# print STDERR "$srcFileName doesn't exist\n" if( !( -e $srcFileName ) );
|
|
# print STDERR "$vcsFileName doesn't exist\n" if( !( -e $vcsFileName ) );
|
|
if( !( -e $srcFileName ) )
|
|
{
|
|
if( $warn )
|
|
{
|
|
print "$srcFileName missing\n";
|
|
}
|
|
return 0;
|
|
}
|
|
if( !( -e $vcsFileName ) )
|
|
{
|
|
if( $warn )
|
|
{
|
|
print "$vcsFileName missing\n";
|
|
}
|
|
return 0;
|
|
}
|
|
# print STDERR "CheckCRCAgainstTarget( $srcFileName, $vcsFileName );\n";
|
|
# print STDERR "vcsFileName: $vcsFileName\n";
|
|
# print STDERR "vcsFileName: $srcFileName\n";
|
|
my $vcsCRC = &GetCRCFromVCSFile( $vcsFileName );
|
|
my $srcCRC = &GetCRCFromSourceFile( $srcFileName );
|
|
if( $warn && ( $vcsCRC != $srcCRC ) )
|
|
{
|
|
print "$vcsFileName checksum ($vcsCRC) != $srcFileName checksum: ($srcCRC)\n";
|
|
}
|
|
|
|
# return 0; # use this to skip crc checking.
|
|
# if( $vcsCRC == $srcCRC )
|
|
# {
|
|
# print STDERR "CRC passed for $srcFileName $vcsFileName $vcsCRC\n";
|
|
# }
|
|
return $vcsCRC == $srcCRC;
|
|
}
|
|
|
|
1;
|