// Client prog handling
//[515]: omg !!! optimize it ! a lot of hacks here and there also :P
-#define CSQC_RETURNVAL prog->globals.generic[OFS_RETURN]
+#define CSQC_RETURNVAL prog->globals.fp[OFS_RETURN]
#define CSQC_BEGIN
#define CSQC_END
prvm_prog_t *prog = CLVM_prog;
if(!cl.csqc_loaded)
return;
- CSQC_BEGIN
- VM_ClearTraceGlobals(prog);
- PRVM_clientglobalfloat(trace_networkentity) = 0;
- CSQC_END
+CSQC_BEGIN
+ VM_ClearTraceGlobals(prog);
+ PRVM_clientglobalfloat(trace_networkentity) = 0;
+CSQC_END
}
//[515]: these are required funcs
}
//[515]: set globals before calling R_UpdateView, WEIRD CRAP
-static void CSQC_SetGlobals (void)
+static void CSQC_SetGlobals (double frametime)
{
+ vec3_t pmove_org;
prvm_prog_t *prog = CLVM_prog;
CSQC_BEGIN
PRVM_clientglobalfloat(time) = cl.time;
- PRVM_clientglobalfloat(frametime) = max(0, cl.time - cl.oldtime);
+ PRVM_clientglobalfloat(cltime) = host.realtime; // Spike named it that way.
+ PRVM_clientglobalfloat(frametime) = frametime;
PRVM_clientglobalfloat(servercommandframe) = cls.servermovesequence;
PRVM_clientglobalfloat(clientcommandframe) = cl.movecmd[0].sequence;
VectorCopy(cl.viewangles, PRVM_clientglobalvector(input_angles));
VectorCopy(cl.csqc_vieworiginfromengine, cl.csqc_vieworigin);
VectorCopy(cl.csqc_viewanglesfromengine, cl.csqc_viewangles);
- // LordHavoc: Spike says not to do this, but without pmove_org the
+ // LadyHavoc: Spike says not to do this, but without pmove_org the
// CSQC is useless as it can't alter the view origin without
// completely replacing it
- Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, PRVM_clientglobalvector(pmove_org));
+ Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, pmove_org);
+ VectorCopy(pmove_org, PRVM_clientglobalvector(pmove_org));
VectorCopy(cl.movement_velocity, PRVM_clientglobalvector(pmove_vel));
PRVM_clientglobalfloat(pmove_onground) = cl.onground;
PRVM_clientglobalfloat(pmove_inwater) = cl.inwater;
VectorCopy(cl.punchvector, PRVM_clientglobalvector(view_punchvector));
PRVM_clientglobalfloat(maxclients) = cl.maxclients;
+ PRVM_clientglobalfloat(player_localentnum) = cl.viewentity;
+
CSQC_R_RecalcView();
CSQC_END
}
}
extern cvar_t cl_noplayershadow;
-extern cvar_t r_equalize_entities_fullbright;
qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
{
prvm_prog_t *prog = CLVM_prog;
float scale;
entity_render_t *entrender;
dp_model_t *model;
+ prvm_vec3_t modellight_origin;
model = CL_GetModelFromEdict(ed);
if (!model)
if (!VectorLength2(entrender->glowmod))
VectorSet(entrender->glowmod, 1, 1, 1);
- // LordHavoc: use the CL_GetTagMatrix function on self to ensure consistent behavior (duplicate code would be bad)
- CL_GetTagMatrix(prog, &entrender->matrix, ed, 0);
+ // LadyHavoc: use the CL_GetTagMatrix function on self to ensure consistent behavior (duplicate code would be bad)
+ // this also sets the custommodellight_origin for us
+ CL_GetTagMatrix(prog, &entrender->matrix, ed, 0, modellight_origin);
+ VectorCopy(modellight_origin, entrender->custommodellight_origin);
// set up the animation data
VM_GenerateFrameGroupBlend(prog, ed->priv.server->framegroupblend, ed);
- VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model);
+ VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model, cl.time);
VM_UpdateEdictSkeleton(prog, ed, model, ed->priv.server->frameblend);
if (PRVM_clientedictfloat(ed, shadertime)) // hack for csprogs.dat files that do not set shadertime, leaves the value at entity spawn time
entrender->shadertime = PRVM_clientedictfloat(ed, shadertime);
// model light
if (renderflags & RF_MODELLIGHT)
{
- if(PRVM_clientedictvector(ed, modellight_ambient)) VectorCopy(PRVM_clientedictvector(ed, modellight_ambient), entrender->modellight_ambient);
- if(PRVM_clientedictvector(ed, modellight_diffuse)) VectorCopy(PRVM_clientedictvector(ed, modellight_diffuse), entrender->modellight_diffuse);
- if(PRVM_clientedictvector(ed, modellight_dir)) VectorCopy(PRVM_clientedictvector(ed, modellight_dir), entrender->modellight_lightdir);
+ if (PRVM_clientedictvector(ed, modellight_ambient)) VectorCopy(PRVM_clientedictvector(ed, modellight_ambient), entrender->custommodellight_ambient); else VectorClear(entrender->custommodellight_ambient);
+ if (PRVM_clientedictvector(ed, modellight_diffuse)) VectorCopy(PRVM_clientedictvector(ed, modellight_diffuse), entrender->custommodellight_diffuse); else VectorClear(entrender->custommodellight_diffuse);
+ if (PRVM_clientedictvector(ed, modellight_dir)) VectorCopy(PRVM_clientedictvector(ed, modellight_dir), entrender->custommodellight_lightdir); else VectorClear(entrender->custommodellight_lightdir);
entrender->flags |= RENDER_CUSTOMIZEDMODELLIGHT;
}
if(renderflags & RF_WORLDOBJECT) entrender->flags |= RENDER_WORLDOBJECT;
if(renderflags & RF_DEPTHHACK) entrender->flags |= RENDER_NODEPTHTEST;
if(renderflags & RF_ADDITIVE) entrender->flags |= RENDER_ADDITIVE;
- }
-
- // walk attachments to find RENDER_EXTERIORMODEL status
- {
- prvm_edict_t *ent = ed;
- prvm_edict_t *v = PRVM_EDICT_NUM(CL_VM_GetViewEntity());
- int attachloop = 0;
- for(;;)
- {
- if(attachloop >= 256)
- break;
- if(ent == v)
- {
- entrender->flags |= RENDER_EXTERIORMODEL;
- break;
- }
- if (PRVM_clientedictedict(ent, tag_entity))
- ent = PRVM_EDICT_NUM(PRVM_clientedictedict(ent, tag_entity));
- else
- break;
- attachloop++;
- }
+ if(renderflags & RF_DYNAMICMODELLIGHT) entrender->flags |= RENDER_DYNAMICMODELLIGHT;
}
c = (int)PRVM_clientedictfloat(ed, colormap);
{
if (!(entrender->effects & EF_FULLBRIGHT) && !(renderflags & RF_FULLBRIGHT))
entrender->flags |= RENDER_LIGHT;
- else if(r_equalize_entities_fullbright.integer)
- entrender->flags |= RENDER_LIGHT | RENDER_EQUALIZE;
}
// hide player shadow during intermission or nehahra movie
if (!(entrender->effects & (EF_NOSHADOW | EF_ADDITIVE | EF_NODEPTHTEST))
entrender->flags |= RENDER_ADDITIVE;
if (entrender->effects & EF_DOUBLESIDED)
entrender->flags |= RENDER_DOUBLESIDED;
+ if (entrender->effects & EF_DYNAMICMODELLIGHT)
+ entrender->flags |= RENDER_DYNAMICMODELLIGHT;
// make the other useful stuff
memcpy(entrender->framegroupblend, ed->priv.server->framegroupblend, sizeof(ed->priv.server->framegroupblend));
CL_UpdateRenderEntity(entrender);
+
// override animation data with full control
memcpy(entrender->frameblend, ed->priv.server->frameblend, sizeof(ed->priv.server->frameblend));
if (ed->priv.server->skeleton.relativetransforms)
// 1 = keyup, key, character (EXT_CSQC)
// 2 = mousemove relative, x, y (EXT_CSQC)
// 3 = mousemove absolute, x, y (DP_CSQC)
-qboolean CL_VM_InputEvent (int eventtype, int x, int y)
+qboolean CL_VM_InputEvent (int eventtype, float x, float y)
{
prvm_prog_t *prog = CLVM_prog;
qboolean r;
if(!cl.csqc_loaded)
return false;
- CSQC_BEGIN
- if (!PRVM_clientfunction(CSQC_InputEvent))
- r = false;
- else
- {
- PRVM_clientglobalfloat(time) = cl.time;
- PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
- PRVM_G_FLOAT(OFS_PARM0) = eventtype;
- PRVM_G_FLOAT(OFS_PARM1) = x; // key or x
- PRVM_G_FLOAT(OFS_PARM2) = y; // ascii or y
- prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_InputEvent), "QC function CSQC_InputEvent is missing");
- r = CSQC_RETURNVAL != 0;
- }
- CSQC_END
+CSQC_BEGIN
+ if (!PRVM_clientfunction(CSQC_InputEvent))
+ r = false;
+ else
+ {
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
+ PRVM_G_FLOAT(OFS_PARM0) = eventtype;
+ PRVM_G_FLOAT(OFS_PARM1) = x; // key or x
+ PRVM_G_FLOAT(OFS_PARM2) = y; // ascii or y
+ prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_InputEvent), "QC function CSQC_InputEvent is missing");
+ r = CSQC_RETURNVAL != 0;
+ }
+CSQC_END
return r;
}
extern r_refdef_view_t csqc_original_r_refdef_view;
extern r_refdef_view_t csqc_main_r_refdef_view;
-qboolean CL_VM_UpdateView (void)
+qboolean CL_VM_UpdateView (double frametime)
{
prvm_prog_t *prog = CLVM_prog;
vec3_t emptyvector;
return false;
R_TimeReport("pre-UpdateView");
CSQC_BEGIN
- r_refdef.view.ismain = true;
csqc_original_r_refdef_view = r_refdef.view;
csqc_main_r_refdef_view = r_refdef.view;
//VectorCopy(cl.viewangles, oldangles);
PRVM_clientglobalfloat(time) = cl.time;
PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
- CSQC_SetGlobals();
+ CSQC_SetGlobals(frametime);
// clear renderable entity and light lists to prevent crashes if the
// CSQC_UpdateView function does not call R_ClearScene as it should
r_refdef.scene.numentities = 0;
r_refdef.scene.numlights = 0;
+ // polygonbegin without draw2d arg has to guess
+ prog->polygonbegin_guess2d = false;
+ // free memory for resources that are no longer referenced
+ PRVM_GarbageCollection(prog);
// pass in width and height as parameters (EXT_CSQC_1)
PRVM_G_FLOAT(OFS_PARM0) = vid.width;
PRVM_G_FLOAT(OFS_PARM1) = vid.height;
return true;
}
-qboolean CL_VM_ConsoleCommand (const char *cmd)
+qboolean CL_VM_ConsoleCommand (const char *text)
{
prvm_prog_t *prog = CLVM_prog;
int restorevm_tempstringsbuf_cursize;
PRVM_clientglobalfloat(time) = cl.time;
PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
- PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, cmd);
+ PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, text);
prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_ConsoleCommand), "QC function CSQC_ConsoleCommand is missing");
prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
r = CSQC_RETURNVAL != 0;
// temporarily so that it can be set by the cvar command,
// and then reprotect it afterwards
int crcflags = csqc_progcrc.flags;
- int sizeflags = csqc_progcrc.flags;
csqc_progcrc.flags &= ~CVAR_READONLY;
csqc_progsize.flags &= ~CVAR_READONLY;
- Cmd_ExecuteString (msg, src_command, true);
- csqc_progcrc.flags = crcflags;
- csqc_progsize.flags = sizeflags;
+ Cmd_ExecuteString(&cmd_client, msg, src_command, true);
+ csqc_progcrc.flags = csqc_progsize.flags = crcflags;
return;
}
l = sizeof(buf) - 1;
strlcpy(buf, p, l + 1); // strlcpy needs a + 1 as it includes the newline!
- Cmd_ExecuteString(buf, src_command, true);
+ Cmd_ExecuteString(&cmd_client, buf, src_command, true);
p += l;
if(*p == '\n')
else
break; // end of string or overflow
}
- Cmd_ExecuteString("curl --clear_autodownload", src_command, true); // don't inhibit CSQC loading
+ Cmd_ExecuteString(&cmd_client, "curl --clear_autodownload", src_command, true); // don't inhibit CSQC loading
return;
}
if(!cl.csqc_loaded)
{
- Cbuf_AddText(msg);
+ Cbuf_AddText(&cmd_client, msg);
return;
}
CSQC_BEGIN
prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
}
else
- Cbuf_AddText(msg);
+ Cbuf_AddText(&cmd_client, msg);
CSQC_END
}
{
prvm_prog_t *prog = CLVM_prog;
size_t i;
- if(!cl.csqc_loaded)
- {
- Con_Print(msg);
- return;
- }
CSQC_BEGIN
- if(PRVM_clientfunction(CSQC_Parse_Print))
+ if(cl.csqc_loaded && PRVM_clientfunction(CSQC_Parse_Print))
{
// FIXME: is this bugged?
i = strlen(msg)-1;
{
prvm_prog_t *prog = CLVM_prog;
int restorevm_tempstringsbuf_cursize;
- if(!cl.csqc_loaded)
- {
- SCR_CenterPrint(msg);
- return;
- }
CSQC_BEGIN
- if(PRVM_clientfunction(CSQC_Parse_CenterPrint))
+ if(cl.csqc_loaded && PRVM_clientfunction(CSQC_Parse_CenterPrint))
{
PRVM_clientglobalfloat(time) = cl.time;
PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
CSQC_END
}
}
-qboolean CL_VM_Event_Sound(int sound_num, float volume, int channel, float attenuation, int ent, vec3_t pos, int flags, float speed)
+qboolean CL_VM_Event_Sound(int sound_num, float fvolume, int channel, float attenuation, int ent, vec3_t pos, int flags, float speed)
{
prvm_prog_t *prog = CLVM_prog;
qboolean r = false;
PRVM_G_FLOAT(OFS_PARM0) = ent;
PRVM_G_FLOAT(OFS_PARM1) = CHAN_ENGINE2USER(channel);
PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(prog, cl.sound_name[sound_num] );
- PRVM_G_FLOAT(OFS_PARM3) = volume;
+ PRVM_G_FLOAT(OFS_PARM3) = fvolume;
PRVM_G_FLOAT(OFS_PARM4) = attenuation;
VectorCopy(pos, PRVM_G_VECTOR(OFS_PARM5) );
PRVM_G_FLOAT(OFS_PARM6) = speed * 100.0f;
}
else
{
- // LordHavoc: removing an entity that is already gone on
+ // LadyHavoc: removing an entity that is already gone on
// the csqc side is possible for legitimate reasons (such
// as a repeat of the remove message), so no warning is
// needed
// link every entity except world
for (i = 1, ent = prog->edicts;i < prog->num_edicts;i++, ent++)
- if (!ent->priv.server->free)
+ if (!ent->priv.server->free && !VectorCompare(PRVM_clientedictvector(ent, absmin), PRVM_clientedictvector(ent, absmax)))
CL_LinkEdict(ent);
}
R_DecalSystem_Reset(&entrender->decalsystem);
memset(entrender, 0, sizeof(*entrender));
World_UnlinkEdict(ed);
- memset(ed->fields.vp, 0, prog->entityfields * 4);
+ memset(ed->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
VM_RemoveEdictSkeleton(prog, ed);
World_Physics_RemoveFromEntity(&cl.world, ed);
World_Physics_RemoveJointFromEntity(&cl.world, ed);
qboolean MakeDownloadPacket(const char *filename, unsigned char *data, size_t len, int crc, int cnt, sizebuf_t *buf, int protocol)
{
int packetsize = buf->maxsize - 7; // byte short long
- int npackets = (len + packetsize - 1) / (packetsize);
+ int npackets = ((int)len + packetsize - 1) / (packetsize);
char vabuf[1024];
if(protocol == PROTOCOL_QUAKEWORLD)
else if(cnt >= 1 && cnt <= npackets)
{
unsigned long thispacketoffset = (cnt - 1) * packetsize;
- int thispacketsize = len - thispacketoffset;
+ int thispacketsize = (int)len - thispacketoffset;
if(thispacketsize > packetsize)
thispacketsize = packetsize;
return;
// see if the requested csprogs.dat file matches the requested crc
- csprogsdatacrc = -1;
if (!cls.demoplayback || csqc_usedemoprogs.integer)
{
csprogsfn = va(vabuf, sizeof(vabuf), "dlcache/%s.%i.%i", csqc_progname.string, requiredsize, requiredcrc);
- csprogsdata = FS_LoadFile(csprogsfn, tempmempool, true, &csprogsdatasize);
+ if(cls.caughtcsprogsdata && cls.caughtcsprogsdatasize == requiredsize && CRC_Block(cls.caughtcsprogsdata, (size_t)cls.caughtcsprogsdatasize) == requiredcrc)
+ {
+ Con_DPrintf("Using buffered \"%s\"\n", csprogsfn);
+ csprogsdata = cls.caughtcsprogsdata;
+ csprogsdatasize = cls.caughtcsprogsdatasize;
+ cls.caughtcsprogsdata = NULL;
+ cls.caughtcsprogsdatasize = 0;
+ }
+ else
+ {
+ Con_DPrintf("Not using buffered \"%s\" (buffered: %p, %d)\n", csprogsfn, (void *)cls.caughtcsprogsdata, (int) cls.caughtcsprogsdatasize);
+ csprogsdata = FS_LoadFile(csprogsfn, tempmempool, true, &csprogsdatasize);
+ }
}
if (!csprogsdata)
{
{
if (cls.demoplayback)
{
- Con_Printf("^1Warning: Your %s is not the same version as the demo was recorded with (CRC/size are %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
+ Con_Printf(CON_WARN "Warning: Your %s is not the same version as the demo was recorded with (CRC/size are %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
// Mem_Free(csprogsdata);
// return;
// We WANT to continue here, and play the demo with different csprogs!
else
{
Mem_Free(csprogsdata);
- Con_Printf("^1Your %s is not the same version as the server (CRC is %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
+ Con_Printf(CON_ERROR "Your %s is not the same version as the server (CRC is %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
CL_Disconnect();
return;
}
if (requiredcrc >= 0)
{
if (cls.demoplayback)
- Con_Printf("CL_VM_Init: demo requires CSQC, but \"%s\" wasn't found\n", csqc_progname.string);
+ Con_Printf(CON_ERROR "CL_VM_Init: demo requires CSQC, but \"%s\" wasn't found\n", csqc_progname.string);
else
- Con_Printf("CL_VM_Init: server requires CSQC, but \"%s\" wasn't found\n", csqc_progname.string);
+ Con_Printf(CON_ERROR "CL_VM_Init: server requires CSQC, but \"%s\" wasn't found\n", csqc_progname.string);
CL_Disconnect();
}
return;
}
- PRVM_Prog_Init(prog);
+ PRVM_Prog_Init(prog, &cmd_client);
// allocate the mempools
prog->progs_mempool = Mem_AllocPool(csqc_progname.string, 0, NULL);
prog->error_cmd = Host_Error;
prog->ExecuteProgram = CLVM_ExecuteProgram;
- PRVM_Prog_Load(prog, csprogsfn, cl_numrequiredfunc, cl_required_func, CL_REQFIELDS, cl_reqfields, CL_REQGLOBALS, cl_reqglobals);
+ PRVM_Prog_Load(prog, csprogsfn, csprogsdata, csprogsdatasize, cl_numrequiredfunc, cl_required_func, CL_REQFIELDS, cl_reqfields, CL_REQGLOBALS, cl_reqglobals);
if (!prog->loaded)
{
- Host_Error("CSQC %s ^2failed to load\n", csprogsfn);
+ Host_Error("CSQC %s failed to load\n", csprogsfn);
if(!sv.active)
CL_Disconnect();
Mem_Free(csprogsdata);
return;
}
- Con_DPrintf("CSQC %s ^5loaded (crc=%i, size=%i)\n", csprogsfn, csprogsdatacrc, (int)csprogsdatasize);
-
if(cls.demorecording)
{
if(cls.demo_lastcsprogssize != csprogsdatasize || cls.demo_lastcsprogscrc != csprogsdatacrc)
PRVM_clientglobaledict(self) = 0;
PRVM_clientglobalstring(mapname) = PRVM_SetEngineString(prog, cl.worldname);
- PRVM_clientglobalfloat(player_localentnum) = cl.playerentity;
+ PRVM_clientglobalfloat(player_localnum) = cl.realplayerentity - 1;
+ PRVM_clientglobalfloat(player_localentnum) = cl.viewentity;
// set map description (use world entity 0)
PRVM_clientedictstring(prog->edicts, message) = PRVM_SetEngineString(prog, cl.worldmessage);
VectorCopy(cl.world.mins, PRVM_clientedictvector(prog->edicts, mins));
VectorCopy(cl.world.maxs, PRVM_clientedictvector(prog->edicts, maxs));
+ VectorCopy(cl.world.mins, PRVM_clientedictvector(prog->edicts, absmin));
+ VectorCopy(cl.world.maxs, PRVM_clientedictvector(prog->edicts, absmax));
// call the prog init
prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Init), "QC function CSQC_Init is missing");
+ // Once CSQC_Init was called, we consider csqc code fully initialized.
+ prog->inittime = host.realtime;
+
cl.csqc_loaded = true;
cl.csqc_vidvars.drawcrosshair = false;
void CL_VM_ShutDown (void)
{
prvm_prog_t *prog = CLVM_prog;
- Cmd_ClearCsqcFuncs();
+ Cmd_ClearCSQCCommands(&cmd_client);
//Cvar_SetValueQuick(&csqc_progcrc, -1);
//Cvar_SetValueQuick(&csqc_progsize, -1);
if(!cl.csqc_loaded)
return;
- CSQC_BEGIN
+CSQC_BEGIN
+ if (prog->loaded)
+ {
PRVM_clientglobalfloat(time) = cl.time;
PRVM_clientglobaledict(self) = 0;
if (PRVM_clientfunction(CSQC_Shutdown))
prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Shutdown), "QC function CSQC_Shutdown is missing");
- PRVM_Prog_Reset(prog);
- CSQC_END
+ }
+ PRVM_Prog_Reset(prog);
+CSQC_END
Con_DPrint("CSQC ^1unloaded\n");
cl.csqc_loaded = false;
}
CSQC_BEGIN;
- // FIXME consider attachments here!
-
ed = PRVM_EDICT_NUM(entnum - MAX_EDICTS);
if(!ed->priv.required->free)
{
mod = CL_GetModelFromEdict(ed);
VectorCopy(PRVM_clientedictvector(ed, origin), out);
- if(CL_GetTagMatrix(prog, &matrix, ed, 0) == 0)
+ if(CL_GetTagMatrix(prog, &matrix, ed, 0, NULL) == 0)
Matrix4x4_OriginFromMatrix(&matrix, out);
if (mod && mod->soundfromcenter)
VectorMAMAM(1.0f, out, 0.5f, mod->normalmins, 0.5f, mod->normalmaxs, out);
if(PRVM_clientedictfunction(ed, camera_transform))
{
ret = true;
- if(viewmatrix || clipplane || visorigin)
+ if(viewmatrix && clipplane && visorigin)
{
Matrix4x4_ToVectors(viewmatrix, forward, left, up, origin);
AnglesFromVectors(ang, forward, up, false);
Matrix4x4_Invert_Full(&mat, viewmatrix);
Matrix4x4_FromVectors(viewmatrix, forward, left, up, origin);
Matrix4x4_Concat(&matq, viewmatrix, &mat);
- Matrix4x4_TransformPositivePlane(&matq, clipplane->normal[0], clipplane->normal[1], clipplane->normal[2], clipplane->dist, &clipplane->normal[0]);
+ Matrix4x4_TransformPositivePlane(&matq, clipplane->normal[0], clipplane->normal[1], clipplane->normal[2], clipplane->dist, clipplane->normal_and_dist);
}
}
CSQC_END
int CL_VM_GetViewEntity(void)
{
if(cl.csqc_server2csqcentitynumber[cl.viewentity])
- return cl.csqc_server2csqcentitynumber[cl.viewentity];
+ return cl.csqc_server2csqcentitynumber[cl.viewentity] + MAX_EDICTS;
return cl.viewentity;
}