case VF_FOG_FADEDEPTH:
PRVM_G_FLOAT(OFS_RETURN) = r_refdef.fog_fadedepth;
break;
+ case VF_MINFPS_QUALITY:
+ PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.quality;
+ break;
default:
PRVM_G_FLOAT(OFS_RETURN) = 0;
VM_Warning(prog, "VM_CL_R_GetView : unknown parm %i\n", c);
case VF_FOG_FADEDEPTH:
r_refdef.fog_fadedepth = k;
break;
+ case VF_MINFPS_QUALITY:
+ r_refdef.view.quality = k;
+ break;
default:
PRVM_G_FLOAT(OFS_RETURN) = 0;
VM_Warning(prog, "VM_CL_R_SetView : unknown parm %i\n", c);
}
//#347 void() runstandardplayerphysics (EXT_CSQC)
-#define PMF_JUMP_HELD 1
-#define PMF_LADDER 2 // not used by DP
-#define PMF_DUCKED 4 // FIXME FTEQW doesn't have this for Q1 like movement
+#define PMF_JUMP_HELD 1 // matches FTEQW
+#define PMF_LADDER 2 // not used by DP, FTEQW sets this in runplayerphysics but does not read it
+#define PMF_DUCKED 4 // FIXME FTEQW doesn't have this for Q1 like movement because Q1 cannot crouch
+#define PMF_ONGROUND 8 // FIXME FTEQW doesn't have this for Q1 like movement and expects CSQC code to do its own trace, this is stupid CPU waste
static void VM_CL_runplayerphysics (prvm_prog_t *prog)
{
cl_clientmovement_state_t s;
prvm_edict_t *ent;
- VM_SAFEPARMCOUNT(1, VM_CL_runplayerphysics);
+ memset(&s, 0, sizeof(s));
+
+ VM_SAFEPARMCOUNTRANGE(0, 1, VM_CL_runplayerphysics);
+
+ ent = (prog->argc == 1 ? PRVM_G_EDICT(OFS_PARM0) : prog->edicts);
+ if(ent == prog->edicts)
+ {
+ // deprecated use
+ s.self = NULL;
+ VectorCopy(PRVM_clientglobalvector(pmove_org), s.origin);
+ VectorCopy(PRVM_clientglobalvector(pmove_vel), s.velocity);
+ VectorCopy(PRVM_clientglobalvector(pmove_mins), s.mins);
+ VectorCopy(PRVM_clientglobalvector(pmove_maxs), s.maxs);
+ s.crouched = 0;
+ s.waterjumptime = PRVM_clientglobalfloat(pmove_waterjumptime);
+ s.cmd.canjump = (int)PRVM_clientglobalfloat(pmove_jump_held) == 0;
+ }
+ else
+ {
+ // new use
+ s.self = ent;
+ VectorCopy(PRVM_clientedictvector(ent, origin), s.origin);
+ VectorCopy(PRVM_clientedictvector(ent, velocity), s.velocity);
+ VectorCopy(PRVM_clientedictvector(ent, mins), s.mins);
+ VectorCopy(PRVM_clientedictvector(ent, maxs), s.maxs);
+ s.crouched = ((int)PRVM_clientedictfloat(ent, pmove_flags) & PMF_DUCKED) != 0;
+ s.waterjumptime = 0; // FIXME where do we get this from? FTEQW lacks support for this too
+ s.cmd.canjump = ((int)PRVM_clientedictfloat(ent, pmove_flags) & PMF_JUMP_HELD) == 0;
+ }
- ent = PRVM_G_EDICT(OFS_PARM0);
- VectorCopy(PRVM_clientedictvector(ent, origin), s.origin);
- VectorCopy(PRVM_clientedictvector(ent, velocity), s.velocity);
- VectorCopy(PRVM_clientedictvector(ent, mins), s.mins);
- VectorCopy(PRVM_clientedictvector(ent, maxs), s.maxs);
- s.crouched = ((int)PRVM_clientedictfloat(ent, pmove_flags) & PMF_DUCKED) != 0;
- s.waterjumptime = 0; // FIXME where do we get this from? FTEQW lacks support for this too
VectorCopy(PRVM_clientglobalvector(input_angles), s.cmd.viewangles);
s.cmd.forwardmove = PRVM_clientglobalvector(input_movevalues)[0];
s.cmd.sidemove = PRVM_clientglobalvector(input_movevalues)[1];
s.cmd.upmove = PRVM_clientglobalvector(input_movevalues)[2];
s.cmd.buttons = PRVM_clientglobalfloat(input_buttons);
s.cmd.frametime = PRVM_clientglobalfloat(input_timelength);
- s.cmd.canjump = ((int)PRVM_clientedictfloat(ent, pmove_flags) & PMF_JUMP_HELD) == 0;
s.cmd.jump = (s.cmd.buttons & 2) != 0;
s.cmd.crouch = (s.cmd.buttons & 16) != 0;
- CL_ClientMovement_PlayerMove(&s);
+ CL_ClientMovement_PlayerMove_Frame(&s);
- VectorCopy(s.origin, PRVM_clientedictvector(ent, origin));
- VectorCopy(s.velocity, PRVM_clientedictvector(ent, velocity));
- PRVM_clientedictfloat(ent, pmove_flags) =
- (s.crouched ? PMF_DUCKED : 0) |
- (s.cmd.canjump ? 0 : PMF_JUMP_HELD);
+ if(ent == prog->edicts)
+ {
+ // deprecated use
+ VectorCopy(s.origin, PRVM_clientglobalvector(pmove_org));
+ VectorCopy(s.velocity, PRVM_clientglobalvector(pmove_vel));
+ PRVM_clientglobalfloat(pmove_jump_held) = !s.cmd.canjump;
+ PRVM_clientglobalfloat(pmove_waterjumptime) = s.waterjumptime;
+ }
+ else
+ {
+ // new use
+ VectorCopy(s.origin, PRVM_clientedictvector(ent, origin));
+ VectorCopy(s.velocity, PRVM_clientedictvector(ent, velocity));
+ PRVM_clientedictfloat(ent, pmove_flags) =
+ (s.crouched ? PMF_DUCKED : 0) |
+ (s.cmd.canjump ? 0 : PMF_JUMP_HELD) |
+ (s.onground ? PMF_ONGROUND : 0);
+ }
}
//#348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
&& model->animscenes)
{
VM_GenerateFrameGroupBlend(prog, ent->priv.server->framegroupblend, ent);
- VM_FrameBlendFromFrameGroupBlend(ent->priv.server->frameblend, ent->priv.server->framegroupblend, model);
+ VM_FrameBlendFromFrameGroupBlend(ent->priv.server->frameblend, ent->priv.server->framegroupblend, model, cl.time);
VM_UpdateEdictSkeleton(prog, ent, model, ent->priv.server->frameblend);
return Mod_Alias_GetTagMatrix(model, ent->priv.server->frameblend, &ent->priv.server->skeleton, tagindex, out);
}
{
tag_index = CL_GetTagIndex(prog, ent, tag_name);
if (tag_index == 0)
- Con_DPrintf("VM_CL_gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
+ if(developer_extra.integer)
+ Con_DPrintf("VM_CL_gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
}
PRVM_G_FLOAT(OFS_RETURN) = tag_index;
}
VectorScale(le, -1, PRVM_clientglobalvector(v_right));
model = CL_GetModelFromEdict(e);
VM_GenerateFrameGroupBlend(prog, e->priv.server->framegroupblend, e);
- VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model);
+ VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model, cl.time);
VM_UpdateEdictSkeleton(prog, e, model, e->priv.server->frameblend);
CL_GetExtendedTagInfo(prog, e, tagindex, &parentindex, &tagname, &tag_localmatrix);
Matrix4x4_ToVectors(&tag_localmatrix, fo, le, up, trans);
VectorAdd(PRVM_serveredictvector(viewee, origin), PRVM_serveredictvector(viewee, maxs), ma);
#if 1
- if(!sv.worldmodel->brush.GetPVS || !sv.worldmodel->brush.BoxTouchingPVS)
+ if(!cl.worldmodel || !cl.worldmodel->brush.GetPVS || !cl.worldmodel->brush.BoxTouchingPVS)
{
// no PVS support on this worldmodel... darn
PRVM_G_FLOAT(OFS_RETURN) = 3;
return;
}
- pvs = sv.worldmodel->brush.GetPVS(sv.worldmodel, viewpos);
+ pvs = cl.worldmodel->brush.GetPVS(cl.worldmodel, viewpos);
if(!pvs)
{
// viewpos isn't in any PVS... darn
PRVM_G_FLOAT(OFS_RETURN) = 2;
return;
}
- PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, pvs, mi, ma);
+ PRVM_G_FLOAT(OFS_RETURN) = cl.worldmodel->brush.BoxTouchingPVS(cl.worldmodel, pvs, mi, ma);
#else
// using fat PVS like FTEQW does (slow)
- if(!sv.worldmodel->brush.FatPVS || !sv.worldmodel->brush.BoxTouchingPVS)
+ if(!cl.worldmodel || !cl.worldmodel->brush.FatPVS || !cl.worldmodel->brush.BoxTouchingPVS)
{
// no PVS support on this worldmodel... darn
PRVM_G_FLOAT(OFS_RETURN) = 3;
return;
}
- fatpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, viewpos, 8, fatpvs, sizeof(fatpvs), false);
+ fatpvsbytes = cl.worldmodel->brush.FatPVS(cl.worldmodel, viewpos, 8, fatpvs, sizeof(fatpvs), false);
if(!fatpvsbytes)
{
// viewpos isn't in any PVS... darn
PRVM_G_FLOAT(OFS_RETURN) = 2;
return;
}
- PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, fatpvs, mi, ma);
+ PRVM_G_FLOAT(OFS_RETURN) = cl.worldmodel->brush.BoxTouchingPVS(cl.worldmodel, fatpvs, mi, ma);
#endif
}
lastbone = min(lastbone, model->num_bones - 1);
lastbone = min(lastbone, skeleton->model->num_bones - 1);
VM_GenerateFrameGroupBlend(prog, framegroupblend, ed);
- VM_FrameBlendFromFrameGroupBlend(frameblend, framegroupblend, model);
+ VM_FrameBlendFromFrameGroupBlend(frameblend, framegroupblend, model, cl.time);
blendfrac = 1.0f - retainfrac;
for (numblends = 0;numblends < MAX_FRAMEBLENDS && frameblend[numblends].lerp;numblends++)
frameblend[numblends].lerp *= blendfrac;
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_FromBonePose7s(&matrix, model->num_posescale, model->data_poses7s + 7 * (frameblend[blendindex].subframe * model->num_bones + bonenum));
Matrix4x4_Accumulate(&blendedmatrix, &matrix, frameblend[blendindex].lerp);
}
skeleton->relativetransforms[bonenum] = blendedmatrix;
R_GetCubemap(name);
}
+#define REFDEFFLAG_TELEPORTED 1
+#define REFDEFFLAG_JUMPING 2
+#define REFDEFFLAG_DEAD 4
+#define REFDEFFLAG_INTERMISSION 8
+static void VM_CL_V_CalcRefdef(prvm_prog_t *prog)
+{
+ matrix4x4_t entrendermatrix;
+ vec3_t clviewangles;
+ vec3_t clvelocity;
+ qboolean teleported;
+ qboolean clonground;
+ qboolean clcmdjump;
+ qboolean cldead;
+ qboolean clintermission;
+ float clstatsviewheight;
+ prvm_edict_t *ent;
+ int flags;
+
+ VM_SAFEPARMCOUNT(2, VM_CL_V_CalcRefdef);
+ ent = PRVM_G_EDICT(OFS_PARM0);
+ flags = PRVM_G_FLOAT(OFS_PARM1);
+
+ // use the CL_GetTagMatrix function on self to ensure consistent behavior (duplicate code would be bad)
+ CL_GetTagMatrix(prog, &entrendermatrix, ent, 0);
+
+ VectorCopy(cl.csqc_viewangles, clviewangles);
+ teleported = (flags & REFDEFFLAG_TELEPORTED) != 0;
+ clonground = ((int)PRVM_clientedictfloat(ent, pmove_flags) & PMF_ONGROUND) != 0;
+ clcmdjump = (flags & REFDEFFLAG_JUMPING) != 0;
+ clstatsviewheight = PRVM_clientedictvector(ent, view_ofs)[2];
+ cldead = (flags & REFDEFFLAG_DEAD) != 0;
+ clintermission = (flags & REFDEFFLAG_INTERMISSION) != 0;
+ VectorCopy(PRVM_clientedictvector(ent, velocity), clvelocity);
+
+ V_CalcRefdefUsing(&entrendermatrix, clviewangles, teleported, clonground, clcmdjump, clstatsviewheight, cldead, clintermission, clvelocity);
+
+ VectorCopy(cl.csqc_vieworiginfromengine, cl.csqc_vieworigin);
+ VectorCopy(cl.csqc_viewanglesfromengine, cl.csqc_viewangles);
+ CSQC_R_RecalcView();
+}
+
//============================================================================
// To create a almost working builtin file from this replace:
VM_log, // #532
VM_getsoundtime, // #533 float(entity e, float channel) getsoundtime = #533; (DP_SND_GETSOUNDTIME)
VM_soundlength, // #534 float(string sample) soundlength = #534; (DP_SND_GETSOUNDTIME)
-NULL, // #535
-NULL, // #536
-NULL, // #537
-NULL, // #538
+VM_buf_loadfile, // #535 float(string filename, float bufhandle) buf_loadfile (DP_QC_STRINGBUFFERS_EXT_WIP)
+VM_buf_writefile, // #536 float(float filehandle, float bufhandle, float startpos, float numstrings) buf_writefile (DP_QC_STRINGBUFFERS_EXT_WIP)
+VM_bufstr_find, // #537 float(float bufhandle, string match, float matchrule, float startpos) bufstr_find (DP_QC_STRINGBUFFERS_EXT_WIP)
+VM_matchpattern, // #538 float(string s, string pattern, float matchrule) matchpattern (DP_QC_STRINGBUFFERS_EXT_WIP)
NULL, // #539
VM_physics_enable, // #540 void(entity e, float physics_enabled) physics_enable = #540; (DP_PHYSICS_ODE)
VM_physics_addforce, // #541 void(entity e, vector force, vector relative_ofs) physics_addforce = #541; (DP_PHYSICS_ODE)
NULL, // #637
VM_CL_RotateMoves, // #638
VM_digest_hex, // #639
-NULL, // #640
+VM_CL_V_CalcRefdef, // #640 void(entity e) V_CalcRefdef (DP_CSQC_V_CALCREFDEF)
+NULL, // #641
};
const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);
projects / xonotic / darkplaces.git / blobdiff