static void objects_render() {
H3dsMeshObj *mesh;
int nmesh, nvert;
double r;
local = (objectShader_section *) mySection->vars;
/* if (demoSystem.drawTiming) {
// Draw the source points
glDisable(GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
render_onlyvertex3ds(local->sources);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_TEXTURE_2D);
} */
glMatrixMode(GL_MODELVIEW);
for (nmesh=0; nmesh<local->sources->meshobjs; nmesh++) {
mesh = &local->sources->meshobjlist[nmesh];
for (nvert=0; nvert<mesh->verts; nvert++) {
r = sqrt(mesh->vertlist[nvert].x * mesh->vertlist[nvert].x + mesh->vertlist[nvert].y * mesh->vertlist[nvert].y + mesh->vertlist[nvert].z * mesh->vertlist[nvert].z);
exprValListAdd(local->evalPositioning.v, "x" , (EXPRTYPE)mesh->vertlist[nvert].x);
exprValListAdd(local->evalPositioning.v, "y" , (EXPRTYPE)mesh->vertlist[nvert].y);
exprValListAdd(local->evalPositioning.v, "z" , (EXPRTYPE)mesh->vertlist[nvert].z);
exprValListAdd(local->evalPositioning.v, "r" , (EXPRTYPE)r);
exprValListAdd(local->evalPositioning.v, "n" , (EXPRTYPE)nvert+1);
glPushMatrix();
// Translate the object to his source position
glTranslatef (mesh->vertlist[nvert].x, mesh->vertlist[nvert].y, mesh->vertlist[nvert].z);
deprecated_place_object(local->evalPositioning);
render_objectLayers (local->object, local->layers, local->enableDepthBufferClearing);
glPopMatrix();
}
}
}
/* Parse a variable or value */
int exprInternalParseVarVal(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end)
{
exprValList *l;
EXPRTYPE *addr;
/* Make sure positions are correct */
if(start != end)
{
return EXPR_ERROR_UNKNOWN;
}
/* Are we an identifier */
if(tokens[start].type == EXPR_TOKEN_IDENTIFIER)
{
/* we are an identifier */
/* check to see if it is a constant */
l = exprGetConstList(obj);
if(l != NULL)
{
if(exprValListGetAddress(l, tokens[start].data.str, &addr) == EXPR_ERROR_NOERROR)
{
/* We found it in the constant list */
/*
Treat is like a variable node so application can change
constant value and it will reflect in expression
*/
node->type = EXPR_NODETYPE_VARIABLE;
node->data.variable.vaddr = addr;
return EXPR_ERROR_NOERROR;
}
}
/* Not found in the constant list, so it must be a variable */
/* Set node type */
node->type = EXPR_NODETYPE_VARIABLE;
/*
The fast access method directly accesses the memory address
of the variable's value at evaluation time. Because of this,
we must make sure the variable does exists in the variable list.
*/
/* Get the variable list */
l = exprGetVarList(obj);
if(l == NULL)
return EXPR_ERROR_NOVARLIST;
/* Get variable address if already in the list */
exprValListGetAddress(l, tokens[start].data.str, &addr);
if(addr == NULL) /* Variable not in the list, add it */
{
exprValListAdd(l, tokens[start].data.str, 0.0);
/* Try to get address again */
exprValListGetAddress(l, tokens[start].data.str, &addr);
if(addr == NULL) /* Could not add variable */
return EXPR_ERROR_MEMORY; /* Could not add variable to list */
}
node->data.variable.vaddr = addr;
return EXPR_ERROR_NOERROR;
}
else if(tokens[start].type == EXPR_TOKEN_VALUE)
{
/* we are a value */
node->type = EXPR_NODETYPE_VALUE;
node->data.value.value = tokens[start].data.val;
return EXPR_ERROR_NOERROR;
}
else
{
obj->starterr = tokens[start].start;
obj->enderr = tokens[end].end;
return EXPR_ERROR_UNKNOWN;
}
}
/* Function to parse an assignment node */
int exprInternalParseAssign(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
{
exprNode *tmp;
exprValList *l;
EXPRTYPE *addr;
/* Make sure the equal sign is not at the start or end */
if(index != start + 1 || index >= end)
{
obj->starterr = tokens[index].start;
obj->enderr = tokens[index].end;
return EXPR_ERROR_SYNTAX;
}
/* Make sure item before equal sign is an identifier */
if(tokens[index - 1].type != EXPR_TOKEN_IDENTIFIER)
{
obj->starterr = tokens[index - 1].start;
obj->enderr = tokens[index].end;
return EXPR_ERROR_SYNTAX;
}
/* Create expression subnode */
tmp = exprAllocNodes(1);
if(tmp == NULL)
{
return EXPR_ERROR_MEMORY;
}
/* Set the data */
node->type = EXPR_NODETYPE_ASSIGN;
node->data.assign.node = tmp;
/*
The fast access method directly accesses the memory address
of the variable's value at evaluation time. Because of this,
we must make sure the variable does exists in the variable list.
*/
/* Make sure name is not a constant name */
l = exprGetConstList(obj);
if(l)
{
exprValListGetAddress(l, tokens[index - 1].data.str, &addr);
if(addr)
{
obj->starterr = tokens[index - 1].start;
obj->enderr = tokens[index].end;
return EXPR_ERROR_CONSTANTASSIGN;
}
}
/* Get the variable list */
l = exprGetVarList(obj);
if(l == NULL)
return EXPR_ERROR_NOVARLIST;
/* Get variable address if already in the list */
exprValListGetAddress(l, tokens[index - 1].data.str, &addr);
if(addr == NULL) /* Variable not in the list, add it */
{
exprValListAdd(l, tokens[index - 1].data.str, 0.0);
/* Try to get address again */
exprValListGetAddress(l, tokens[index - 1].data.str, &addr);
if(addr == NULL) /* Could not add variable */
return EXPR_ERROR_MEMORY; /* Could not add variable to list */
}
node->data.assign.vaddr = addr;
/* Parse the subnode */
return exprInternalParse(obj, tmp, tokens, index + 1, end);
}
/* Function will parse a call to a function */
int exprInternalParseFunction(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int p1, int p2)
{
int pos;
int num, cur;
int refnum, refcur;
int plevel = 0;
int lv, err;
exprNode *tmp;
exprFuncType fptr;
int argmin, argmax;
int refargmin, refargmax;
int type;
exprFuncList *l;
exprValList *vars;
EXPRTYPE *addr;
EXPRTYPE **reftmp;
/* We should have a function list */
l = exprGetFuncList(obj);
if(l == NULL)
return EXPR_ERROR_NOSUCHFUNCTION;
/* check paren. location */
if(p2 <= p1)
return EXPR_ERROR_SYNTAX;
/* second paren. should not be after the end */
if(p2 > end)
return EXPR_ERROR_SYNTAX;
/* Item before parenthesis should be an identifier */
if(tokens[p1 - 1].type != EXPR_TOKEN_IDENTIFIER)
{
obj->starterr = tokens[p1 - 1].start;
obj->enderr = tokens[p1].end;
return EXPR_ERROR_SYNTAX;
}
/* Look up the function */
err = exprFuncListGet(l, tokens[p1 - 1].data.str, &fptr, &type, &argmin, &argmax, &refargmin, &refargmax);
if(err != EXPR_ERROR_NOERROR)
{
if(err == EXPR_ERROR_NOTFOUND)
{
obj->starterr = tokens[p1 - 1].start;
obj->enderr = tokens[p1 - 1].end;
return EXPR_ERROR_NOSUCHFUNCTION;
}
else
return err;
}
/* Make sure the function exists */
if(fptr == NULL && type == 0)
{
obj->starterr = tokens[p1 - 1].start;
obj->enderr = tokens[p1 - 1].end;
return EXPR_ERROR_NOSUCHFUNCTION;
}
/* Count arguments */
if(p2 == p1 + 1)
{
num = 0;
refnum = 0;
}
else
{
num = 1;
refnum = 0;
/* count commas */
for(pos = p1 + 1; pos < p2; pos++)
{
switch(tokens[pos].type)
{
case EXPR_TOKEN_OPAREN:
plevel++;
break;
case EXPR_TOKEN_CPAREN:
plevel--;
if(plevel < 0)
{
obj->starterr = tokens[pos].start;
obj->enderr = tokens[pos].end;
return EXPR_ERROR_UNMATCHEDPAREN;
}
break;
case EXPR_TOKEN_COMMA:
/* Found comma */
if(plevel == 0)
num++;
break;
case EXPR_TOKEN_AMPERSAND:
/* Found reference mark */
if(plevel == 0)
{
/* This may only occur after the open parenthesis or comma */
if(tokens[pos - 1].type == EXPR_TOKEN_OPAREN || tokens[pos - 1].type == EXPR_TOKEN_COMMA)
refnum++;
else
return EXPR_ERROR_SYNTAX;
}
break;
}
}
/* plevel should be zero */
if(plevel != 0)
return EXPR_ERROR_UNMATCHEDPAREN;
}
/* We now have the number of total arguments and
number of ref arguments. Get number of normal
arguments */
num = num - refnum;
/* Make sure number of arguments is correct */
/* Here we make sure the limits are greater
or equal to zero because any negative number
could be used to specify no limit */
if(argmin >= 0 && num < argmin)
{
obj->starterr = tokens[p1 - 1].start;
obj->enderr = tokens[p2].end;
return EXPR_ERROR_BADNUMBERARGUMENTS;
}
if(argmax >= 0 && num > argmax)
{
obj->starterr = tokens[p1 - 1].start;
obj->enderr = tokens[p2].end;
return EXPR_ERROR_BADNUMBERARGUMENTS;
}
if(refargmin >= 0 && refnum < refargmin)
{
obj->starterr = tokens[p1 - 1].start;
obj->enderr = tokens[p2].end;
return EXPR_ERROR_BADNUMBERARGUMENTS;
}
if(refargmax >= 0 && refnum > refargmax)
{
obj->starterr = tokens[p1 - 1].start;
obj->enderr = tokens[p2].end;
return EXPR_ERROR_BADNUMBERARGUMENTS;
}
/* Set tmp to null in case of no arguments */
tmp = NULL;
reftmp = NULL;
if(num > 0)
{
/* Allocate subnodes */
tmp = exprAllocNodes(num);
if(tmp == NULL)
return EXPR_ERROR_MEMORY;
}
if(refnum > 0)
{
/* Allocate ref pointers */
reftmp = exprAllocMem(sizeof(EXPRTYPE*) * refnum);
if(reftmp == NULL)
{
exprFreeMem(tmp);
return EXPR_ERROR_MEMORY;
}
}
/* Set this node's data */
node->type = EXPR_NODETYPE_FUNCTION;
node->data.function.fptr = fptr;
node->data.function.nodecount = num;
node->data.function.nodes = tmp;
node->data.function.refcount = refnum;
node->data.function.refs = reftmp;
node->data.function.type = type;
/* parse each subnode */
if(num + refnum > 0)
{
plevel = 0;
cur = 0;
refcur = 0;
lv = p1 + 1;
/* look for commas if more than 1 arg */
if(num + refnum > 1)
{
for(pos = p1 + 1; pos < p2; pos++)
{
switch(tokens[pos].type)
{
case EXPR_TOKEN_OPAREN:
plevel++;
break;
case EXPR_TOKEN_CPAREN:
plevel--;
break; /* Already checked paren nesting above */
case EXPR_TOKEN_COMMA:
/* Found comma */
if(plevel == 0)
{
/* parse inside */
if(tokens[lv].type == EXPR_TOKEN_AMPERSAND)
{
if(lv != pos - 2)
{
obj->starterr = tokens[lv].start;
obj->enderr = tokens[pos].end;
return EXPR_ERROR_SYNTAX;
}
/* It is a reference */
if(tokens[lv + 1].type != EXPR_TOKEN_IDENTIFIER)
{
obj->starterr = tokens[lv].start;
obj->enderr = tokens[lv + 1].end;
return EXPR_ERROR_SYNTAX;
}
/* Make sure it is not a constant */
vars = exprGetConstList(obj);
if(vars)
{
exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
if(addr)
{
obj->starterr = tokens[lv].start;
obj->enderr = tokens[lv + 1].start;
return EXPR_ERROR_REFCONSTANT;
}
}
/* Get variable list */
vars = exprGetVarList(obj);
if(vars == NULL)
return EXPR_ERROR_NOVARLIST;
/* Get variable address */
exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
if(addr == NULL)
{
/* Add variable to list */
exprValListAdd(vars, tokens[lv + 1].data.str, 0.0);
/* Try to get address again */
exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
if(addr == NULL)
return EXPR_ERROR_MEMORY; /* Could not add variable */
}
/* Set reference item */
reftmp[refcur] = addr;
/* increase ref arg number and lv position*/
refcur++;
lv = pos + 1;
}
else
{
err = exprInternalParse(obj, &(tmp[cur]), tokens, lv, pos - 1);
if(err != EXPR_ERROR_NOERROR)
return err;
/* increase arg number and lv position*/
lv = pos + 1;
cur++;
}
}
break;
}
}
}
/* lv should point after the last comma, or open paren. if only 1 arg */
if(tokens[lv].type == EXPR_TOKEN_AMPERSAND)
{
if(lv != p2 - 2)
{
obj->starterr = tokens[lv].start;
obj->enderr = tokens[p2].end;
return EXPR_ERROR_SYNTAX;
}
/* It is a reference */
if(tokens[lv + 1].type != EXPR_TOKEN_IDENTIFIER)
{
obj->starterr = tokens[lv].start;
obj->enderr = tokens[lv + 1].end;
return EXPR_ERROR_SYNTAX;
}
/* Make sure it is not a constant */
vars = exprGetConstList(obj);
if(vars)
{
exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
if(addr)
{
obj->starterr = tokens[lv].start;
obj->enderr = tokens[lv + 1].start;
return EXPR_ERROR_REFCONSTANT;
}
}
/* Get variable list */
vars = exprGetVarList(obj);
if(vars == NULL)
return EXPR_ERROR_NOVARLIST;
/* Get variable address */
exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
if(addr == NULL)
{
/* Add variable to list */
exprValListAdd(vars, tokens[lv + 1].data.str, 0.0);
/* Try to get address again */
exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
if(addr == NULL)
return EXPR_ERROR_MEMORY; /* Could not add variable */
}
/* Set reference item */
reftmp[refcur] = addr;
}
else
{
err = exprInternalParse(obj, &(tmp[cur]), tokens, lv, p2 - 1);
if(err != EXPR_ERROR_NOERROR)
return err;
}
}
return EXPR_ERROR_NOERROR;
}
