void UI_NodeSetPropertyFromRAW (uiNode_t* node, const value_t* property, const void* rawValue, int rawType)
{
if (property->type != rawType) {
Com_Printf("UI_NodeSetPropertyFromRAW: type %i expected, but @%s type %i found. Property setter to '%s@%s' skipped\n", rawType, property->string, property->type, UI_GetPath(node), property->string);
return;
}
if ((property->type & V_UI_MASK) == V_NOT_UI)
Com_SetValue(node, rawValue, property->type, property->ofs, property->size);
else if ((property->type & V_UI_MASK) == V_UI_CVAR) {
UI_FreeStringProperty(Com_GetValue<void*>(node, property));
switch (property->type & V_BASETYPEMASK) {
case V_FLOAT: *Com_GetValue<float* >(node, property) = *static_cast<float const*>(rawValue); break;
case V_INT: *Com_GetValue<int* >(node, property) = *static_cast<int const*>(rawValue); break;
default: Com_GetValue<byte const*>(node, property) = static_cast<byte const*>(rawValue); break;
}
} else if (property->type == V_UI_ACTION) {
Com_GetValue<uiAction_t const*>(node, property) = static_cast<uiAction_t const*>(rawValue);
} else if (property->type == V_UI_SPRITEREF) {
Com_GetValue<uiSprite_t const*>(node, property) = static_cast<uiSprite_t const*>(rawValue);
} else {
Com_Error(ERR_FATAL, "UI_NodeSetPropertyFromRAW: Property type '%d' unsupported", property->type);
}
UI_Node_PropertyChanged(node, property);
}
static void CL_ParticleFunction (ptl_t *p, ptlCmd_t *cmd)
{
int stackIdx;
ptrdiff_t e;
int type;
int i, j, n;
void *cmdData;
float arg;
ptl_t *pnew;
/* test for null cmd */
if (!cmd)
return;
/* run until finding PC_END */
for (stackIdx = 0, e = 0; cmd->cmd != PC_END; cmd++) {
if (cmd->ref > RSTACK)
cmdData = CL_ParticleCommandGetDataLocation(p, cmd);
else {
if (!stackIdx)
Com_Error(ERR_DROP, "CL_ParticleFunction: stack underflow");
/* pop an element off the stack */
e = (byte *) stackPtr[--stackIdx] - cmdStack;
i = RSTACK - cmd->ref;
if (!i) {
/* normal stack reference */
cmdData = stackPtr[stackIdx];
cmd->type = stackType[stackIdx];
} else {
/* stack reference to element of vector */
if ((1 << stackType[stackIdx]) & V_VECS) {
cmd->type = V_FLOAT;
cmdData = (float *) stackPtr[stackIdx] + (i - 1);
} else {
Com_Error(ERR_DROP, "CL_ParticleFunction: can't get components of a non-vector type (particle %s)", p->ctrl->name);
}
}
}
switch (cmd->cmd) {
case PC_PUSH:
/* check for stack overflow */
if (stackIdx >= MAX_STACK_DEPTH)
Com_Error(ERR_DROP, "CL_ParticleFunction: stack overflow");
/* store the value in the stack */
stackPtr[stackIdx] = &cmdStack[e];
stackType[stackIdx] = cmd->type;
e += Com_SetValue(stackPtr[stackIdx++], cmdData, (valueTypes_t)cmd->type, 0, 0);
break;
case PC_POP:
case PC_KPOP:
/* check for stack underflow */
if (stackIdx == 0)
Com_Error(ERR_DROP, "CL_ParticleFunction: stack underflow");
/* get pics and models */
if (offsetof(ptl_t, pic) == -cmd->ref) {
if (stackType[--stackIdx] != V_STRING)
Com_Error(ERR_DROP, "Bad type '%s' for pic (particle %s)", vt_names[stackType[stackIdx - 1]], p->ctrl->name);
p->pic = CL_ParticleGetArt((char *) stackPtr[stackIdx], p->frame, ART_PIC);
e = (byte *) stackPtr[stackIdx] - cmdStack;
break;
}
if (offsetof(ptl_t, model) == -cmd->ref) {
if (stackType[--stackIdx] != V_STRING)
Com_Error(ERR_DROP, "Bad type '%s' for model (particle %s)", vt_names[stackType[stackIdx - 1]], p->ctrl->name);
p->model = CL_ParticleGetArt((char *) stackPtr[stackIdx], p->frame, ART_MODEL);
e = (byte *) stackPtr[stackIdx] - cmdStack;
break;
}
if (offsetof(ptl_t, program) == -cmd->ref) {
if (stackType[--stackIdx] != V_STRING)
Com_Error(ERR_DROP, "Bad type '%s' for program (particle %s)", vt_names[stackType[stackIdx - 1]], p->ctrl->name);
p->program = R_LoadProgram((char *) stackPtr[stackIdx], R_InitParticleProgram, R_UseParticleProgram);
if (p->program)
p->program->userdata = p;
e = (byte *) stackPtr[stackIdx] - cmdStack;
break;
}
/* get different data */
if (cmd->cmd == PC_POP)
e -= Com_SetValue(cmdData, stackPtr[--stackIdx], (valueTypes_t)cmd->type, 0, 0);
else
Com_SetValue(cmdData, stackPtr[stackIdx - 1], (valueTypes_t)cmd->type, 0, 0);
break;
case PC_ADD:
case PC_SUB:
/* check for stack underflow */
if (stackIdx == 0)
Com_Error(ERR_DROP, "CL_ParticleFunction: stack underflow");
type = stackType[stackIdx - 1];
if (!((1 << type) & V_VECS))
Com_Error(ERR_DROP, "CL_ParticleFunction: bad type '%s' for add (particle %s)", vt_names[stackType[stackIdx - 1]], p->ctrl->name);
/* float based vector addition */
if (type != cmd->type)
Com_Error(ERR_DROP, "CL_ParticleFunction: bad vector dimensions for add/sub (particle %s)", p->ctrl->name);
n = type - V_FLOAT + 1;
for (i = 0; i < n; i++) {
if (cmd->cmd == PC_SUB)
arg = -(*((float *) cmdData + i));
else
arg = *((float *) cmdData + i);
*((float *) stackPtr[stackIdx - 1] + i) += arg;
}
break;
case PC_MUL:
case PC_DIV:
/* check for stack underflow */
if (stackIdx == 0)
Com_Error(ERR_DROP, "CL_ParticleFunction: stack underflow");
type = stackType[stackIdx - 1];
if (!((1 << type) & V_VECS))
Com_Error(ERR_DROP, "CL_ParticleFunction: bad type '%s' for add (particle %s)", vt_names[stackType[stackIdx - 1]], p->ctrl->name);
n = type - V_FLOAT + 1;
if (type > V_FLOAT && cmd->type > V_FLOAT) {
/* component wise multiplication */
if (type != cmd->type)
Com_Error(ERR_DROP, "CL_ParticleFunction: bad vector dimensions for mul/div (particle %s)", p->ctrl->name);
for (i = 0; i < n; i++) {
if (cmd->cmd == PC_DIV)
arg = 1.0 / (*((float *) cmdData + i));
else
arg = *((float *) cmdData + i);
*((float *) stackPtr[stackIdx - 1] + i) *= arg;
}
break;
}
if (cmd->type > V_FLOAT)
Com_Error(ERR_DROP, "CL_ParticleFunction: bad vector dimensions for mul/div (particle %s)", p->ctrl->name);
/* scalar multiplication with scalar in second argument */
if (cmd->cmd == PC_DIV)
arg = 1.0 / (*(float *) cmdData);
else
arg = *(float *) cmdData;
for (i = 0; i < n; i++)
*((float *) stackPtr[stackIdx - 1] + i) *= arg;
break;
case PC_SIN:
if (cmd->type != V_FLOAT)
Com_Error(ERR_DROP, "CL_ParticleFunction: bad type '%s' for sin (particle %s)", vt_names[stackType[stackIdx - 1]], p->ctrl->name);
stackPtr[stackIdx] = &cmdStack[e];
stackType[stackIdx] = cmd->type;
*(float *) stackPtr[stackIdx++] = sin(*(float *) cmdData * (2 * M_PI));
e += sizeof(float);
break;
case PC_COS:
if (cmd->type != V_FLOAT)
Com_Error(ERR_DROP, "CL_ParticleFunction: bad type '%s' for cos (particle %s)", vt_names[stackType[stackIdx - 1]], p->ctrl->name);
stackPtr[stackIdx] = &cmdStack[e];
stackType[stackIdx] = cmd->type;
*(float *) stackPtr[stackIdx++] = sin(*(float *) cmdData * (2 * M_PI));
e += sizeof(float);
break;
case PC_TAN:
if (cmd->type != V_FLOAT)
Com_Error(ERR_DROP, "CL_ParticleFunction: bad type '%s' for tan (particle %s)", vt_names[stackType[stackIdx - 1]], p->ctrl->name);
stackPtr[stackIdx] = &cmdStack[e];
stackType[stackIdx] = cmd->type;
*(float *) stackPtr[stackIdx++] = sin(*(float *) cmdData * (2 * M_PI));
e += sizeof(float);
break;
case PC_RAND:
case PC_CRAND:
stackPtr[stackIdx] = &cmdStack[e];
stackType[stackIdx] = cmd->type;
n = cmd->type - V_FLOAT + 1;
if (cmd->cmd == PC_RAND)
for (i = 0; i < n; i++)
*((float *) stackPtr[stackIdx] + i) = *((float *) cmdData + i) * frand();
else
for (i = 0; i < n; i++)
*((float *) stackPtr[stackIdx] + i) = *((float *) cmdData + i) * crand();
e += n * sizeof(float);
stackIdx++;
break;
case PC_V2:
case PC_V3:
case PC_V4:
n = cmd->cmd - PC_V2 + 2;
j = 0;
if (stackIdx < n)
Com_Error(ERR_DROP, "CL_ParticleFunction: stack underflow");
for (i = 0; i < n; i++) {
if (!((1 << stackType[--stackIdx]) & V_VECS))
Com_Error(ERR_DROP, "CL_ParticleFunction: bad type '%s' for vector creation (particle %s)", vt_names[stackType[stackIdx]], p->ctrl->name);
j += stackType[stackIdx] - V_FLOAT + 1;
}
if (j > 4)
Com_Error(ERR_DROP, "CL_ParticleFunction: created vector with dim > 4 (particle %s)", p->ctrl->name);
stackType[stackIdx++] = V_FLOAT + j - 1;
break;
case PC_KILL:
CL_ParticleFree(p);
return;
case PC_SPAWN:
pnew = CL_ParticleSpawn((const char *) cmdData, p->levelFlags, p->s, p->v, p->a);
if (!pnew)
Com_Printf("PC_SPAWN: Could not spawn child particle for '%s' (%s)\n", p->ctrl->name, (const char *) cmdData);
break;
case PC_TNSPAWN:
/* check for stack underflow */
if (stackIdx < 2)
Com_Error(ERR_DROP, "CL_ParticleFunction: stack underflow");
/* pop elements off the stack */
/* amount of timed particles */
type = stackType[--stackIdx];
if (type != V_INT)
Com_Error(ERR_DROP, "CL_ParticleFunction: bad type '%s' int required for tnspawn (particle %s)", vt_names[stackType[stackIdx]], p->ctrl->name);
n = *(int *) stackPtr[stackIdx];
/* delta time */
type = stackType[--stackIdx];
if (type != V_INT)
Com_Error(ERR_DROP, "CL_ParticleFunction: bad type '%s' int required for tnspawn (particle %s)", vt_names[stackType[stackIdx]], p->ctrl->name);
i = *(int *) stackPtr[stackIdx];
/** @todo make the children boolean configurable */
CL_ParticleSpawnTimed((const char *) cmdData, p, true, i, n);
e -= 2 * sizeof(int);
break;
case PC_NSPAWN:
/* check for stack underflow */
if (stackIdx == 0)
Com_Error(ERR_DROP, "CL_ParticleFunction: stack underflow");
type = stackType[--stackIdx];
if (type != V_INT)
Com_Error(ERR_DROP, "CL_ParticleFunction: bad type '%s' int required for nspawn (particle %s)", vt_names[stackType[stackIdx]], p->ctrl->name);
n = *(int *) stackPtr[stackIdx];
e -= sizeof(int);
for (i = 0; i < n; i++) {
pnew = CL_ParticleSpawn((const char *) cmdData, p->levelFlags, p->s, p->v, p->a);
if (!pnew)
Com_Printf("PC_NSPAWN: Could not spawn child particle for '%s'\n", p->ctrl->name);
}
break;
case PC_CHILD:
pnew = CL_ParticleSpawn((const char *)cmdData, p->levelFlags, p->s, p->v, p->a);
if (pnew) {
pnew->next = p->children;
pnew->parent = p;
p->children = pnew;
} else {
Com_Printf("PC_CHILD: Could not spawn child particle for '%s'\n", p->ctrl->name);
}
break;
default:
Com_Error(ERR_DROP, "CL_ParticleFunction: unknown cmd type %i", cmd->type);
break;
}
}
}
