prvm_edict_t *entity;
float volume;
float attenuation;
+ vec3_t org;
VM_SAFEPARMCOUNT(5, VM_CL_sound);
return;
}
- S_StartSound(MAX_EDICTS + PRVM_NUM_FOR_EDICT(entity), channel, S_FindName(sample), entity->fields.client->origin, volume, attenuation);
+ CL_VM_GetEntitySoundOrigin(MAX_EDICTS + PRVM_NUM_FOR_EDICT(entity), org);
+ S_StartSound(MAX_EDICTS + PRVM_NUM_FOR_EDICT(entity), channel, S_FindName(sample), org, volume, attenuation);
}
// #483 void(vector origin, string sample, float volume, float attenuation) pointsound
trace_t trace;
prvm_edict_t *ent;
prvm_edict_t *ignore;
- int svent;
+ int svent = 0;
prog->xfunction->builtinsprofile += 600;
vec_t radius, radius2;
vec3_t org, eorg, mins, maxs;
int i, numtouchedicts;
- prvm_edict_t *touchedicts[MAX_EDICTS];
+ static prvm_edict_t *touchedicts[MAX_EDICTS];
int chainfield;
VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_findradius);
Matrix4x4_FromVectors(&matrix, forward, left, up, org);
R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &matrix, col, style, cubemapname, castshadow, coronaintensity, coronasizescale, ambientscale, diffusescale, specularscale, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
- r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights++];
+ r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights];r_refdef.scene.numlights++;
prog->functions[prog->funcoffsets.CSQC_UpdateView].totaltime -= Sys_DoubleTime() - t;
}
else
if(!strcasecmp(c, "pl"))
dpsnprintf(t, sizeof(t), "%i", cl.scores[i].qw_packetloss);
+ else
+ if(!strcasecmp(c, "movementloss"))
+ dpsnprintf(t, sizeof(t), "%i", cl.scores[i].qw_movementloss);
else
if(!strcasecmp(c, "entertime"))
dpsnprintf(t, sizeof(t), "%f", cl.scores[i].qw_entertime);
}
-//====================================================================
-//DP_QC_GETSURFACE
-
-extern void clippointtosurface(dp_model_t *model, msurface_t *surface, vec3_t p, vec3_t out);
-
-static msurface_t *cl_getsurface(dp_model_t *model, int surfacenum)
-{
- if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces)
- return NULL;
- return model->data_surfaces + surfacenum + model->firstmodelsurface;
-}
-
-// #434 float(entity e, float s) getsurfacenumpoints
-static void VM_CL_getsurfacenumpoints(void)
-{
- dp_model_t *model;
- msurface_t *surface;
- VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenumpoints);
- // return 0 if no such surface
- if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
- {
- PRVM_G_FLOAT(OFS_RETURN) = 0;
- return;
- }
-
- // note: this (incorrectly) assumes it is a simple polygon
- PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices;
-}
-
-// #435 vector(entity e, float s, float n) getsurfacepoint
-static void VM_CL_getsurfacepoint(void)
-{
- prvm_edict_t *ed;
- dp_model_t *model;
- msurface_t *surface;
- int pointnum;
- VM_SAFEPARMCOUNT(3, VM_CL_getsurfacenumpoints);
- VectorClear(PRVM_G_VECTOR(OFS_RETURN));
- ed = PRVM_G_EDICT(OFS_PARM0);
- if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
- return;
- // note: this (incorrectly) assumes it is a simple polygon
- pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
- if (pointnum < 0 || pointnum >= surface->num_vertices)
- return;
- // FIXME: implement rotation/scaling
- VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
-}
-//PF_getsurfacepointattribute, // #486 vector(entity e, float s, float n, float a) getsurfacepointattribute = #486;
-// float SPA_POSITION = 0;
-// float SPA_S_AXIS = 1;
-// float SPA_T_AXIS = 2;
-// float SPA_R_AXIS = 3; // same as SPA_NORMAL
-// float SPA_TEXCOORDS0 = 4;
-// float SPA_LIGHTMAP0_TEXCOORDS = 5;
-// float SPA_LIGHTMAP0_COLOR = 6;
-// TODO: add some wrapper code and merge VM_CL/SV_getsurface* [12/16/2007 Black]
-static void VM_CL_getsurfacepointattribute(void)
-{
- prvm_edict_t *ed;
- dp_model_t *model;
- msurface_t *surface;
- int pointnum;
- int attributetype;
-
- VM_SAFEPARMCOUNT(4, VM_CL_getsurfacenumpoints);
- VectorClear(PRVM_G_VECTOR(OFS_RETURN));
- ed = PRVM_G_EDICT(OFS_PARM0);
- if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
- return;
- // note: this (incorrectly) assumes it is a simple polygon
- pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
- if (pointnum < 0 || pointnum >= surface->num_vertices)
- return;
-
- // FIXME: implement rotation/scaling
- attributetype = (int) PRVM_G_FLOAT(OFS_PARM3);
-
- switch( attributetype ) {
- // float SPA_POSITION = 0;
- case 0:
- VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
- break;
- // float SPA_S_AXIS = 1;
- case 1:
- VectorCopy(&(model->surfmesh.data_svector3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
- break;
- // float SPA_T_AXIS = 2;
- case 2:
- VectorCopy(&(model->surfmesh.data_tvector3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
- break;
- // float SPA_R_AXIS = 3; // same as SPA_NORMAL
- case 3:
- VectorCopy(&(model->surfmesh.data_normal3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
- break;
- // float SPA_TEXCOORDS0 = 4;
- case 4: {
- float *ret = PRVM_G_VECTOR(OFS_RETURN);
- float *texcoord = &(model->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[pointnum * 2];
- ret[0] = texcoord[0];
- ret[1] = texcoord[1];
- ret[2] = 0.0f;
- break;
- }
- // float SPA_LIGHTMAP0_TEXCOORDS = 5;
- case 5: {
- float *ret = PRVM_G_VECTOR(OFS_RETURN);
- float *texcoord = &(model->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[pointnum * 2];
- ret[0] = texcoord[0];
- ret[1] = texcoord[1];
- ret[2] = 0.0f;
- break;
- }
- // float SPA_LIGHTMAP0_COLOR = 6;
- case 6:
- // ignore alpha for now..
- VectorCopy( &(model->surfmesh.data_lightmapcolor4f + 4 * surface->num_firstvertex)[pointnum * 4], PRVM_G_VECTOR(OFS_RETURN));
- break;
- default:
- VectorSet( PRVM_G_VECTOR(OFS_RETURN), 0.0f, 0.0f, 0.0f );
- break;
- }
-}
-// #436 vector(entity e, float s) getsurfacenormal
-static void VM_CL_getsurfacenormal(void)
-{
- dp_model_t *model;
- msurface_t *surface;
- vec3_t normal;
- VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenormal);
- VectorClear(PRVM_G_VECTOR(OFS_RETURN));
- if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
- return;
- // FIXME: implement rotation/scaling
- // note: this (incorrectly) assumes it is a simple polygon
- // note: this only returns the first triangle, so it doesn't work very
- // well for curved surfaces or arbitrary meshes
- TriangleNormal((model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), (model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + 3, (model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + 6, normal);
- VectorNormalize(normal);
- VectorCopy(normal, PRVM_G_VECTOR(OFS_RETURN));
-}
-
-// #437 string(entity e, float s) getsurfacetexture
-static void VM_CL_getsurfacetexture(void)
-{
- dp_model_t *model;
- msurface_t *surface;
- VM_SAFEPARMCOUNT(2, VM_CL_getsurfacetexture);
- PRVM_G_INT(OFS_RETURN) = OFS_NULL;
- if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
- return;
- PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(surface->texture->name);
-}
-
-// #438 float(entity e, vector p) getsurfacenearpoint
-static void VM_CL_getsurfacenearpoint(void)
-{
- int surfacenum, best;
- vec3_t clipped, p;
- vec_t dist, bestdist;
- prvm_edict_t *ed;
- dp_model_t *model = NULL;
- msurface_t *surface;
- vec_t *point;
- VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenearpoint);
- PRVM_G_FLOAT(OFS_RETURN) = -1;
- ed = PRVM_G_EDICT(OFS_PARM0);
- if(!(model = CL_GetModelFromEdict(ed)) || !model->num_surfaces)
- return;
-
- // FIXME: implement rotation/scaling
- point = PRVM_G_VECTOR(OFS_PARM1);
- VectorSubtract(point, ed->fields.client->origin, p);
- best = -1;
- bestdist = 1000000000;
- for (surfacenum = 0;surfacenum < model->nummodelsurfaces;surfacenum++)
- {
- surface = model->data_surfaces + surfacenum + model->firstmodelsurface;
- // first see if the nearest point on the surface's box is closer than the previous match
- clipped[0] = bound(surface->mins[0], p[0], surface->maxs[0]) - p[0];
- clipped[1] = bound(surface->mins[1], p[1], surface->maxs[1]) - p[1];
- clipped[2] = bound(surface->mins[2], p[2], surface->maxs[2]) - p[2];
- dist = VectorLength2(clipped);
- if (dist < bestdist)
- {
- // it is, check the nearest point on the actual geometry
- clippointtosurface(model, surface, p, clipped);
- VectorSubtract(clipped, p, clipped);
- dist += VectorLength2(clipped);
- if (dist < bestdist)
- {
- // that's closer too, store it as the best match
- best = surfacenum;
- bestdist = dist;
- }
- }
- }
- PRVM_G_FLOAT(OFS_RETURN) = best;
-}
-
-// #439 vector(entity e, float s, vector p) getsurfaceclippedpoint
-static void VM_CL_getsurfaceclippedpoint(void)
-{
- prvm_edict_t *ed;
- dp_model_t *model;
- msurface_t *surface;
- vec3_t p, out;
- VM_SAFEPARMCOUNT(3, VM_CL_getsurfaceclippedpoint);
- VectorClear(PRVM_G_VECTOR(OFS_RETURN));
- ed = PRVM_G_EDICT(OFS_PARM0);
- if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
- return;
- // FIXME: implement rotation/scaling
- VectorSubtract(PRVM_G_VECTOR(OFS_PARM2), ed->fields.client->origin, p);
- clippointtosurface(model, surface, p, out);
- // FIXME: implement rotation/scaling
- VectorAdd(out, ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
-}
-
// #443 void(entity e, entity tagentity, string tagname) setattachment
void VM_CL_setattachment (void)
{
{
int r;
dp_model_t *model;
- int frame;
*tagname = NULL;
*parentindex = 0;
&& (model = CL_GetModelFromEdict(e))
&& model->animscenes)
{
- frame = (int)e->fields.client->frame;
- if (frame < 0 || frame >= model->numframes)
- frame = 0;
-
- r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)e->fields.client->skin, model->animscenes[frame].firstframe, tagindex - 1, parentindex, tagname, tag_localmatrix);
+ r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)e->fields.client->skin, e->priv.server->frameblend, &e->priv.server->skeleton, tagindex - 1, parentindex, tagname, tag_localmatrix);
if(!r) // success?
*parentindex += 1;
int CL_GetEntityLocalTagMatrix(prvm_edict_t *ent, int tagindex, matrix4x4_t *out)
{
- int frame;
- int ret;
dp_model_t *model;
- entity_render_t cheatentity;
if (tagindex >= 0
&& (model = CL_GetModelFromEdict(ent))
&& model->animscenes)
{
- // if model has wrong frame, engine automatically switches to model first frame
- frame = (int)ent->fields.client->frame;
- if (frame < 0 || frame >= model->numframes)
- frame = 0;
- // now we'll do some CHEATING
- memset(&cheatentity, 0, sizeof(cheatentity));
- cheatentity.model = model;
- CL_LoadFrameGroupBlend(ent, &cheatentity);
- R_LerpAnimation(&cheatentity);
- ret = CL_BlendTagMatrix(&cheatentity, tagindex, out);
- if(ret)
- *out = identitymatrix;
- return ret;
+ VM_GenerateFrameGroupBlend(ent->priv.server->framegroupblend, ent);
+ VM_FrameBlendFromFrameGroupBlend(ent->priv.server->frameblend, ent->priv.server->framegroupblend, model);
+ VM_UpdateEdictSkeleton(ent, model, ent->priv.server->frameblend);
+ return Mod_Alias_GetTagMatrix(model, ent->priv.server->frameblend, &ent->priv.server->skeleton, tagindex, out);
}
*out = identitymatrix;
return 0;
{
prvm_edict_t *ent;
const char *tag_name;
- int modelindex, tag_index;
+ int tag_index;
VM_SAFEPARMCOUNT(2, VM_CL_gettagindex);
tag_name = PRVM_G_STRING(OFS_PARM1);
if (ent == prog->edicts)
{
- VM_Warning("gettagindex: can't affect world entity\n");
+ VM_Warning("VM_CL_gettagindex(entity #%i): can't affect world entity\n", PRVM_NUM_FOR_EDICT(ent));
return;
}
if (ent->priv.server->free)
{
- VM_Warning("gettagindex: can't affect free entity\n");
+ VM_Warning("VM_CL_gettagindex(entity #%i): can't affect free entity\n", PRVM_NUM_FOR_EDICT(ent));
return;
}
- modelindex = (int)ent->fields.client->modelindex;
tag_index = 0;
- if (modelindex >= MAX_MODELS || (modelindex <= -MAX_MODELS /* client models */))
- Con_DPrintf("gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
+ if (!CL_GetModelFromEdict(ent))
+ Con_DPrintf("VM_CL_gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
else
{
tag_index = CL_GetTagIndex(ent, tag_name);
if (tag_index == 0)
- Con_DPrintf("gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
+ Con_Printf("VM_CL_gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
}
PRVM_G_FLOAT(OFS_RETURN) = tag_index;
}
int returncode;
prvm_eval_t *val;
vec3_t fo, le, up, trans;
+ const dp_model_t *model;
VM_SAFEPARMCOUNT(2, VM_CL_gettaginfo);
returncode = CL_GetTagMatrix(&tag_matrix, e, tagindex);
Matrix4x4_ToVectors(&tag_matrix, prog->globals.client->v_forward, le, prog->globals.client->v_up, PRVM_G_VECTOR(OFS_RETURN));
VectorScale(le, -1, prog->globals.client->v_right);
+ model = CL_GetModelFromEdict(e);
+ VM_GenerateFrameGroupBlend(e->priv.server->framegroupblend, e);
+ VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model);
+ VM_UpdateEdictSkeleton(e, model, e->priv.server->frameblend);
CL_GetExtendedTagInfo(e, tagindex, &parentindex, &tagname, &tag_localmatrix);
Matrix4x4_ToVectors(&tag_localmatrix, fo, le, up, trans);
*vmpartspawner.particle_velocityjitter = theme->velocityjitter;
*vmpartspawner.particle_qualityreduction = theme->qualityreduction;
*vmpartspawner.particle_stretch = theme->stretch;
- vmpartspawner.particle_staincolor1[0] = (theme->staincolor1 >> 16) & 0xFF;
- vmpartspawner.particle_staincolor1[1] = (theme->staincolor1 >> 8) & 0xFF;
- vmpartspawner.particle_staincolor1[2] = (theme->staincolor1 >> 0) & 0xFF;
- vmpartspawner.particle_staincolor2[0] = (theme->staincolor2 >> 16) & 0xFF;
- vmpartspawner.particle_staincolor2[1] = (theme->staincolor2 >> 8) & 0xFF;
- vmpartspawner.particle_staincolor2[2] = (theme->staincolor2 >> 0) & 0xFF;
+ vmpartspawner.particle_staincolor1[0] = ((int)theme->staincolor1 >> 16) & 0xFF;
+ vmpartspawner.particle_staincolor1[1] = ((int)theme->staincolor1 >> 8) & 0xFF;
+ vmpartspawner.particle_staincolor1[2] = ((int)theme->staincolor1 >> 0) & 0xFF;
+ vmpartspawner.particle_staincolor2[0] = ((int)theme->staincolor2 >> 16) & 0xFF;
+ vmpartspawner.particle_staincolor2[1] = ((int)theme->staincolor2 >> 8) & 0xFF;
+ vmpartspawner.particle_staincolor2[2] = ((int)theme->staincolor2 >> 0) & 0xFF;
*vmpartspawner.particle_staintex = (float)theme->staintex;
*vmpartspawner.particle_delayspawn = theme->delayspawn;
*vmpartspawner.particle_delaycollision = theme->delaycollision;
theme->velocityjitter = *vmpartspawner.particle_velocityjitter;
theme->qualityreduction = (*vmpartspawner.particle_qualityreduction) ? true : false;
theme->stretch = *vmpartspawner.particle_stretch;
- theme->staincolor1 = vmpartspawner.particle_staincolor1[0]*65536 + vmpartspawner.particle_staincolor1[1]*256 + vmpartspawner.particle_staincolor1[2];
- theme->staincolor2 = vmpartspawner.particle_staincolor2[0]*65536 + vmpartspawner.particle_staincolor2[1]*256 + vmpartspawner.particle_staincolor2[2];
+ theme->staincolor1 = ((int)vmpartspawner.particle_staincolor1[0])*65536 + (int)(vmpartspawner.particle_staincolor1[1])*256 + (int)(vmpartspawner.particle_staincolor1[2]);
+ theme->staincolor2 = (int)(vmpartspawner.particle_staincolor2[0])*65536 + (int)(vmpartspawner.particle_staincolor2[1])*256 + (int)(vmpartspawner.particle_staincolor2[2]);
theme->staintex =(int)*vmpartspawner.particle_staintex;
theme->delayspawn = *vmpartspawner.particle_delayspawn;
theme->delaycollision = *vmpartspawner.particle_delaycollision;
if (prog->argc < 3) // global-set particle
{
- part = CL_NewParticle((unsigned short)*vmpartspawner.particle_type, ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, (int)(*vmpartspawner.particle_alpha*256), (int)(*vmpartspawner.particle_alphafade*256), *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)*vmpartspawner.particle_blendmode, (porientation_t)*vmpartspawner.particle_orientation, ((int)vmpartspawner.particle_staincolor1[0] << 16) + ((int)vmpartspawner.particle_staincolor1[1] << 8) + ((int)vmpartspawner.particle_staincolor1[2]), ((int)vmpartspawner.particle_staincolor2[0] << 16) + ((int)vmpartspawner.particle_staincolor2[1] << 8) + ((int)vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex);
+ part = CL_NewParticle((unsigned short)*vmpartspawner.particle_type, ((int)(vmpartspawner.particle_color1[0]) << 16) + ((int)(vmpartspawner.particle_color1[1]) << 8) + ((int)(vmpartspawner.particle_color1[2])), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, (int)(*vmpartspawner.particle_alpha*256), (int)(*vmpartspawner.particle_alphafade*256), *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)*vmpartspawner.particle_blendmode, (porientation_t)*vmpartspawner.particle_orientation, (int)(vmpartspawner.particle_staincolor1[0])*65536 + (int)(vmpartspawner.particle_staincolor1[1])*256 + (int)(vmpartspawner.particle_staincolor1[2]), (int)(vmpartspawner.particle_staincolor2[0])*65536 + (int)(vmpartspawner.particle_staincolor2[1])*256 + (int)(vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex);
if (!part)
{
PRVM_G_FLOAT(OFS_RETURN) = 0;
if(polys->progstarttime != prog->starttime) // from other progs? won't draw these (this can cause crashes!)
return;
R_Mesh_ResetTextureState();
- R_Mesh_Matrix(&identitymatrix);
+ R_EntityMatrix(&identitymatrix);
GL_CullFace(GL_NONE);
R_Mesh_VertexPointer(polys->data_vertex3f, 0, 0);
R_Mesh_ColorPointer(polys->data_color4f, 0, 0);
R_Mesh_TexCoordPointer(0, 2, polys->data_texcoord2f, 0, 0);
- R_SetupGenericShader(true);
for (surfacelistindex = 0;surfacelistindex < numsurfaces;)
{
GL_BlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ONE);
else
GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- R_Mesh_TexBind(0, R_GetTexture(tex));
+ R_SetupShader_Generic(tex, NULL, GL_MODULATE, 1);
numtriangles = 0;
for (;surfacelistindex < numsurfaces;surfacelistindex++)
{
PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, fatpvs, mi, ma);
#endif
}
+
+// #263 float(float modlindex) skel_create = #263; // (FTE_CSQC_SKELETONOBJECTS) create a skeleton (be sure to assign this value into .skeletonindex for use), returns skeleton index (1 or higher) on success, returns 0 on failure (for example if the modelindex is not skeletal), it is recommended that you create a new skeleton if you change modelindex.
+static void VM_CL_skel_create(void)
+{
+ int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
+ dp_model_t *model = CL_GetModelByIndex(modelindex);
+ skeleton_t *skeleton;
+ int i;
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ if (!model || !model->num_bones)
+ return;
+ for (i = 0;i < MAX_EDICTS;i++)
+ if (!prog->skeletons[i])
+ break;
+ if (i == MAX_EDICTS)
+ return;
+ prog->skeletons[i] = skeleton = Mem_Alloc(cls.levelmempool, sizeof(skeleton_t) + model->num_bones * sizeof(matrix4x4_t));
+ skeleton->model = model;
+ skeleton->relativetransforms = (matrix4x4_t *)(skeleton+1);
+ // initialize to identity matrices
+ for (i = 0;i < skeleton->model->num_bones;i++)
+ skeleton->relativetransforms[i] = identitymatrix;
+ PRVM_G_FLOAT(OFS_RETURN) = i + 1;
+}
+
+// #264 float(float skel, entity ent, float modlindex, float retainfrac, float firstbone, float lastbone) skel_build = #264; // (FTE_CSQC_SKELETONOBJECTS) blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure
+static void VM_CL_skel_build(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ skeleton_t *skeleton;
+ prvm_edict_t *ed = PRVM_G_EDICT(OFS_PARM1);
+ int modelindex = (int)PRVM_G_FLOAT(OFS_PARM2);
+ float retainfrac = PRVM_G_FLOAT(OFS_PARM3);
+ int firstbone = PRVM_G_FLOAT(OFS_PARM4);
+ int lastbone = PRVM_G_FLOAT(OFS_PARM5);
+ dp_model_t *model = CL_GetModelByIndex(modelindex);
+ float blendfrac;
+ int numblends;
+ int bonenum;
+ int blendindex;
+ framegroupblend_t framegroupblend[MAX_FRAMEGROUPBLENDS];
+ frameblend_t frameblend[MAX_FRAMEBLENDS];
+ matrix4x4_t blendedmatrix;
+ matrix4x4_t matrix;
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ firstbone = max(0, firstbone);
+ lastbone = min(lastbone, model->num_bones - 1);
+ lastbone = min(lastbone, skeleton->model->num_bones - 1);
+ VM_GenerateFrameGroupBlend(framegroupblend, ed);
+ VM_FrameBlendFromFrameGroupBlend(frameblend, framegroupblend, model);
+ blendfrac = 1.0f - retainfrac;
+ for (numblends = 0;numblends < MAX_FRAMEBLENDS && frameblend[numblends].lerp;numblends++)
+ frameblend[numblends].lerp *= blendfrac;
+ for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
+ {
+ memset(&blendedmatrix, 0, sizeof(blendedmatrix));
+ Matrix4x4_Accumulate(&blendedmatrix, &skeleton->relativetransforms[bonenum], retainfrac);
+ for (blendindex = 0;blendindex < numblends;blendindex++)
+ {
+ Matrix4x4_FromBonePose6s(&matrix, model->num_posescale, model->data_poses6s + 6 * (frameblend[blendindex].subframe * model->num_bones + bonenum));
+ Matrix4x4_Accumulate(&blendedmatrix, &matrix, frameblend[blendindex].lerp);
+ }
+ skeleton->relativetransforms[bonenum] = blendedmatrix;
+ }
+ PRVM_G_FLOAT(OFS_RETURN) = skeletonindex;
+}
+
+// #265 float(float skel) skel_get_numbones = #265; // (FTE_CSQC_SKELETONOBJECTS) returns how many bones exist in the created skeleton
+static void VM_CL_skel_get_numbones(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ skeleton_t *skeleton;
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ PRVM_G_FLOAT(OFS_RETURN) = skeleton->model->num_bones;
+}
+
+// #266 string(float skel, float bonenum) skel_get_bonename = #266; // (FTE_CSQC_SKELETONOBJECTS) returns name of bone (as a tempstring)
+static void VM_CL_skel_get_bonename(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
+ skeleton_t *skeleton;
+ PRVM_G_INT(OFS_RETURN) = 0;
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
+ return;
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(skeleton->model->data_bones[bonenum].name);
+}
+
+// #267 float(float skel, float bonenum) skel_get_boneparent = #267; // (FTE_CSQC_SKELETONOBJECTS) returns parent num for supplied bonenum, 0 if bonenum has no parent or bone does not exist (returned value is always less than bonenum, you can loop on this)
+static void VM_CL_skel_get_boneparent(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
+ skeleton_t *skeleton;
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
+ return;
+ PRVM_G_FLOAT(OFS_RETURN) = skeleton->model->data_bones[bonenum].parent + 1;
+}
+
+// #268 float(float skel, string tagname) skel_find_bone = #268; // (FTE_CSQC_SKELETONOBJECTS) get number of bone with specified name, 0 on failure, tagindex (bonenum+1) on success, same as using gettagindex on the modelindex
+static void VM_CL_skel_find_bone(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ const char *tagname = PRVM_G_STRING(OFS_PARM1);
+ skeleton_t *skeleton;
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ PRVM_G_FLOAT(OFS_RETURN) = Mod_Alias_GetTagIndexForName(skeleton->model, 0, tagname) + 1;
+}
+
+// #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
+static void VM_CL_skel_get_bonerel(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
+ skeleton_t *skeleton;
+ matrix4x4_t matrix;
+ vec3_t forward, left, up, origin;
+ VectorClear(PRVM_G_VECTOR(OFS_RETURN));
+ VectorClear(prog->globals.client->v_forward);
+ VectorClear(prog->globals.client->v_right);
+ VectorClear(prog->globals.client->v_up);
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
+ return;
+ matrix = skeleton->relativetransforms[bonenum];
+ Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
+ VectorCopy(forward, prog->globals.client->v_forward);
+ VectorNegate(left, prog->globals.client->v_right);
+ VectorCopy(up, prog->globals.client->v_up);
+ VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
+}
+
+// #270 vector(float skel, float bonenum) skel_get_boneabs = #270; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton in model space - sets v_forward, v_right, v_up, returns origin (relative to entity)
+static void VM_CL_skel_get_boneabs(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
+ skeleton_t *skeleton;
+ matrix4x4_t matrix;
+ matrix4x4_t temp;
+ vec3_t forward, left, up, origin;
+ VectorClear(PRVM_G_VECTOR(OFS_RETURN));
+ VectorClear(prog->globals.client->v_forward);
+ VectorClear(prog->globals.client->v_right);
+ VectorClear(prog->globals.client->v_up);
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
+ return;
+ matrix = skeleton->relativetransforms[bonenum];
+ // convert to absolute
+ while ((bonenum = skeleton->model->data_bones[bonenum].parent) >= 0)
+ {
+ temp = matrix;
+ Matrix4x4_Concat(&matrix, &skeleton->relativetransforms[bonenum], &temp);
+ }
+ Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
+ VectorCopy(forward, prog->globals.client->v_forward);
+ VectorNegate(left, prog->globals.client->v_right);
+ VectorCopy(up, prog->globals.client->v_up);
+ VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
+}
+
+// #271 void(float skel, float bonenum, vector org) skel_set_bone = #271; // (FTE_CSQC_SKELETONOBJECTS) set matrix of bone relative to its parent, reads v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
+static void VM_CL_skel_set_bone(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
+ vec3_t forward, left, up, origin;
+ skeleton_t *skeleton;
+ matrix4x4_t matrix;
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
+ return;
+ VectorCopy(prog->globals.client->v_forward, forward);
+ VectorNegate(prog->globals.client->v_right, left);
+ VectorCopy(prog->globals.client->v_up, up);
+ VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
+ Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
+ skeleton->relativetransforms[bonenum] = matrix;
+}
+
+// #272 void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrix (relative to its parent) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
+static void VM_CL_skel_mul_bone(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
+ vec3_t forward, left, up, origin;
+ skeleton_t *skeleton;
+ matrix4x4_t matrix;
+ matrix4x4_t temp;
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
+ return;
+ VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
+ VectorCopy(prog->globals.client->v_forward, forward);
+ VectorNegate(prog->globals.client->v_right, left);
+ VectorCopy(prog->globals.client->v_up, up);
+ Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
+ temp = skeleton->relativetransforms[bonenum];
+ Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
+}
+
+// #273 void(float skel, float startbone, float endbone, vector org) skel_mul_bones = #273; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrices (relative to their parents) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bones)
+static void VM_CL_skel_mul_bones(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ int firstbone = PRVM_G_FLOAT(OFS_PARM1) - 1;
+ int lastbone = PRVM_G_FLOAT(OFS_PARM2) - 1;
+ int bonenum;
+ vec3_t forward, left, up, origin;
+ skeleton_t *skeleton;
+ matrix4x4_t matrix;
+ matrix4x4_t temp;
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ VectorCopy(PRVM_G_VECTOR(OFS_PARM3), origin);
+ VectorCopy(prog->globals.client->v_forward, forward);
+ VectorNegate(prog->globals.client->v_right, left);
+ VectorCopy(prog->globals.client->v_up, up);
+ Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
+ firstbone = max(0, firstbone);
+ lastbone = min(lastbone, skeleton->model->num_bones - 1);
+ for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
+ {
+ temp = skeleton->relativetransforms[bonenum];
+ Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
+ }
+}
+
+// #274 void(float skeldst, float skelsrc, float startbone, float endbone) skel_copybones = #274; // (FTE_CSQC_SKELETONOBJECTS) copy bone matrices (relative to their parents) from one skeleton to another, useful for copying a skeleton to a corpse
+static void VM_CL_skel_copybones(void)
+{
+ int skeletonindexdst = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ int skeletonindexsrc = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
+ int firstbone = PRVM_G_FLOAT(OFS_PARM2) - 1;
+ int lastbone = PRVM_G_FLOAT(OFS_PARM3) - 1;
+ int bonenum;
+ skeleton_t *skeletondst;
+ skeleton_t *skeletonsrc;
+ if (skeletonindexdst < 0 || skeletonindexdst >= MAX_EDICTS || !(skeletondst = prog->skeletons[skeletonindexdst]))
+ return;
+ if (skeletonindexsrc < 0 || skeletonindexsrc >= MAX_EDICTS || !(skeletonsrc = prog->skeletons[skeletonindexsrc]))
+ return;
+ firstbone = max(0, firstbone);
+ lastbone = min(lastbone, skeletondst->model->num_bones - 1);
+ lastbone = min(lastbone, skeletonsrc->model->num_bones - 1);
+ for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
+ skeletondst->relativetransforms[bonenum] = skeletonsrc->relativetransforms[bonenum];
+}
+
+// #275 void(float skel) skel_delete = #275; // (FTE_CSQC_SKELETONOBJECTS) deletes skeleton at the beginning of the next frame (you can add the entity, delete the skeleton, renderscene, and it will still work)
+static void VM_CL_skel_delete(void)
+{
+ int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
+ skeleton_t *skeleton;
+ if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
+ return;
+ Mem_Free(skeleton);
+ prog->skeletons[skeletonindex] = NULL;
+}
+
+// #276 float(float modlindex, string framename) frameforname = #276; // (FTE_CSQC_SKELETONOBJECTS) finds number of a specified frame in the animation, returns -1 if no match found
+static void VM_CL_frameforname(void)
+{
+ int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
+ dp_model_t *model = CL_GetModelByIndex(modelindex);
+ const char *name = PRVM_G_STRING(OFS_PARM1);
+ int i;
+ PRVM_G_FLOAT(OFS_RETURN) = -1;
+ if (!model || !model->animscenes)
+ return;
+ for (i = 0;i < model->numframes;i++)
+ {
+ if (!strcasecmp(model->animscenes[i].name, name))
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = i;
+ break;
+ }
+ }
+}
+
+// #277 float(float modlindex, float framenum) frameduration = #277; // (FTE_CSQC_SKELETONOBJECTS) returns the intended play time (in seconds) of the specified framegroup, if it does not exist the result is 0, if it is a single frame it may be a small value around 0.1 or 0.
+static void VM_CL_frameduration(void)
+{
+ int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
+ dp_model_t *model = CL_GetModelByIndex(modelindex);
+ int framenum = (int)PRVM_G_FLOAT(OFS_PARM1);
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ if (!model || !model->animscenes || framenum < 0 || framenum >= model->numframes)
+ return;
+ if (model->animscenes[framenum].framerate)
+ PRVM_G_FLOAT(OFS_RETURN) = model->animscenes[framenum].framecount / model->animscenes[framenum].framerate;
+}
+
//============================================================================
// To create a almost working builtin file from this replace:
NULL, // #260
NULL, // #261
NULL, // #262
-NULL, // #263
-NULL, // #264
-NULL, // #265
-NULL, // #266
-NULL, // #267
-NULL, // #268
-NULL, // #269
-NULL, // #270
-NULL, // #271
-NULL, // #272
-NULL, // #273
-NULL, // #274
-NULL, // #275
-NULL, // #276
-NULL, // #277
+VM_CL_skel_create, // #263 float(float modlindex) skel_create = #263; // (FTE_CSQC_SKELETONOBJECTS) create a skeleton (be sure to assign this value into .skeletonindex for use), returns skeleton index (1 or higher) on success, returns 0 on failure (for example if the modelindex is not skeletal), it is recommended that you create a new skeleton if you change modelindex.
+VM_CL_skel_build, // #264 float(float skel, entity ent, float modlindex, float retainfrac, float firstbone, float lastbone) skel_build = #264; // (FTE_CSQC_SKELETONOBJECTS) blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure
+VM_CL_skel_get_numbones, // #265 float(float skel) skel_get_numbones = #265; // (FTE_CSQC_SKELETONOBJECTS) returns how many bones exist in the created skeleton
+VM_CL_skel_get_bonename, // #266 string(float skel, float bonenum) skel_get_bonename = #266; // (FTE_CSQC_SKELETONOBJECTS) returns name of bone (as a tempstring)
+VM_CL_skel_get_boneparent, // #267 float(float skel, float bonenum) skel_get_boneparent = #267; // (FTE_CSQC_SKELETONOBJECTS) returns parent num for supplied bonenum, -1 if bonenum has no parent or bone does not exist (returned value is always less than bonenum, you can loop on this)
+VM_CL_skel_find_bone, // #268 float(float skel, string tagname) skel_find_bone = #268; // (FTE_CSQC_SKELETONOBJECTS) get number of bone with specified name, 0 on failure, tagindex (bonenum+1) on success, same as using gettagindex on the modelindex
+VM_CL_skel_get_bonerel, // #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
+VM_CL_skel_get_boneabs, // #270 vector(float skel, float bonenum) skel_get_boneabs = #270; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton in model space - sets v_forward, v_right, v_up, returns origin (relative to entity)
+VM_CL_skel_set_bone, // #271 void(float skel, float bonenum, vector org) skel_set_bone = #271; // (FTE_CSQC_SKELETONOBJECTS) set matrix of bone relative to its parent, reads v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
+VM_CL_skel_mul_bone, // #272 void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrix (relative to its parent) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
+VM_CL_skel_mul_bones, // #273 void(float skel, float startbone, float endbone, vector org) skel_mul_bones = #273; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrices (relative to their parents) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bones)
+VM_CL_skel_copybones, // #274 void(float skeldst, float skelsrc, float startbone, float endbone) skel_copybones = #274; // (FTE_CSQC_SKELETONOBJECTS) copy bone matrices (relative to their parents) from one skeleton to another, useful for copying a skeleton to a corpse
+VM_CL_skel_delete, // #275 void(float skel) skel_delete = #275; // (FTE_CSQC_SKELETONOBJECTS) deletes skeleton at the beginning of the next frame (you can add the entity, delete the skeleton, renderscene, and it will still work)
+VM_CL_frameforname, // #276 float(float modlindex, string framename) frameforname = #276; // (FTE_CSQC_SKELETONOBJECTS) finds number of a specified frame in the animation, returns -1 if no match found
+VM_CL_frameduration, // #277 float(float modlindex, float framenum) frameduration = #277; // (FTE_CSQC_SKELETONOBJECTS) returns the intended play time (in seconds) of the specified framegroup, if it does not exist the result is 0, if it is a single frame it may be a small value around 0.1 or 0.
NULL, // #278
NULL, // #279
NULL, // #280
VM_CL_te_beam, // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
VM_vectorvectors, // #432 void(vector dir) vectorvectors (DP_QC_VECTORVECTORS)
VM_CL_te_plasmaburn, // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
-VM_CL_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
-VM_CL_getsurfacepoint, // #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
-VM_CL_getsurfacenormal, // #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
-VM_CL_getsurfacetexture, // #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
-VM_CL_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
-VM_CL_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
+VM_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
+VM_getsurfacepoint, // #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
+VM_getsurfacenormal, // #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
+VM_getsurfacetexture, // #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
+VM_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
+VM_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
NULL, // #440 void(entity e, string s) clientcommand (KRIMZON_SV_PARSECLIENTCOMMAND)
VM_tokenize, // #441 float(string s) tokenize (KRIMZON_SV_PARSECLIENTCOMMAND)
VM_argv, // #442 string(float n) argv (KRIMZON_SV_PARSECLIENTCOMMAND)
VM_CL_pointsound, // #483 void(vector origin, string sample, float volume, float attenuation) pointsound (DP_SV_POINTSOUND)
VM_strreplace, // #484 string(string search, string replace, string subject) strreplace (DP_QC_STRREPLACE)
VM_strireplace, // #485 string(string search, string replace, string subject) strireplace (DP_QC_STRREPLACE)
-VM_CL_getsurfacepointattribute,// #486 vector(entity e, float s, float n, float a) getsurfacepointattribute
+VM_getsurfacepointattribute,// #486 vector(entity e, float s, float n, float a) getsurfacepointattribute
VM_gecko_create, // #487 float gecko_create( string name )
VM_gecko_destroy, // #488 void gecko_destroy( string name )
VM_gecko_navigate, // #489 void gecko_navigate( string name, string URI )
NULL, // #623
VM_CL_getextresponse, // #624 string getextresponse(void)
NULL, // #625
+NULL, // #626
+VM_sprintf, // #627 string sprintf(string format, ...)
+VM_getsurfacenumtriangles, // #628 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACETRIANGLE)
+VM_getsurfacetriangle, // #629 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACETRIANGLE)
+NULL, // #630
};
const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);
projects / xonotic / darkplaces.git / blobdiff