/*
* Implementation
*/
void
LispPackageInit(void)
{
Kinternal = KEYWORD("INTERNAL");
Kexternal = KEYWORD("EXTERNAL");
Kinherited = KEYWORD("INHERITED");
}
ULONG size(ULONG *arg)
{
rsiVECTOR vec;
float begin,end;
int flags = rsiFActionLinear;
if(!actor)
return rsiERR_ACTOR;
begin = (float)atof((char*)arg[0]);
end = (float)atof((char*)arg[1]);
if(!read_vector(&vec,(char*)arg[2]))
return ERROR_VECTOR;
if(arg[3])
{
if(KEYWORD((char*)arg[3], "LINEAR"))
flags |= rsiFActionLinear;
else
if(KEYWORD((char*)arg[3], "SPLINE"))
flags |= rsiFActionSpline;
else
return ERROR_INTERPOL;
}
return rsiSize(CTXT, actor->item,begin,end,&vec,/*rsiTSizeFlags,flags,*/rsiTDone);
}
LispObj *
Lisp_XawCoerceToListReturnStruct(LispBuiltin *builtin)
/*
xaw-coerce-to-list-return-struct opaque
*/
{
LispObj *result, *code, *ocod = COD;
XawListReturnStruct *retlist;
LispObj *opaque;
opaque = ARGUMENT(0);
if (!CHECKO(opaque, xawListReturnStruct_t))
LispDestroy("%s: cannot convert %s to XawListReturnStruct",
STRFUN(builtin), STROBJ(opaque));
retlist = (XawListReturnStruct*)(opaque->data.opaque.data);
GCDisable();
code = CONS(ATOM("MAKE-XAW-LIST-RETURN-STRUCT"),
CONS(KEYWORD("STRING"),
CONS(STRING(retlist->string),
CONS(KEYWORD("INDEX"),
CONS(INTEGER(retlist->list_index), NIL)))));
COD = CONS(code, COD);
GCEnable();
result = EVAL(code);
COD = ocod;
return (result);
}
ULONG csg(ULONG *arg)
{
int operation;
void *csg;
rsiResult err;
err = rsiCreateCSG(CTXT, &csg);
if(err)
return err;
if(arg[0])
{
if(KEYWORD((char*)arg[0], "UNION"))
operation = rsiFCSGUnion;
else
if(KEYWORD((char*)arg[0], "INTERSECTION"))
operation = rsiFCSGIntersection;
else
if(KEYWORD((char*)arg[0], "DIFFERENCE"))
operation = rsiFCSGDifference;
else
return ERROR_CSGOPERATOR;
err = rsiSetCSG(CTXT, csg, rsiTCSGOperator, operation, rsiTDone);
if(err)
return err;
}
if(arg[1])
{
err = rsiSetCSG(CTXT, csg, rsiTCSGFlags, rsiFCSGInverted, rsiTDone);
if(err)
return err;
}
if(insideCSG > 0)
{
SetCSGObject(csg);
insideCSG--;
}
if(!AddCSGItem(csg))
return ERROR_MEM;
insideCSG += 2;
return rsiERR_NONE;
}
LispObj *
Lisp_PQnotifies(LispBuiltin *builtin)
/*
pq-notifies connection
*/
{
LispObj *result, *code, *cod = COD;
PGconn *conn;
PGnotify *notifies;
LispObj *connection;
connection = ARGUMENT(0);
if (!CHECKO(connection, PGconn_t))
LispDestroy("%s: cannot convert %s to PGconn*",
STRFUN(builtin), STROBJ(connection));
conn = (PGconn*)(connection->data.opaque.data);
if ((notifies = PQnotifies(conn)) == NULL)
return (NIL);
GCDisable();
code = CONS(ATOM("MAKE-PG-NOTIFY"),
CONS(KEYWORD("RELNAME"),
CONS(STRING(notifies->relname),
CONS(KEYWORD("BE-PID"),
CONS(REAL(notifies->be_pid), NIL)))));
COD = CONS(code, COD);
GCEnable();
result = EVAL(code);
COD = cod;
free(notifies);
return (result);
}
int f_newsurface(ULONG *arg)
{
int flags = 0;
rsiResult err;
void *surface;
if (KEYWORD(arg[1], "BRIGHT"))
flags |= rsiFSurfBright;
err = rsiCreateSurface(&surface, rsiTSurfFlags, flags, rsiTDone);
if (err)
return err;
if (!arg[0])
return ERROR_SURFACE;
surf = AddSurfList((char*)arg[0], surface);
if (!surf)
return ERROR_MEM;
return rsiERR_NONE;
}
ULONG flare(ULONG *arg)
{
rsiResult err;
rsiCOLOR color;
void *flare;
float f;
int flags;
if (!light)
return ERROR_NOLIGHT;
err = rsiCreateFlare(CTXT, light, &flare);
if (err)
return err;
if (arg[0])
{
f = (float)atof((char*)arg[0])/100;
err = rsiSetFlare(CTXT, flare, rsiTFlarePos, f, rsiTDone);
if (err)
return err;
}
if (arg[1])
{
f = (float)atof((char*)arg[1])/100;
err = rsiSetFlare(CTXT, flare, rsiTFlareRadius, f, rsiTDone);
if (err)
return err;
}
if (arg[2])
{
if (!read_color(&color, (char*)arg[2]))
return ERROR_COLOR;
err = rsiSetFlare(CTXT, flare, rsiTFlareColor, &color, rsiTDone);
if (err)
return err;
}
flags = 0;
if (arg[3])
{
if (KEYWORD(arg[3], "DISC"))
flags |= rsiFFlareDisc;
else
if (KEYWORD(arg[3], "POLYGON"))
flags |= rsiFFlarePoly;
else
return ERROR_FLARETYPE;
}
err = rsiSetFlare(CTXT, flare, rsiTFlareType, flags, rsiTDone);
if (err)
return err;
flags = 0;
if (arg[4])
{
if (KEYWORD(arg[4], "PLAIN"))
flags |= rsiFFlarePlain;
else
if (KEYWORD(arg[4], "RING"))
flags |= rsiFFlareExp;
else
if (KEYWORD(arg[4], "RADIAL"))
flags |= rsiFFlareRadial;
else
if (KEYWORD(arg[4], "EXP1"))
flags |= rsiFFlareExp1;
else
if (KEYWORD(arg[4], "EXP2"))
flags |= rsiFFlareExp2;
else
return ERROR_FLAREFUNC;
}
err = rsiSetFlare(CTXT, flare, rsiTFlareFunc, flags, rsiTDone);
if (err)
return err;
if (arg[5])
{
err = rsiSetFlare(CTXT, flare, rsiTFlareEdges, (int)*(LONG*)arg[5], rsiTDone);
if (err)
return err;
}
if (arg[6])
{
f = (float)atof((char*)arg[6])*PI/180;
err = rsiSetFlare(CTXT, flare, rsiTFlareTilt, f, rsiTDone);
if (err)
return err;
}
return rsiERR_NONE;
}
void
LispRegexInit(void)
{
Knomatch = KEYWORD("NOMATCH");
}
ULONG brush(ULONG *arg)
{
void *brush,*actor;
rsiVECTOR vec;
int flags = 0;
rsiResult err;
if(!surf)
return rsiERR_SURFACE;
err = rsiAddBrush(CTXT, &brush,((char*)arg[0]),surf->item);
if(err)
return err;
if(KEYWORD((char*)arg[1], "COLOR"))
flags = rsiFBrushColor;
else
if(KEYWORD((char*)arg[1], "REFLECT"))
flags = rsiFBrushReflectivity;
else
if(KEYWORD((char*)arg[1], "FILTER"))
flags = rsiFBrushFilter;
else
if(KEYWORD((char*)arg[1], "ALTITUDE"))
flags = rsiFBrushAltitude;
else
if(KEYWORD((char*)arg[1], "SPECULAR"))
flags = rsiFBrushSpecular;
else
return ERROR_BRUSHTYPE;
if(KEYWORD((char*)arg[2], "WRAPX"))
flags |= rsiFBrushWrapX;
else
if(KEYWORD((char*)arg[2], "WRAPY"))
flags |= rsiFBrushWrapY;
else
if(KEYWORD((char*)arg[2], "WRAPXY"))
flags |= rsiFBrushWrapXY;
else
if(!KEYWORD((char*)arg[2], "FLAT"))
return ERROR_BRUSHMETHOD;
if(arg[6])
flags |= rsiFBrushRepeat;
if(arg[7])
flags |= rsiFBrushMirror;
if(arg[8])
flags |= rsiFBrushSoft;
err = rsiSetBrush(CTXT, brush,rsiTBrushFlags,flags,rsiTDone);
if(err)
return err;
if(!read_vector(&vec,(char*)arg[3]))
return ERROR_VECTOR;
err = rsiSetBrush(CTXT, brush,rsiTBrushPos,&vec,rsiTDone);
if(err)
return err;
if(!read_vector(&vec,(char*)arg[4]))
return ERROR_VECTOR;
err = rsiSetBrush(CTXT, brush,rsiTBrushAlign,&vec,rsiTDone);
if(err)
return err;
if(!read_vector(&vec,(char*)arg[5]))
return ERROR_VECTOR;
err = rsiSetBrush(CTXT, brush,rsiTBrushSize,&vec,rsiTDone);
if(err)
return err;
if(arg[9])
{
actor = FindActorListItem((char*)arg[9]);
if(!actor)
return rsiERR_ACTOR;
err = rsiSetBrush(CTXT, brush,rsiTBrushActor,actor,rsiTDone);
if(err)
return err;
}
return rsiERR_NONE;
}
HaxeMessageSyntax::HaxeMessageSyntax()
{
DEFINE_VOID("SpaceChar", RANGE(" \n\r\t"));
DEFINE_VOID("Whitespace", REPEAT(INLINE("SpaceChar")));
specialChar_ =
DEFINE("SpecialChar",
GLUE(
CHAR('&'),
KEYWORD("gt lt"),
CHAR(';')
)
);
gt_ = keywordByName("gt");
lt_ = keywordByName("lt");
value_ =
DEFINE("Value",
REPEAT(1,
CHOICE(
REF("SpecialChar"),
GLUE(
NOT(
GLUE(
INLINE("Whitespace"),
CHAR('<')
)
),
ANY()
)
)
)
);
typeTip_ =
DEFINE("TypeTip",
GLUE(
STRING("<type>"),
INLINE("Whitespace"),
REF("Value"),
INLINE("Whitespace"),
STRING("</type>")
)
);
memberName_ = DEFINE("MemberName", REPEAT(1, OTHER('\"')));
memberType_ = DEFINE("MemberType", REPEAT(0, 1, INLINE("Value")));
memberDescription_ = DEFINE("MemberDescription", REPEAT(0, 1, INLINE("Value")));
member_ =
DEFINE("Member",
GLUE(
STRING("<i n=\""),
REF("MemberName"),
STRING("\"><t>"),
REF("MemberType"),
STRING("</t><d>"),
REF("MemberDescription"),
STRING("</d></i>")
)
);
membersTip_ =
DEFINE("MembersTip",
GLUE(
STRING("<list>"),
REPEAT(1,
GLUE(
INLINE("Whitespace"),
REF("Member")
)
),
INLINE("Whitespace"),
STRING("</list>")
)
);
haxeTip_ =
DEFINE("HaxeTip",
FIND(
GLUE(
INLINE("Whitespace"),
CHOICE(
REF("TypeTip"),
REF("MembersTip")
),
INLINE("Whitespace")
)
)
);
ENTRY("HaxeTip");
}
LispObj *
Lisp_PQgetvalue(LispBuiltin *builtin)
/*
pq-getvalue result tuple field &optional type-specifier
*/
{
char *string;
double real = 0.0;
PGresult *res;
int tuple, field, isint = 0, isreal = 0, integer;
LispObj *result, *otupple, *field_number, *type;
type = ARGUMENT(3);
field_number = ARGUMENT(2);
otupple = ARGUMENT(1);
result = ARGUMENT(0);
if (!CHECKO(result, PGresult_t))
LispDestroy("%s: cannot convert %s to PGresult*",
STRFUN(builtin), STROBJ(result));
res = (PGresult*)(result->data.opaque.data);
CHECK_INDEX(otupple);
tuple = FIXNUM_VALUE(otupple);
CHECK_INDEX(field_number);
field = FIXNUM_VALUE(field_number);
string = PQgetvalue(res, tuple, field);
if (type != UNSPEC) {
char *typestring;
CHECK_SYMBOL(type);
typestring = ATOMID(type);
if (strcmp(typestring, "INT16") == 0) {
integer = *(short*)string;
isint = 1;
goto simple_type;
}
else if (strcmp(typestring, "INT32") == 0) {
integer = *(int*)string;
isint = 1;
goto simple_type;
}
else if (strcmp(typestring, "FLOAT") == 0) {
real = *(float*)string;
isreal = 1;
goto simple_type;
}
else if (strcmp(typestring, "REAL") == 0) {
real = *(double*)string;
isreal = 1;
goto simple_type;
}
else if (strcmp(typestring, "PG-POLYGON") == 0)
goto polygon_type;
else if (strcmp(typestring, "STRING") != 0)
LispDestroy("%s: unknown type %s",
STRFUN(builtin), typestring);
}
simple_type:
return (isint ? INTEGER(integer) : isreal ? DFLOAT(real) :
(string ? STRING(string) : NIL));
polygon_type:
{
LispObj *poly, *box, *p = NIL, *cdr, *obj;
POLYGON *polygon;
int i, size;
size = PQgetlength(res, tuple, field);
polygon = (POLYGON*)(string - sizeof(int));
GCDisable();
/* get polygon->boundbox */
cdr = EVAL(CONS(ATOM("MAKE-PG-POINT"),
CONS(KEYWORD("X"),
CONS(REAL(polygon->boundbox.high.x),
CONS(KEYWORD("Y"),
CONS(REAL(polygon->boundbox.high.y), NIL))))));
obj = EVAL(CONS(ATOM("MAKE-PG-POINT"),
CONS(KEYWORD("X"),
CONS(REAL(polygon->boundbox.low.x),
CONS(KEYWORD("Y"),
CONS(REAL(polygon->boundbox.low.y), NIL))))));
box = EVAL(CONS(ATOM("MAKE-PG-BOX"),
CONS(KEYWORD("HIGH"),
CONS(cdr,
CONS(KEYWORD("LOW"),
CONS(obj, NIL))))));
/* get polygon->p values */
for (i = 0; i < polygon->npts; i++) {
obj = EVAL(CONS(ATOM("MAKE-PG-POINT"),
CONS(KEYWORD("X"),
CONS(REAL(polygon->p[i].x),
CONS(KEYWORD("Y"),
CONS(REAL(polygon->p[i].y), NIL))))));
if (i == 0)
p = cdr = CONS(obj, NIL);
else {
RPLACD(cdr, CONS(obj, NIL));
cdr = CDR(cdr);
}
}
/* make result */
poly = EVAL(CONS(ATOM("MAKE-PG-POLYGON"),
CONS(KEYWORD("SIZE"),
CONS(REAL(size),
CONS(KEYWORD("NUM-POINTS"),
CONS(REAL(polygon->npts),
CONS(KEYWORD("BOUNDBOX"),
CONS(box,
CONS(KEYWORD("POINTS"),
CONS(QUOTE(p), NIL))))))))));
GCEnable();
return (poly);
}
}
ULONG hypertexture(ULONG *arg)
{
void *texture, *actor;
rsiVECTOR vec;
rsiResult err;
float fnum;
int type;
if(!surf)
return rsiERR_SURFACE;
if(KEYWORD((char*)arg[0], "EXPLOSION"))
type = rsiFHyperExplosion;
else
return ERROR_HYPERTYPE;
err = rsiAddHyperTexture(CTXT, &texture,type,surf->item);
if(err)
return err;
if(arg[1])
{
if(!read_vector(&vec,(char*)arg[1]))
return ERROR_VECTOR;
err = rsiSetHyperTexture(CTXT, texture,rsiTHyperPos,&vec,rsiTDone);
if(err)
return err;
}
if(arg[2])
{
if(!read_vector(&vec,(char*)arg[2]))
return ERROR_VECTOR;
err = rsiSetHyperTexture(CTXT, texture,rsiTHyperAlign,&vec,rsiTDone);
if(err)
return err;
}
if(arg[3])
{
if(!read_vector(&vec,(char*)arg[3]))
return ERROR_VECTOR;
err = rsiSetHyperTexture(CTXT, texture,rsiTHyperSize,&vec,rsiTDone);
if(err)
return err;
}
if(arg[4])
{
fnum = (float)atof((char*)arg[4]);
err = rsiSetHyperTexture(CTXT, texture,rsiTHyperP1,fnum,rsiTDone);
if(err)
return err;
}
if(arg[5])
{
fnum = (float)atof((char*)arg[5]);
err = rsiSetHyperTexture(CTXT, texture,rsiTHyperP2,fnum,rsiTDone);
if(err)
return err;
}
if(arg[6])
{
fnum = (float)atof((char*)arg[6]);
err = rsiSetHyperTexture(CTXT, texture,rsiTHyperP3,fnum,rsiTDone);
if(err)
return err;
}
if(arg[7])
{
actor = FindActorListItem((char*)arg[7]);
if(!actor)
return rsiERR_ACTOR;
err = rsiSetHyperTexture(CTXT, texture,rsiTHyperActor,actor,rsiTDone);
if(err)
return err;
}
return rsiERR_NONE;
}
static int
parse_arg_type(char **name, enum arg_type *ret)
{
char *rest = NULL;
enum arg_type candidate;
#define KEYWORD(KWD, TYPE) \
do { \
if (strncmp(*name, KWD, sizeof(KWD) - 1) == 0) { \
rest = *name + sizeof(KWD) - 1; \
candidate = TYPE; \
goto ok; \
} \
} while (0)
KEYWORD("void", ARGTYPE_VOID);
KEYWORD("int", ARGTYPE_INT);
KEYWORD("uint", ARGTYPE_UINT);
KEYWORD("long", ARGTYPE_LONG);
KEYWORD("ulong", ARGTYPE_ULONG);
KEYWORD("char", ARGTYPE_CHAR);
KEYWORD("short", ARGTYPE_SHORT);
KEYWORD("ushort", ARGTYPE_USHORT);
KEYWORD("float", ARGTYPE_FLOAT);
KEYWORD("double", ARGTYPE_DOUBLE);
KEYWORD("array", ARGTYPE_ARRAY);
KEYWORD("struct", ARGTYPE_STRUCT);
/* Misspelling of int used in ltrace.conf that we used to
* ship. */
KEYWORD("itn", ARGTYPE_INT);
assert(rest == NULL);
return -1;
#undef KEYWORD
ok:
if (isalnum(CTYPE_CONV(*rest)) || *rest == '_')
return -1;
*name = rest;
*ret = candidate;
return 0;
}
int f_spotlight(ULONG *arg)
{
rsiVECTOR vec;
rsiCOLOR color;
float fnum;
void *actor;
rsiResult err;
ULONG flags = 0;
err = rsiCreateSpotLight(&light);
if (err)
return err;
if (!read_vector(&vec,(char*)arg[0]))
return ERROR_VECTOR;
err = rsiSetSpotLight(light,rsiTLightPos,&vec,rsiTDone);
if (err)
return err;
if (arg[1])
{
if (!read_color(&color,(char*)arg[1]))
return ERROR_COLOREXP;
err = rsiSetSpotLight(light,rsiTLightColor,&color,rsiTDone);
if (err)
return err;
}
if (arg[2])
{
if (!read_vector(&vec,(char*)arg[2]))
return ERROR_VECTOR;
err = rsiSetSpotLight(light,rsiTLightLookPoint,&vec,rsiTDone);
if (err)
return err;
}
if (arg[3])
{
fnum = (float)atof((char*)arg[3]);
err = rsiSetSpotLight(light, rsiTLightAngle,fnum,rsiTDone);
if (err)
return err;
}
if (arg[4])
{
fnum = (float)atof((char*)arg[4]);
err = rsiSetSpotLight(light, rsiTLightRadius, fnum, rsiTDone);
if (err)
return err;
}
if (KEYWORD(arg[5], "SHADOW"))
flags |= rsiFLightShadow;
if (arg[6])
{
actor = FindActorListItem((char*)arg[6]);
if (!actor)
return rsiERR_ACTOR;
err = rsiSetSpotLight(light, rsiTLightActor, actor,rsiTDone);
if (err)
return err;
}
if (arg[7])
{
actor = FindActorListItem((char*)arg[7]);
if (!actor)
return rsiERR_ACTOR;
err = rsiSetSpotLight(light, rsiTLightLookPActor, actor,rsiTDone);
if (err)
return err;
}
if (arg[8])
{
fnum = (float)atof((char*)arg[8]);
err = rsiSetSpotLight(light, rsiTLightFallOff, fnum,rsiTDone);
if (err)
return err;
}
if (!KEYWORD(arg[9], "NOSTAR"))
flags |= rsiFLightStar;
if (!KEYWORD(arg[10], "NOFLARES"))
flags |= rsiFLightFlares;
err = rsiSetSpotLight(light, rsiTLightFlags, flags, rsiTDone);
if (err)
return err;
return rsiERR_NONE;
}
/*
* Implementation
*/
void
LispStreamInit(void)
{
Oopen = STATIC_ATOM("OPEN");
Oclose = STATIC_ATOM("CLOSE");
Otruename = STATIC_ATOM("TRUENAME");
Kif_does_not_exist = KEYWORD("IF-DOES-NOT-EXIST");
Kprobe = KEYWORD("PROBE");
Kinput = KEYWORD("INPUT");
Koutput = KEYWORD("OUTPUT");
Kio = KEYWORD("IO");
Knew_version = KEYWORD("NEW-VERSION");
Krename = KEYWORD("RENAME");
Krename_and_delete = KEYWORD("RENAME-AND-DELETE");
Koverwrite = KEYWORD("OVERWRITE");
Kappend = KEYWORD("APPEND");
Ksupersede = KEYWORD("SUPERSEDE");
Kcreate = KEYWORD("CREATE");
}
int f_startrender(ULONG *arg)
{
rsiResult err;
int flags = 0;
float begin, end;
int left,top,right,bottom;
void *dmy = NULL;
BOOL res;
rsiSMALL_COLOR *scr;
if(insideCSG > 0)
return ERROR_CSG;
if (KEYWORD(arg[0], "QUICK"))
flags |= rsiFRenderQuick;
if (arg[1])
{
err = rsiSetOctreeDepth(atoi((char*)arg[1]));
if (err)
return err;
}
if (arg[2])
begin = (float)atof((char*)arg[2]);
else
begin = 0.;
if (arg[3])
end = (float)atof((char*)arg[3]);
else
end = 0.;
if (arg[4])
left = atoi((char *)arg[4]);
else
left = rsiFDefault;
if (arg[5])
top = atoi((char *)arg[5]);
else
top = rsiFDefault;
if (arg[6])
right = atoi((char *)arg[6]);
else
right = rsiFDefault;
if (arg[7])
bottom = atoi((char *)arg[7]);
else
bottom = rsiFDefault;
if (arg[8])
{
err = rsiSetWorld(dmy, rsiTWorldMinObjects, atoi((char *)arg[8]), rsiTDone);
if(err)
return err;
}
err = rsiSetRenderField(left,top,right,bottom);
if (err)
return err;
if (scrarray)
delete [ ] scrarray;
err = rsiRender((UBYTE**)&scr,rsiTRenderFlags,flags,rsiTRenderTimeBegin,begin,rsiTRenderTimeEnd,end,rsiTDone);
if (err)
return err;
scrarray = new rsiSMALL_COLOR[xRes*yRes];
if(!scrarray)
return ERROR_MEM;
memcpy(scrarray, scr, sizeof(rsiSMALL_COLOR)*xRes*yRes);
return err;
}
int f_setworld(ULONG *arg)
{
rsiCOLOR color;
float fnum;
rsiResult err;
void *dmy=NULL;
if (arg[0])
{
if (!read_color(&color,(char*)arg[0]))
return ERROR_COLOREXP;
err = rsiSetWorld(dmy,rsiTWorldBackground,&color,rsiTDone);
if (err)
return err;
}
if (arg[1])
{
if (!read_color(&color,(char*)arg[1]))
return ERROR_COLOREXP;
err = rsiSetWorld(dmy,rsiTWorldAmbient,&color,rsiTDone);
if (err)
return err;
}
if (KEYWORD(arg[2], "RANDJIT"))
{
err = rsiSetRandomJitter(KEYWORD(arg[2], "RANDJIT"));
if (err)
return err;
}
if (arg[3])
{
err = rsiSetWorld(dmy,rsiTWorldBackdropPic,(char*)arg[3],rsiTDone);
if (err)
return err;
}
if (arg[4])
{
fnum = (float)atof((char*)arg[4]);
err = rsiSetWorld(dmy,rsiTWorldFogLength,fnum,rsiTDone);
if (err)
return err;
}
if (arg[5])
{
fnum = (float)atof((char*)arg[5]);
err = rsiSetWorld(dmy,rsiTWorldFogHeight,fnum,rsiTDone);
if (err)
return err;
}
if (arg[6])
{
if (!read_color(&color,(char*)arg[6]))
return ERROR_COLOREXP;
err = rsiSetWorld(dmy,rsiTWorldFogColor,&color,rsiTDone);
if (err)
return err;
}
if (arg[7])
{
err = rsiSetWorld(dmy,rsiTWorldReflectionMap,(char*)arg[7],rsiTDone);
if (err)
return err;
}
return rsiERR_NONE;
}
