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; } } }