Add GL_ExtensionSupported in vid_null.c because vid_shared.c relies on
[xonotic/darkplaces.git] / csprogs.c
index 77e3a16..68dbd83 100644 (file)
--- a/csprogs.c
+++ b/csprogs.c
 // 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_BEGIN             csqc_tmpprog=prog;prog=0;PRVM_SetProg(PRVM_CLIENTPROG);
-#define CSQC_END               prog=csqc_tmpprog;
-
-static prvm_prog_t *csqc_tmpprog;
+#define CSQC_RETURNVAL prog->globals.fp[OFS_RETURN]
+#define CSQC_BEGIN
+#define CSQC_END
 
 void CL_VM_PreventInformationLeaks(void)
 {
+       prvm_prog_t *prog = CLVM_prog;
        if(!cl.csqc_loaded)
                return;
        CSQC_BEGIN
-               VM_ClearTraceGlobals();
+               VM_ClearTraceGlobals(prog);
                PRVM_clientglobalfloat(trace_networkentity) = 0;
        CSQC_END
 }
@@ -196,28 +195,9 @@ prvm_required_field_t cl_reqglobals[] =
 #undef PRVM_DECLARE_function
 };
 
-void CL_VM_Error (const char *format, ...) DP_FUNC_PRINTF(1);
-void CL_VM_Error (const char *format, ...)     //[515]: hope it will be never executed =)
-{
-       char errorstring[4096];
-       va_list argptr;
-
-       va_start (argptr, format);
-       dpvsnprintf (errorstring, sizeof(errorstring), format, argptr);
-       va_end (argptr);
-//     Con_Printf( "CL_VM_Error: %s\n", errorstring );
-
-       PRVM_Crash();
-       cl.csqc_loaded = false;
-
-       Cvar_SetValueQuick(&csqc_progcrc, -1);
-       Cvar_SetValueQuick(&csqc_progsize, -1);
-
-//     Host_AbortCurrentFrame();       //[515]: hmmm... if server says it needs csqc then client MUST disconnect
-       Host_Error("CL_VM_Error: %s", errorstring);
-}
 void CL_VM_UpdateDmgGlobals (int dmg_take, int dmg_save, vec3_t dmg_origin)
 {
+       prvm_prog_t *prog = CLVM_prog;
        if(cl.csqc_loaded)
        {
                CSQC_BEGIN
@@ -230,6 +210,7 @@ void CL_VM_UpdateDmgGlobals (int dmg_take, int dmg_save, vec3_t dmg_origin)
 
 void CSQC_UpdateNetworkTimes(double newtime, double oldtime)
 {
+       prvm_prog_t *prog = CLVM_prog;
        if(!cl.csqc_loaded)
                return;
        CSQC_BEGIN
@@ -240,12 +221,14 @@ void CSQC_UpdateNetworkTimes(double newtime, double oldtime)
 }
 
 //[515]: set globals before calling R_UpdateView, WEIRD CRAP
-void CSQC_R_RecalcView (void);
-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) = 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));
@@ -258,7 +241,8 @@ static void CSQC_SetGlobals (void)
                // LordHavoc: 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;
@@ -268,23 +252,27 @@ static void CSQC_SetGlobals (void)
                VectorCopy(cl.punchvector, PRVM_clientglobalvector(view_punchvector));
                PRVM_clientglobalfloat(maxclients) = cl.maxclients;
 
+               PRVM_clientglobalfloat(player_localentnum) = cl.viewentity;
+
                CSQC_R_RecalcView();
        CSQC_END
 }
 
 void CSQC_Predraw (prvm_edict_t *ed)
 {
+       prvm_prog_t *prog = CLVM_prog;
        int b;
        if(!PRVM_clientedictfunction(ed, predraw))
                return;
        b = PRVM_clientglobaledict(self);
        PRVM_clientglobaledict(self) = PRVM_EDICT_TO_PROG(ed);
-       PRVM_ExecuteProgram(PRVM_clientedictfunction(ed, predraw), "CSQC_Predraw: NULL function\n");
+       prog->ExecuteProgram(prog, PRVM_clientedictfunction(ed, predraw), "CSQC_Predraw: NULL function\n");
        PRVM_clientglobaledict(self) = b;
 }
 
 void CSQC_Think (prvm_edict_t *ed)
 {
+       prvm_prog_t *prog = CLVM_prog;
        int b;
        if(PRVM_clientedictfunction(ed, think))
        if(PRVM_clientedictfloat(ed, nextthink) && PRVM_clientedictfloat(ed, nextthink) <= PRVM_clientglobalfloat(time))
@@ -292,7 +280,7 @@ void CSQC_Think (prvm_edict_t *ed)
                PRVM_clientedictfloat(ed, nextthink) = 0;
                b = PRVM_clientglobaledict(self);
                PRVM_clientglobaledict(self) = PRVM_EDICT_TO_PROG(ed);
-               PRVM_ExecuteProgram(PRVM_clientedictfunction(ed, think), "CSQC_Think: NULL function\n");
+               prog->ExecuteProgram(prog, PRVM_clientedictfunction(ed, think), "CSQC_Think: NULL function\n");
                PRVM_clientglobaledict(self) = b;
        }
 }
@@ -301,11 +289,13 @@ 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;
        int renderflags;
        int c;
        float scale;
        entity_render_t *entrender;
        dp_model_t *model;
+       prvm_vec3_t modellight_origin;
 
        model = CL_GetModelFromEdict(ed);
        if (!model)
@@ -320,6 +310,7 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
                entrender->entitynumber = edictnum + MAX_EDICTS;
                //entrender->shadertime = 0; // shadertime was set by spawn()
                entrender->flags = 0;
+               entrender->effects = 0;
                entrender->alpha = 1;
                entrender->scale = 1;
                VectorSet(entrender->colormod, 1, 1, 1);
@@ -356,13 +347,15 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
        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(&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(ed->priv.server->framegroupblend, ed);
-       VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model);
-       VM_UpdateEdictSkeleton(ed, model, ed->priv.server->frameblend);
+       VM_GenerateFrameGroupBlend(prog, ed->priv.server->framegroupblend, ed);
+       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);
 
@@ -373,9 +366,9 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
        // 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;
        }
 
@@ -386,6 +379,7 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
                if(renderflags & RF_WORLDOBJECT) entrender->flags |= RENDER_WORLDOBJECT;
                if(renderflags & RF_DEPTHHACK) entrender->flags |= RENDER_NODEPTHTEST;
                if(renderflags & RF_ADDITIVE) entrender->flags |= RENDER_ADDITIVE;
+               if(renderflags & RF_DYNAMICMODELLIGHT) entrender->flags |= RENDER_DYNAMICMODELLIGHT;
        }
 
        c = (int)PRVM_clientedictfloat(ed, colormap);
@@ -422,10 +416,13 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
                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)
@@ -440,8 +437,9 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
 // 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)
@@ -457,7 +455,7 @@ qboolean CL_VM_InputEvent (int eventtype, int x, int y)
                        PRVM_G_FLOAT(OFS_PARM0) = eventtype;
                        PRVM_G_FLOAT(OFS_PARM1) = x; // key or x
                        PRVM_G_FLOAT(OFS_PARM2) = y; // ascii or y
-                       PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_InputEvent), "QC function CSQC_InputEvent is missing");
+                       prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_InputEvent), "QC function CSQC_InputEvent is missing");
                        r = CSQC_RETURNVAL != 0;
                }
        CSQC_END
@@ -465,8 +463,10 @@ qboolean CL_VM_InputEvent (int eventtype, int x, int y)
 }
 
 extern r_refdef_view_t csqc_original_r_refdef_view;
-qboolean CL_VM_UpdateView (void)
+extern r_refdef_view_t csqc_main_r_refdef_view;
+qboolean CL_VM_UpdateView (double frametime)
 {
+       prvm_prog_t *prog = CLVM_prog;
        vec3_t emptyvector;
        emptyvector[0] = 0;
        emptyvector[1] = 0;
@@ -477,30 +477,35 @@ qboolean CL_VM_UpdateView (void)
        R_TimeReport("pre-UpdateView");
        CSQC_BEGIN
                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;
                // pass in width and height as parameters (EXT_CSQC_1)
                PRVM_G_FLOAT(OFS_PARM0) = vid.width;
                PRVM_G_FLOAT(OFS_PARM1) = vid.height;
-               PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_UpdateView), "QC function CSQC_UpdateView is missing");
+               prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_UpdateView), "QC function CSQC_UpdateView is missing");
                //VectorCopy(oldangles, cl.viewangles);
                // Dresk : Reset Dmg Globals Here
                CL_VM_UpdateDmgGlobals(0, 0, emptyvector);
-               r_refdef.view = csqc_original_r_refdef_view;
+               r_refdef.view = csqc_main_r_refdef_view;
+               R_RenderView_UpdateViewVectors(); // we have to do this, as we undid the scene render doing this for us
        CSQC_END
+
        R_TimeReport("UpdateView");
        return true;
 }
 
-extern sizebuf_t vm_tempstringsbuf;
 qboolean CL_VM_ConsoleCommand (const char *cmd)
 {
+       prvm_prog_t *prog = CLVM_prog;
        int restorevm_tempstringsbuf_cursize;
        qboolean r = false;
        if(!cl.csqc_loaded)
@@ -510,10 +515,10 @@ qboolean CL_VM_ConsoleCommand (const char *cmd)
        {
                PRVM_clientglobalfloat(time) = cl.time;
                PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
-               restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
-               PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(cmd);
-               PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_ConsoleCommand), "QC function CSQC_ConsoleCommand is missing");
-               vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
+               restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
+               PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, cmd);
+               prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_ConsoleCommand), "QC function CSQC_ConsoleCommand is missing");
+               prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
                r = CSQC_RETURNVAL != 0;
        }
        CSQC_END
@@ -522,6 +527,7 @@ qboolean CL_VM_ConsoleCommand (const char *cmd)
 
 qboolean CL_VM_Parse_TempEntity (void)
 {
+       prvm_prog_t *prog = CLVM_prog;
        int                     t;
        qboolean        r = false;
        if(!cl.csqc_loaded)
@@ -529,15 +535,15 @@ qboolean CL_VM_Parse_TempEntity (void)
        CSQC_BEGIN
        if(PRVM_clientfunction(CSQC_Parse_TempEntity))
        {
-               t = msg_readcount;
+               t = cl_message.readcount;
                PRVM_clientglobalfloat(time) = cl.time;
                PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
-               PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_TempEntity), "QC function CSQC_Parse_TempEntity is missing");
+               prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Parse_TempEntity), "QC function CSQC_Parse_TempEntity is missing");
                r = CSQC_RETURNVAL != 0;
                if(!r)
                {
-                       msg_readcount = t;
-                       msg_badread = false;
+                       cl_message.readcount = t;
+                       cl_message.badread = false;
                }
        }
        CSQC_END
@@ -546,6 +552,7 @@ qboolean CL_VM_Parse_TempEntity (void)
 
 void CL_VM_Parse_StuffCmd (const char *msg)
 {
+       prvm_prog_t *prog = CLVM_prog;
        int restorevm_tempstringsbuf_cursize;
        if(msg[0] == 'c')
        if(msg[1] == 's')
@@ -614,10 +621,10 @@ void CL_VM_Parse_StuffCmd (const char *msg)
        {
                PRVM_clientglobalfloat(time) = cl.time;
                PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
-               restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
-               PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
-               PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_StuffCmd), "QC function CSQC_Parse_StuffCmd is missing");
-               vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
+               restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
+               PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, msg);
+               prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Parse_StuffCmd), "QC function CSQC_Parse_StuffCmd is missing");
+               prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
        }
        else
                Cbuf_AddText(msg);
@@ -626,17 +633,19 @@ void CL_VM_Parse_StuffCmd (const char *msg)
 
 static void CL_VM_Parse_Print (const char *msg)
 {
+       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 = vm_tempstringsbuf.cursize;
-       PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
-       PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_Print), "QC function CSQC_Parse_Print is missing");
-       vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
+       restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
+       PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, msg);
+       prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Parse_Print), "QC function CSQC_Parse_Print is missing");
+       prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
 }
 
 void CSQC_AddPrintText (const char *msg)
 {
+       prvm_prog_t *prog = CLVM_prog;
        size_t i;
        if(!cl.csqc_loaded)
        {
@@ -670,6 +679,7 @@ void CSQC_AddPrintText (const char *msg)
 
 void CL_VM_Parse_CenterPrint (const char *msg)
 {
+       prvm_prog_t *prog = CLVM_prog;
        int restorevm_tempstringsbuf_cursize;
        if(!cl.csqc_loaded)
        {
@@ -681,10 +691,10 @@ void CL_VM_Parse_CenterPrint (const char *msg)
        {
                PRVM_clientglobalfloat(time) = cl.time;
                PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
-               restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
-               PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
-               PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_CenterPrint), "QC function CSQC_Parse_CenterPrint is missing");
-               vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
+               restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
+               PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, msg);
+               prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Parse_CenterPrint), "QC function CSQC_Parse_CenterPrint is missing");
+               prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
        }
        else
                SCR_CenterPrint(msg);
@@ -693,6 +703,7 @@ void CL_VM_Parse_CenterPrint (const char *msg)
 
 void CL_VM_UpdateIntermissionState (int intermission)
 {
+       prvm_prog_t *prog = CLVM_prog;
        if(cl.csqc_loaded)
        {
                CSQC_BEGIN
@@ -702,6 +713,7 @@ void CL_VM_UpdateIntermissionState (int intermission)
 }
 void CL_VM_UpdateShowingScoresState (int showingscores)
 {
+       prvm_prog_t *prog = CLVM_prog;
        if(cl.csqc_loaded)
        {
                CSQC_BEGIN
@@ -709,8 +721,9 @@ void CL_VM_UpdateShowingScoresState (int showingscores)
                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;
        if(cl.csqc_loaded)
        {
@@ -721,13 +734,13 @@ qboolean CL_VM_Event_Sound(int sound_num, float volume, int channel, float atten
                        PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
                        PRVM_G_FLOAT(OFS_PARM0) = ent;
                        PRVM_G_FLOAT(OFS_PARM1) = CHAN_ENGINE2USER(channel);
-                       PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(cl.sound_name[sound_num] );
-                       PRVM_G_FLOAT(OFS_PARM3) = volume;
+                       PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(prog, cl.sound_name[sound_num] );
+                       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;
                        PRVM_G_FLOAT(OFS_PARM7) = flags; // flags
-                       PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Event_Sound), "QC function CSQC_Event_Sound is missing");
+                       prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Event_Sound), "QC function CSQC_Event_Sound is missing");
                        r = CSQC_RETURNVAL != 0;
                }
                CSQC_END
@@ -735,8 +748,9 @@ qboolean CL_VM_Event_Sound(int sound_num, float volume, int channel, float atten
 
        return r;
 }
-void CL_VM_UpdateCoopDeathmatchGlobals (int gametype)
+static void CL_VM_UpdateCoopDeathmatchGlobals (int gametype)
 {
+       prvm_prog_t *prog = CLVM_prog;
        // Avoid global names for clean(er) coding
        int localcoop;
        int localdeathmatch;
@@ -767,8 +781,10 @@ void CL_VM_UpdateCoopDeathmatchGlobals (int gametype)
                CSQC_END
        }
 }
-float CL_VM_Event (float event)                //[515]: needed ? I'd say "YES", but don't know for what :D
+#if 0
+static float CL_VM_Event (float event)         //[515]: needed ? I'd say "YES", but don't know for what :D
 {
+       prvm_prog_t *prog = CLVM_prog;
        float r = 0;
        if(!cl.csqc_loaded)
                return 0;
@@ -778,15 +794,17 @@ float CL_VM_Event (float event)           //[515]: needed ? I'd say "YES", but don't know
                PRVM_clientglobalfloat(time) = cl.time;
                PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
                PRVM_G_FLOAT(OFS_PARM0) = event;
-               PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Event), "QC function CSQC_Event is missing");
+               prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Event), "QC function CSQC_Event is missing");
                r = CSQC_RETURNVAL;
        }
        CSQC_END
        return r;
 }
+#endif
 
 void CSQC_ReadEntities (void)
 {
+       prvm_prog_t *prog = CLVM_prog;
        unsigned short entnum, oldself, realentnum;
        if(!cl.csqc_loaded)
        {
@@ -799,8 +817,8 @@ void CSQC_ReadEntities (void)
                oldself = PRVM_clientglobaledict(self);
                while(1)
                {
-                       entnum = MSG_ReadShort();
-                       if(!entnum || msg_badread)
+                       entnum = MSG_ReadShort(&cl_message);
+                       if(!entnum || cl_message.badread)
                                break;
                        realentnum = entnum & 0x7FFF;
                        PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[realentnum];
@@ -808,7 +826,7 @@ void CSQC_ReadEntities (void)
                        {
                                if(PRVM_clientglobaledict(self))
                                {
-                                       PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Remove), "QC function CSQC_Ent_Remove is missing");
+                                       prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Ent_Remove), "QC function CSQC_Ent_Remove is missing");
                                        cl.csqc_server2csqcentitynumber[realentnum] = 0;
                                }
                                else
@@ -827,7 +845,7 @@ void CSQC_ReadEntities (void)
                                        if(!PRVM_clientfunction(CSQC_Ent_Spawn))
                                        {
                                                prvm_edict_t    *ed;
-                                               ed = PRVM_ED_Alloc();
+                                               ed = PRVM_ED_Alloc(prog);
                                                PRVM_clientedictfloat(ed, entnum) = realentnum;
                                                PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT_TO_PROG(ed);
                                        }
@@ -838,15 +856,15 @@ void CSQC_ReadEntities (void)
                                                PRVM_G_FLOAT(OFS_PARM0) = (float) realentnum;
                                                // make sure no one gets wrong ideas
                                                PRVM_clientglobaledict(self) = 0;
-                                               PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Spawn), "QC function CSQC_Ent_Spawn is missing");
+                                               prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Ent_Spawn), "QC function CSQC_Ent_Spawn is missing");
                                                PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT( PRVM_G_INT( OFS_RETURN ) );
                                        }
                                        PRVM_G_FLOAT(OFS_PARM0) = 1;
-                                       PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Update), "QC function CSQC_Ent_Update is missing");
+                                       prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Ent_Update), "QC function CSQC_Ent_Update is missing");
                                }
                                else {
                                        PRVM_G_FLOAT(OFS_PARM0) = 0;
-                                       PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Update), "QC function CSQC_Ent_Update is missing");
+                                       prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Ent_Update), "QC function CSQC_Ent_Update is missing");
                                }
                        }
                }
@@ -854,13 +872,13 @@ void CSQC_ReadEntities (void)
        CSQC_END
 }
 
-void CL_VM_CB_BeginIncreaseEdicts(void)
+static void CLVM_begin_increase_edicts(prvm_prog_t *prog)
 {
        // links don't survive the transition, so unlink everything
        World_UnlinkAll(&cl.world);
 }
 
-void CL_VM_CB_EndIncreaseEdicts(void)
+static void CLVM_end_increase_edicts(prvm_prog_t *prog)
 {
        int i;
        prvm_edict_t *ent;
@@ -871,7 +889,7 @@ void CL_VM_CB_EndIncreaseEdicts(void)
                        CL_LinkEdict(ent);
 }
 
-void CL_VM_CB_InitEdict(prvm_edict_t *e)
+static void CLVM_init_edict(prvm_prog_t *prog, prvm_edict_t *e)
 {
        int edictnum = PRVM_NUM_FOR_EDICT(e);
        entity_render_t *entrender;
@@ -882,21 +900,19 @@ void CL_VM_CB_InitEdict(prvm_edict_t *e)
        entrender->shadertime = cl.time;
 }
 
-extern void R_DecalSystem_Reset(decalsystem_t *decalsystem);
-
-void CL_VM_CB_FreeEdict(prvm_edict_t *ed)
+static void CLVM_free_edict(prvm_prog_t *prog, prvm_edict_t *ed)
 {
        entity_render_t *entrender = cl.csqcrenderentities + PRVM_NUM_FOR_EDICT(ed);
        R_DecalSystem_Reset(&entrender->decalsystem);
        memset(entrender, 0, sizeof(*entrender));
        World_UnlinkEdict(ed);
-       memset(ed->fields.vp, 0, prog->entityfields * 4);
-       VM_RemoveEdictSkeleton(ed);
+       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);
 }
 
-void CL_VM_CB_CountEdicts(void)
+static void CLVM_count_edicts(prvm_prog_t *prog)
 {
        int             i;
        prvm_edict_t    *ent;
@@ -920,19 +936,18 @@ void CL_VM_CB_CountEdicts(void)
        Con_Printf("touch     :%3i\n", solid);
 }
 
-qboolean CL_VM_CB_LoadEdict(prvm_edict_t *ent)
+static qboolean CLVM_load_edict(prvm_prog_t *prog, prvm_edict_t *ent)
 {
        return true;
 }
 
-void Cmd_ClearCsqcFuncs (void);
-
 // returns true if the packet is valid, false if end of file is reached
 // used for dumping the CSQC download into demo files
 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)
                return false; // CSQC can't run in QW anyway
@@ -941,13 +956,13 @@ qboolean MakeDownloadPacket(const char *filename, unsigned char *data, size_t le
        if(cnt == 0)
        {
                MSG_WriteByte(buf, svc_stufftext);
-               MSG_WriteString(buf, va("\ncl_downloadbegin %lu %s\n", (unsigned long)len, filename));
+               MSG_WriteString(buf, va(vabuf, sizeof(vabuf), "\ncl_downloadbegin %lu %s\n", (unsigned long)len, filename));
                return true;
        }
        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;
 
@@ -961,7 +976,7 @@ qboolean MakeDownloadPacket(const char *filename, unsigned char *data, size_t le
        else if(cnt == npackets + 1)
        {
                MSG_WriteByte(buf, svc_stufftext);
-               MSG_WriteString(buf, va("\ncl_downloadfinished %lu %d\n", (unsigned long)len, crc));
+               MSG_WriteString(buf, va(vabuf, sizeof(vabuf), "\ncl_downloadfinished %lu %d\n", (unsigned long)len, crc));
                return true;
        }
        return false;
@@ -970,11 +985,13 @@ qboolean MakeDownloadPacket(const char *filename, unsigned char *data, size_t le
 extern cvar_t csqc_usedemoprogs;
 void CL_VM_Init (void)
 {
-       const char* csprogsfn;
+       prvm_prog_t *prog = CLVM_prog;
+       const char* csprogsfn = NULL;
        unsigned char *csprogsdata = NULL;
-       fs_offset_t csprogsdatasize;
+       fs_offset_t csprogsdatasize = 0;
        int csprogsdatacrc, requiredcrc;
        int requiredsize;
+       char vabuf[1024];
 
        // reset csqc_progcrc after reading it, so that changing servers doesn't
        // expect csqc on the next server
@@ -988,11 +1005,22 @@ void CL_VM_Init (void)
                return;
 
        // see if the requested csprogs.dat file matches the requested crc
-       csprogsdatacrc = -1;
        if (!cls.demoplayback || csqc_usedemoprogs.integer)
        {
-               csprogsfn = va("dlcache/%s.%i.%i", csqc_progname.string, requiredsize, requiredcrc);
-               csprogsdata = FS_LoadFile(csprogsfn, tempmempool, true, &csprogsdatasize);
+               csprogsfn = va(vabuf, sizeof(vabuf), "dlcache/%s.%i.%i", csqc_progname.string, requiredsize, requiredcrc);
+               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, cls.caughtcsprogsdata, (int) cls.caughtcsprogsdatasize);
+                       csprogsdata = FS_LoadFile(csprogsfn, tempmempool, true, &csprogsdatasize);
+               }
        }
        if (!csprogsdata)
        {
@@ -1034,13 +1062,12 @@ void CL_VM_Init (void)
                return;
        }
 
-       PRVM_Begin;
-       PRVM_InitProg(PRVM_CLIENTPROG);
+       PRVM_Prog_Init(prog);
 
        // allocate the mempools
        prog->progs_mempool = Mem_AllocPool(csqc_progname.string, 0, NULL);
        prog->edictprivate_size = 0; // no private struct used
-       prog->name = CL_NAME;
+       prog->name = "client";
        prog->num_edicts = 1;
        prog->max_edicts = 512;
        prog->limit_edicts = CL_MAX_EDICTS;
@@ -1050,22 +1077,24 @@ void CL_VM_Init (void)
        prog->extensionstring = vm_sv_extensions;
        prog->builtins = vm_cl_builtins;
        prog->numbuiltins = vm_cl_numbuiltins;
-       prog->begin_increase_edicts = CL_VM_CB_BeginIncreaseEdicts;
-       prog->end_increase_edicts = CL_VM_CB_EndIncreaseEdicts;
-       prog->init_edict = CL_VM_CB_InitEdict;
-       prog->free_edict = CL_VM_CB_FreeEdict;
-       prog->count_edicts = CL_VM_CB_CountEdicts;
-       prog->load_edict = CL_VM_CB_LoadEdict;
-       prog->init_cmd = VM_CL_Cmd_Init;
-       prog->reset_cmd = VM_CL_Cmd_Reset;
-       prog->error_cmd = CL_VM_Error;
-       prog->ExecuteProgram = CLVM_ExecuteProgram;
-
-       PRVM_LoadProgs(csprogsfn, cl_numrequiredfunc, cl_required_func, CL_REQFIELDS, cl_reqfields, CL_REQGLOBALS, cl_reqglobals);
+
+       // all callbacks must be defined (pointers are not checked before calling)
+       prog->begin_increase_edicts = CLVM_begin_increase_edicts;
+       prog->end_increase_edicts   = CLVM_end_increase_edicts;
+       prog->init_edict            = CLVM_init_edict;
+       prog->free_edict            = CLVM_free_edict;
+       prog->count_edicts          = CLVM_count_edicts;
+       prog->load_edict            = CLVM_load_edict;
+       prog->init_cmd              = CLVM_init_cmd;
+       prog->reset_cmd             = CLVM_reset_cmd;
+       prog->error_cmd             = Host_Error;
+       prog->ExecuteProgram        = CLVM_ExecuteProgram;
+
+       PRVM_Prog_Load(prog, csprogsfn, csprogsdata, csprogsdatasize, cl_numrequiredfunc, cl_required_func, CL_REQFIELDS, cl_reqfields, CL_REQGLOBALS, cl_reqglobals);
 
        if (!prog->loaded)
        {
-               CL_VM_Error("CSQC %s ^2failed to load\n", csprogsfn);
+               Host_Error("CSQC %s ^2failed to load\n", csprogsfn);
                if(!sv.active)
                        CL_Disconnect();
                Mem_Free(csprogsdata);
@@ -1106,18 +1135,23 @@ void CL_VM_Init (void)
        PRVM_clientglobalfloat(time) = cl.time;
        PRVM_clientglobaledict(self) = 0;
 
-       PRVM_clientglobalstring(mapname) = PRVM_SetEngineString(cl.worldname);
-       PRVM_clientglobalfloat(player_localentnum) = cl.playerentity;
+       PRVM_clientglobalstring(mapname) = PRVM_SetEngineString(prog, cl.worldname);
+       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(cl.worldmessage);
+       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
-       PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Init), "QC function CSQC_Init is missing");
+       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 = realtime;
 
-       PRVM_End;
        cl.csqc_loaded = true;
 
        cl.csqc_vidvars.drawcrosshair = false;
@@ -1129,17 +1163,21 @@ void CL_VM_Init (void)
 
 void CL_VM_ShutDown (void)
 {
+       prvm_prog_t *prog = CLVM_prog;
        Cmd_ClearCsqcFuncs();
        //Cvar_SetValueQuick(&csqc_progcrc, -1);
        //Cvar_SetValueQuick(&csqc_progsize, -1);
        if(!cl.csqc_loaded)
                return;
        CSQC_BEGIN
-               PRVM_clientglobalfloat(time) = cl.time;
-               PRVM_clientglobaledict(self) = 0;
-               if (PRVM_clientfunction(CSQC_Shutdown))
-                       PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Shutdown), "QC function CSQC_Shutdown is missing");
-               PRVM_ResetProg();
+               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
        Con_DPrint("CSQC ^1unloaded\n");
        cl.csqc_loaded = false;
@@ -1147,6 +1185,7 @@ void CL_VM_ShutDown (void)
 
 qboolean CL_VM_GetEntitySoundOrigin(int entnum, vec3_t out)
 {
+       prvm_prog_t *prog = CLVM_prog;
        prvm_edict_t *ed;
        dp_model_t *mod;
        matrix4x4_t matrix;
@@ -1154,15 +1193,13 @@ qboolean CL_VM_GetEntitySoundOrigin(int entnum, vec3_t out)
 
        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 (&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);
@@ -1176,6 +1213,7 @@ qboolean CL_VM_GetEntitySoundOrigin(int entnum, vec3_t out)
 
 qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clipplane, vec3_t visorigin)
 {
+       prvm_prog_t *prog = CLVM_prog;
        qboolean ret = false;
        prvm_edict_t *ed;
        vec3_t forward, left, up, origin, ang;
@@ -1188,7 +1226,7 @@ qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clip
                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);
@@ -1200,7 +1238,7 @@ qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clip
                                VectorScale(left, -1, PRVM_clientglobalvector(v_right));
                                VectorCopy(up, PRVM_clientglobalvector(v_up));
                                VectorCopy(origin, PRVM_clientglobalvector(trace_endpos));
-                               PRVM_ExecuteProgram(PRVM_clientedictfunction(ed, camera_transform), "QC function e.camera_transform is missing");
+                               prog->ExecuteProgram(prog, PRVM_clientedictfunction(ed, camera_transform), "QC function e.camera_transform is missing");
                                VectorCopy(PRVM_G_VECTOR(OFS_RETURN), origin);
                                VectorCopy(PRVM_clientglobalvector(v_forward), forward);
                                VectorScale(PRVM_clientglobalvector(v_right), -1, left);
@@ -1209,10 +1247,17 @@ qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clip
                                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
 
        return ret;
 }
+
+int CL_VM_GetViewEntity(void)
+{
+       if(cl.csqc_server2csqcentitynumber[cl.viewentity])
+               return cl.csqc_server2csqcentitynumber[cl.viewentity] + MAX_EDICTS;
+       return cl.viewentity;
+}