ResourceMarket::ResourceMarket() {
this->coal = Coal(20);
this->oil = Oil(15);
this->garbage = Garbage(10);
this->uranium = Uranium(5);
}
static FUNC *ConvertTransform( FUNC *func, EDAT xform[16] )
{
int d, which ;
FUNC *loop ;
static EDAT gnew[16] = ZERO_EDAT_16 ;
EXPR *arg, *expr ;
MatrixMultiInit(4) ;
for( loop = func ; loop ; loop = OpticForward( FuncNext(loop) ) )
{
which = (int) ( ExprValue( FuncArg( loop, 0 ) ) + 0.49 ) ;
if( which > 5 ) /* surface */
break ;
arg = Copy( FuncArg( loop, 1 ) ) ;
if( FuncIsReversed( loop ) )
arg = Ecc( arg, "u-", Garbage() ) ;
MatrixIdentity( 4, gnew ) ;
if( which < 3 )
gnew[ RC( which, 3 ) ].E = ECc( arg, "u-", Garbage() ) ;
else
{
d = which - 3 ;
expr = ECc( arg, "cos", Garbage() ) ;
gnew[ RC( (d+1)%3, (d+1)%3 ) ].E = Copy( expr ) ;
gnew[ RC( (d+2)%3, (d+2)%3 ) ].E = expr ;
expr = ECc( arg, "sin", Garbage() ) ;
gnew[ RC( (d+1)%3, (d+2)%3 ) ].E = Copy( expr ) ;
expr = Ecc( expr, "u-", Garbage() ) ;
gnew[ RC( (d+2)%3, (d+1)%3 ) ].E = expr ;
}
Free( arg ) ;
MatrixMultiNew( 4, gnew ) ;
MatrixZero( 4, gnew ) ; /* free it up */
}
MatrixMultiResult( 4, xform ) ;
MatrixMultiInit(4) ;
return loop ;
}
static FUNC *ConvertSurface( FUNC *func, OPTIC *optic )
{
FUNC *loop ;
EXPR *EA0, *separate ;
int ea0used, which, rev ;
optic->terms[ TERM_MAT ].E = Copy( MatGet() ) ;
optic->terms[ TERM_TEMP ].E = Copy( MatGetTemp() ) ;
for( loop = func ; loop ; loop = OpticForward( FuncNext(loop) ) )
{
which = (int) ( ExprValue( FuncArg( loop, 0 ) ) + 0.49 ) ;
if( which < 6 )
break ;
EA0 = Copy( FuncArg( loop, 1 ) ) ;
ea0used = 0 ;
switch( which )
{
case 6: /* INDX */
if( FuncArgCount( loop ) == 4 )
{
MatPush( EA0, FuncArg( loop, 2 ),
FuncIsReversed( loop ) ) ;
optic->mutant = 1 ;
(optic - 1)->mutant = -1 ; /* kludge-o-rama */
optic->terms[TERM_MUTANT].E = Copy( FuncArg( loop, 3 ) ) ;
}
else
if( FuncArgCount( loop ) == 3 )
{
MatPush( EA0, FuncArg( loop, 2 ),
FuncIsReversed( loop ) ) ;
}
else
if( FuncArgCount( loop ) == 2 )
{
MatPush( EA0, Label( "MatTemperature" ),
FuncIsReversed( loop ) ) ;
}
break ;
case 7: /* PARAX */
optic->terms[TERM_FOCLEN].E = EA0 ;
optic->function |= FUNCTION_PARAX ;
ea0used = 1 ;
break ;
case 8: /* MIRROR */
optic->function |= FUNCTION_MIRROR ;
break ;
case 9: /* GRATING */
optic->function |= FUNCTION_GRATING ;
optic->terms[TERM_LINES].E = EA0 ;
optic->terms[TERM_ORDER].E = Copy( FuncArg( loop, 2 ) ) ;
ea0used = 1 ;
break ;
case 10: /* VIEW */
optic->function |= FUNCTION_VIEW ;
break ;
case 11: /* STOP */
if( FuncArgCount( loop ) == 1 ) /* EXIT */
optic->function |= FUNCTION_EXIT ;
else
if( FuncArgCount( loop ) == 7 ) /* STOP */
{
int i ;
EDAT *S ;
if( optic->StopCount == NSTOPS )
{
IOerror( IO_ERR, "ConvertSurface", "too many stops" ) ;
failed = 1 ;
break ;
}
S = &optic->terms[ TERM_STOPS + 6 * optic->StopCount ] ;
for( i = 0 ; i < 6 ; i++ )
S[i].E = Copy( FuncArg( loop, i + 1 ) ) ;
optic->StopCount++ ;
}
break ;
case 12: /* PDIST */
if( FuncIsReversed( loop ) )
optic->terms[TERM_PDIST].E = Ecc( EA0, "u-", Garbage() ) ;
else
optic->terms[TERM_PDIST].E = EA0 ;
optic->function |= FUNCTION_PDIST ;
ea0used = 1 ;
break ;
case 13: /* PRINT */
break ;
case 14: /* LABEL */
separate = String( " & " ) ;
if( optic->terms[ TERM_LABEL ].E )
{
optic->terms[ TERM_LABEL ].E = Ecc(
optic->terms[ TERM_LABEL ].E, "//", separate ) ;
optic->terms[ TERM_LABEL ].E = Ecc(
optic->terms[ TERM_LABEL ].E, "//", EA0 ) ;
}
else
optic->terms[ TERM_LABEL ].E = EA0 ;
ea0used = 1 ;
break ;
case 15: /* SURF */
rev = ( FuncIsReversed( loop ) ? -1 : 1 ) ;
if( optic->reverse != rev )
{
if( !optic->reverse )
optic->reverse = rev ;
else
{
IOerror( IO_ERR, "ConvertSurface",
"inconsistent surface reversal on surface #%d",
Surface ) ;
failed = 1 ;
}
}
if( FuncArgCount( loop ) == 4 )
{
optic->surface |= SURFACE_SYMBOLIC ;
optic->terms[TERM_Sx].E = Copy( FuncArg( loop, 1 ) ) ;
optic->terms[TERM_Sy].E = Copy( FuncArg( loop, 2 ) ) ;
optic->terms[TERM_Sf].E = Copy( FuncArg( loop, 3 ) ) ;
if( !ExprIsVariable( optic->terms[TERM_Sx].E ) )
IOerror( IO_ERR, "ConvertSurface", "X not a variable" ) ;
if( !ExprIsVariable( optic->terms[TERM_Sy].E ) )
IOerror( IO_ERR, "ConvertSurface", "Y not a variable" ) ;
break ;
}
optic->terms[TERM_CURV].E = EA0 ;
ea0used = 1 ;
if( FuncArgCount( loop ) == 1 )
optic->surface |= SURFACE_FLAT ;
else
if( FuncArgCount( loop ) == 2 )
optic->surface |= SURFACE_SPHERE ;
else
if( FuncArgCount( loop ) == 3 )
{
optic->surface |= SURFACE_CONIC ;
optic->terms[TERM_CONIC].E = Copy( FuncArg( loop, 2 ) ) ;
}
else /* count = 6 */
{
optic->surface |= SURFACE_ASPHERE ;
optic->terms[TERM_CONIC].E = Copy( FuncArg( loop, 2 ) ) ;
optic->terms[TERM_A4].E = Copy( FuncArg( loop, 3 ) ) ;
optic->terms[TERM_A6].E = Copy( FuncArg( loop, 4 ) ) ;
optic->terms[TERM_A8].E = Copy( FuncArg( loop, 5 ) ) ;
optic->terms[TERM_A10].E = Copy( FuncArg( loop, 6 ) ) ;
}
break ;
case 16: /* TRIX */
rev = ( FuncIsReversed( loop ) ? -1 : 1 ) ;
if( optic->reverse != rev )
{
if( !optic->reverse )
optic->reverse = rev ;
else
{
IOerror( IO_ERR, "ConvertSurface",
"inconsistent surface reversal on surface #%d",
Surface ) ;
failed = 1 ;
}
}
optic->terms[TERM_Ex].E = EA0 ;
optic->terms[TERM_Ey].E = Copy( FuncArg( loop, 2 ) ) ;
optic->terms[TERM_Ez].E = Copy( FuncArg( loop, 3 ) ) ;
optic->terms[TERM_Eo].E = Copy( FuncArg( loop, 4 ) ) ;
optic->surface |= SURFACE_TRIAXIAL ;
ea0used = 1 ;
break ;
case 17: /* MARK */
if( FuncArgCount( loop ) == 2 ) /* surface */
{
optic->terms[TERM_MARK].E = EA0 ;
ea0used = 1 ;
}
else
if( FuncArgCount( loop ) == 3 ) /* variable */
{
if( !ExprIsVariable( FuncArg( loop, 1 ) ) )
{
IOerror( OpticBomb, "ConvertSurface",
"EXPR not a VARIABLE" ) ;
}
ExprSetFlags( FuncArg( loop, 1 ),
(int) ExprValue( FuncArg( loop, 2 ) ) & VAR_OPTIC ) ;
}
break ;
case 18: /* COAT */
if( optic->terms[ TERM_COATING ].E )
{
IOerror( IO_ERR, "ConvertSurface",
"multiple coating declarations on surface %d",
Surface ) ;
failed = 1 ;
}
else
{
optic->terms[ TERM_COATING ].E = EA0 ;
ea0used = 1 ;
}
break ;
case 19: /* BOUND */
break ;
case 20: /* BAFFLE */
optic->function |= FUNCTION_BAFFLE ;
break ;
case 21: /* MERIT */
break ;
case 22: /* APERTURE */
optic->function |= FUNCTION_APERTURE ;
if( aperture_set )
{
IOerror( IO_ERR, "ConvertSurface", "multiple apertures" ) ;
failed = 1 ;
}
aperture_set = 1 ;
break ;
case 23: /* PINHOLE */
optic->function |= FUNCTION_PINHOLE ;
break ;
case 24: /* ORIGIN */
if( origin_set )
{
IOerror( IO_WARN, "ConvertSurface", "multiple origins" ) ;
/* EVIL HACK!!!! */
/* failed = 1 ; */
}
else
{
optic->function |= FUNCTION_ORIGIN ;
origin_set = 1 ;
}
break ;
case 25: /* FRESNEL */
rev = ( FuncIsReversed( loop ) ? -1 : 1 ) ;
if( optic->reverse != rev )
{
if( !optic->reverse )
optic->reverse = rev ;
else
{
IOerror( IO_ERR, "ConvertSurface",
"inconsistent surface reversal on surface #%d",
Surface ) ;
failed = 1 ;
}
}
optic->surface |= SURFACE_FRESNEL ;
optic->terms[TERM_FOCLEN].E = EA0 ;
ea0used = 1 ;
break ;
default:
IOerror( OpticBomb, "ConvertSurface",
"unexpected surface function on surface #%d", Surface ) ;
failed = 1 ;
}
if( !ea0used )
Free( EA0 ) ;
}
if( !Compare( optic->terms[ TERM_MAT ].E, MatGet() ) )
optic->function |= FUNCTION_SNELL ;
return loop ;
}
////////////////////////////////////////////////////////////////////////////////
/// Destructeur
////////////////////////////////////////////////////////////////////////////////
CPathMgr::~CPathMgr()
{
Garbage();
}
