static int cl_numrequiredfunc = sizeof(cl_required_func) / sizeof(char*);
-unsigned int csqc_drawmask = 0;
static char *csqc_printtextbuf = NULL;
static unsigned short *csqc_sv2csqcents; //[515]: server entities numbers on client side. FIXME : make pointers instead of numbers ?
if(CSQC_Parse_Print)
{
- csqc_printtextbuf = Mem_Alloc(csqc_mempool, CSQC_PRINTBUFFERLEN);
+ csqc_printtextbuf = (char *)Mem_Alloc(csqc_mempool, CSQC_PRINTBUFFERLEN);
csqc_printtextbuf[0] = 0;
}
}
+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];
csqc_loaded = false;
Mem_FreePool(&csqc_mempool);
- Cvar_SetValueQuick(&csqc_progcrc, 0);
+ 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(va("CL_VM_Error: %s", errorstring));
prog->globals.client->input_buttons = csqc_buttons;
VectorSet(prog->globals.client->input_movevalues, cl.cmd.forwardmove, cl.cmd.sidemove, cl.cmd.upmove);
//VectorCopy(cl.movement_origin, csqc_origin);
- VectorCopy(cl.entities[cl.viewentity].render.origin, csqc_origin);
+ Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, csqc_origin);
VectorCopy(csqc_origin, prog->globals.client->pmove_org);
prog->globals.client->maxclients = cl.maxclients;
//VectorCopy(cl.movement_velocity, prog->globals.client->pmove_vel);
CSQC_END
}
-static void CSQC_Predraw (prvm_edict_t *ed)
+void CSQC_Predraw (prvm_edict_t *ed)
{
int b;
if(!ed->fields.client->predraw)
prog->globals.client->self = b;
}
-static void CSQC_Think (prvm_edict_t *ed)
+void CSQC_Think (prvm_edict_t *ed)
{
int b;
if(ed->fields.client->think)
}
}
-//[515]: weird too
-static qboolean CSQC_EdictToEntity (prvm_edict_t *ed, entity_t *e)
+extern cvar_t cl_noplayershadow;
+qboolean CSQC_AddRenderEdict(prvm_edict_t *ed)
{
int i;
prvm_eval_t *val;
+ entity_t *e;
+ matrix4x4_t tagmatrix, matrix2;
- i = ed->fields.client->modelindex;
- e->state_current.modelindex = 0;
+ e = CL_NewTempEntity();
+ if (!e)
+ return false;
+
+ i = (int)ed->fields.client->modelindex;
if(i >= MAX_MODELS || i <= -MAX_MODELS) //[515]: make work as error ?
{
- Con_Print("CSQC_EdictToEntity: modelindex >= MAX_MODELS\n");
- ed->fields.client->modelindex = 0;
+ Con_Print("CSQC_AddRenderEdict: modelindex >= MAX_MODELS\n");
+ ed->fields.client->modelindex = i = 0;
}
+
+ // model setup and some modelflags
+ if (i < MAX_MODELS)
+ e->render.model = cl.model_precache[e->state_current.modelindex];
else
- e->state_current.modelindex = i;
- if(!e->state_current.modelindex)
+ e->render.model = cl.csqc_model_precache[65536-e->state_current.modelindex];
+
+ if (!e->render.model)
return false;
- e->state_current.time = cl.time;
+ e->render.colormap = (int)ed->fields.client->colormap;
+ e->render.frame = (int)ed->fields.client->frame;
+ e->render.skinnum = (int)ed->fields.client->skin;
+ e->render.effects |= e->render.model->flags2 & (EF_FULLBRIGHT | EF_ADDITIVE);
- i = 0;
- if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_renderflags)) && val->_float)
+ if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_alpha)) && val->_float) e->render.alpha = val->_float;
+ if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_scale)) && val->_float) e->render.scale = val->_float;
+ if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_colormod)) && VectorLength2(val->vector)) VectorCopy(val->vector, e->render.colormod);
+ if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_effects)) && val->_float) e->render.effects = (int)val->_float;
+ if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_tag_entity)) && val->edict)
{
- i = val->_float;
- if(i & RF_VIEWMODEL) e->state_current.flags |= RENDER_VIEWMODEL;
- if(i & RF_EXTERNALMODEL)e->state_current.flags |= RENDER_EXTERIORMODEL;
- if(i & RF_DEPTHHACK) e->state_current.effects |= EF_NODEPTHTEST;
- if(i & RF_ADDITIVE) e->state_current.effects |= EF_ADDITIVE;
+ int tagentity;
+ int tagindex;
+ tagentity = val->edict;
+ if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_tag_index)) && val->_float)
+ tagindex = (int)val->_float;
+ // FIXME: calculate tag matrix
+ Matrix4x4_CreateIdentity(&tagmatrix);
}
+ else
+ Matrix4x4_CreateIdentity(&tagmatrix);
if(i & RF_USEAXIS) //FIXME!!!
- VectorCopy(ed->fields.client->angles, e->persistent.newangles);
+ {
+ vec3_t left;
+ VectorNegate(prog->globals.client->v_right, left);
+ Matrix4x4_FromVectors(&matrix2, prog->globals.client->v_forward, left, prog->globals.client->v_up, ed->fields.client->origin);
+ }
else
- VectorCopy(ed->fields.client->angles, e->persistent.newangles);
-
- VectorCopy(ed->fields.client->origin, e->persistent.neworigin);
- VectorCopy(ed->fields.client->origin, e->state_current.origin);
- e->state_current.colormap = ed->fields.client->colormap;
- e->state_current.effects = ed->fields.client->effects;
- e->state_current.frame = ed->fields.client->frame;
- e->state_current.skin = ed->fields.client->skin;
-
- if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_alpha)) && val->_float) e->state_current.alpha = val->_float*255;
- if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_scale)) && val->_float) e->state_current.scale = val->_float*16;
- if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_colormod)) && VectorLength2(val->vector)) VectorScale(val->vector, 32, e->state_current.colormod);
- if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_effects)) && val->_float) e->state_current.effects = val->_float;
- if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_tag_entity)) && val->edict)
{
- e->state_current.tagentity = val->edict;
- if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_tag_index)) && val->_float)
- e->state_current.tagindex = val->_float;
+ vec3_t angles;
+ VectorCopy(ed->fields.client->angles, angles);
+ // if model is alias, reverse pitch direction
+ if (e->render.model->type == mod_alias)
+ angles[0] = -angles[0];
+
+ // set up the render matrix
+ // FIXME: e->render.scale should go away
+ Matrix4x4_CreateFromQuakeEntity(&matrix2, ed->fields.client->origin[0], ed->fields.client->origin[1], ed->fields.client->origin[2], angles[0], angles[1], angles[2], e->render.scale);
+ }
+
+ // FIXME: csqc has frame1/frame2/frame1time/frame2time/lerpfrac but this implementation's cl_entvars_t lacks those fields
+ e->render.frame1 = e->render.frame = ed->fields.client->frame;
+ e->render.frame1time = e->render.frame2time = 0;
+ e->render.framelerp = 0;
+
+ // concat the matrices to make the entity relative to its tag
+ Matrix4x4_Concat(&e->render.matrix, &tagmatrix, &matrix2);
+ // make the other useful stuff
+ CL_UpdateRenderEntity(&e->render);
+
+ i = 0;
+ if((val = PRVM_GETEDICTFIELDVALUE(ed, csqc_fieldoff_renderflags)) && val->_float)
+ {
+ i = (int)val->_float;
+ if(i & RF_VIEWMODEL) e->render.flags |= RENDER_VIEWMODEL;
+ if(i & RF_EXTERNALMODEL)e->render.flags |= RENDER_EXTERIORMODEL;
+ if(i & RF_DEPTHHACK) e->render.effects |= EF_NODEPTHTEST;
+ if(i & RF_ADDITIVE) e->render.effects |= EF_ADDITIVE;
}
+ // transparent stuff can't be lit during the opaque stage
+ if (e->render.effects & (EF_ADDITIVE | EF_NODEPTHTEST) || e->render.alpha < 1)
+ e->render.flags |= RENDER_TRANSPARENT;
+ // double sided rendering mode causes backfaces to be visible
+ // (mostly useful on transparent stuff)
+ if (e->render.effects & EF_DOUBLESIDED)
+ e->render.flags |= RENDER_NOCULLFACE;
+ // either fullbright or lit
+ if (!(e->render.effects & EF_FULLBRIGHT) && !r_fullbright.integer)
+ e->render.flags |= RENDER_LIGHT;
+ // hide player shadow during intermission or nehahra movie
+ if (!(e->render.effects & EF_NOSHADOW)
+ && !(e->render.flags & (RENDER_VIEWMODEL | RENDER_TRANSPARENT))
+ && (!(e->render.flags & RENDER_EXTERIORMODEL) || (!cl.intermission && cls.protocol != PROTOCOL_NEHAHRAMOVIE && !cl_noplayershadow.integer)))
+ e->render.flags |= RENDER_SHADOW;
+
return true;
}
{
memset(cl.csqcentities_active, 0, sizeof(cl.csqcentities_active));
cl.num_csqcentities = 0;
- csqc_drawmask = 0;
}
void CL_ExpandCSQCEntities (int num);
-void CSQC_RelinkCSQCEntities (void)
-{
- int i;
- entity_t *e;
- prvm_edict_t *ed;
-
- *prog->time = cl.time;
- for(i=1;i<prog->num_edicts;i++)
- {
- if(i >= cl.max_csqcentities)
- CL_ExpandCSQCEntities(i);
-
- e = &cl.csqcentities[i];
- ed = &prog->edicts[i];
- if(ed->priv.required->free)
- {
- e->state_current.active = false;
- cl.csqcentities_active[i] = false;
- continue;
- }
- VectorAdd(ed->fields.client->origin, ed->fields.client->mins, ed->fields.client->absmin);
- VectorAdd(ed->fields.client->origin, ed->fields.client->maxs, ed->fields.client->absmax);
- CSQC_Think(ed);
- if(ed->priv.required->free)
- {
- e->state_current.active = false;
- cl.csqcentities_active[i] = false;
- continue;
- }
- CSQC_Predraw(ed);
- if(ed->priv.required->free)
- {
- e->state_current.active = false;
- cl.csqcentities_active[i] = false;
- continue;
- }
- if(!cl.csqcentities_active[i])
- if(!((int)ed->fields.client->drawmask & csqc_drawmask))
- continue;
-
- e->state_previous = e->state_current;
- e->state_current = defaultstate;
- if((cl.csqcentities_active[i] = CSQC_EdictToEntity(ed, e)))
- {
- if(!e->state_current.active)
- {
- if(!e->state_previous.active)
- VectorCopy(ed->fields.client->origin, e->persistent.trail_origin);//[515]: hack to make good gibs =/
- e->state_previous = e->state_current;
- e->state_current.active = true;
- }
- e->persistent.lerpdeltatime = 0;//prog->globals.client->frametime;
- cl.num_csqcentities++;
- }
- }
-}
-
-//[515]: omfg... it's all weird =/
-void CSQC_AddEntity (int n)
-{
- cl.csqcentities_active[n] = true;
-}
-
qboolean CL_VM_InputEvent (qboolean pressed, int key)
{
qboolean r;
//VectorCopy(cl.viewangles, oldangles);
*prog->time = cl.time;
CSQC_SetGlobals();
- csqc_drawmask = 0;
cl.num_csqcentities = 0;
PRVM_ExecuteProgram (prog->globals.client->CSQC_UpdateView, CL_F_UPDATEVIEW);
//VectorCopy(oldangles, cl.viewangles);
CSQC_END
- csqc_frame = false;
return true;
}
void CL_VM_Parse_StuffCmd (const char *msg)
{
- if(!csqc_loaded) //[515]: add more here
if(msg[0] == 'c')
if(msg[1] == 's')
if(msg[2] == 'q')
if(msg[3] == 'c')
{
- Cvar_SetQuick(&csqc_progcrc, "0");
- csqc_progcrc.flags = 0;
+ // if this is setting a csqc variable, deprotect csqc_progcrc
+ // 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);
- csqc_progcrc.flags = CVAR_READONLY;
+ csqc_progcrc.flags = crcflags;
+ csqc_progsize.flags = sizeflags;
return;
}
if(!csqc_loaded || !CSQC_Parse_StuffCmd)
Con_Print(msg);
return;
}
+ // FIXME: is this bugged?
i = strlen(msg)-1;
if(msg[i] != '\n' && msg[i] != '\r')
{
csqc_printtextbuf[0] = 0;
}
else
- strcat(csqc_printtextbuf, msg);
+ strlcat(csqc_printtextbuf, msg, CSQC_PRINTBUFFERLEN);
return;
}
- strcat(csqc_printtextbuf, msg);
+ strlcat(csqc_printtextbuf, msg, CSQC_PRINTBUFFERLEN);
CL_VM_Parse_Print(csqc_printtextbuf);
csqc_printtextbuf[0] = 0;
}
void CL_VM_Init (void)
{
+ unsigned char *csprogsdata;
+ fs_offset_t csprogsdatasize;
+ int csprogsdatacrc, requiredcrc;
+ int requiredsize;
entity_t *ent;
+ // reset csqc_progcrc after reading it, so that changing servers doesn't
+ // expect csqc on the next server
+ requiredcrc = csqc_progcrc.integer;
+ requiredsize = csqc_progsize.integer;
+ Cvar_SetValueQuick(&csqc_progcrc, -1);
+ Cvar_SetValueQuick(&csqc_progsize, -1);
+
csqc_loaded = false;
memset(cl.csqc_model_precache, 0, sizeof(cl.csqc_model_precache));
memset(&cl.csqc_vidvars, true, sizeof(csqc_vidvars_t));
- if(!FS_FileExists(csqc_progname.string))
+ // if the server is not requesting a csprogs, then we're done here
+ if (requiredcrc < 0)
+ return;
+
+ // see if the requested csprogs.dat file matches the requested crc
+ csprogsdatacrc = -1;
+ csprogsdata = FS_LoadFile(va("dlcache/%s.%i.%i", csqc_progname.string, requiredsize, requiredcrc), tempmempool, true, &csprogsdatasize);
+ if (!csprogsdata)
+ csprogsdata = FS_LoadFile(csqc_progname.string, tempmempool, true, &csprogsdatasize);
+ if (csprogsdata)
{
- if(!sv.active && csqc_progcrc.integer)
+ csprogsdatacrc = CRC_Block(csprogsdata, csprogsdatasize);
+ Mem_Free(csprogsdata);
+ if (csprogsdatacrc != requiredcrc || csprogsdatasize != requiredsize)
{
- Con_Printf("CL_VM_Init: server requires CSQC, but \"%s\" wasn't found\n", csqc_progname.string);
- CL_Disconnect();
+ 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);
+ return;
+ }
+ else
+ {
+ 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);
+ CL_Disconnect();
+ return;
+ }
}
- return;
}
else
- if(!sv.active && !csqc_progcrc.integer) //[515]: because cheaters may use csqc while server didn't allowed it !
+ {
+ if (requiredcrc >= 0)
{
- Con_Printf("CL_VM_Init: server didn't sent CSQC crc, so CSQC is disabled\n");
- return;
+ if (cls.demoplayback)
+ Con_Printf("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);
+ CL_Disconnect();
}
+ return;
+ }
PRVM_Begin;
PRVM_InitProg(PRVM_CLIENTPROG);
+ csqc_mempool = Mem_AllocPool("CSQC", 0, NULL);
+
// allocate the mempools
prog->progs_mempool = Mem_AllocPool(csqc_progname.string, 0, NULL);
prog->headercrc = CL_PROGHEADER_CRC;
prog->edictprivate_size = 0; // no private struct used
- prog->name = csqc_progname.string;
+ prog->name = CL_NAME;
prog->num_edicts = 1;
prog->limit_edicts = CL_MAX_EDICTS;
prog->extensionstring = vm_cl_extensions;
PRVM_LoadProgs(csqc_progname.string, cl_numrequiredfunc, cl_required_func, 0, NULL);
- if(!sv.active && !cls.demoplayback && prog->filecrc != (unsigned short)csqc_progcrc.integer)
- {
- Con_Printf("^1Your CSQC version differs from server's one (%i!=%i)\n", prog->filecrc, csqc_progcrc.integer);
- PRVM_ResetProg();
- CL_Disconnect();
- return;
- }
-
if(prog->loaded)
- {
- Cvar_SetValueQuick(&csqc_progcrc, prog->filecrc);
- Con_Printf("CSQC ^5loaded (crc=%i)\n", csqc_progcrc.integer);
- }
+ Con_Printf("CSQC ^5loaded (crc=%i, size=%i)\n", csprogsdatacrc, (int)csprogsdatasize);
else
{
CL_VM_Error("CSQC ^2failed to load\n");
return;
}
- csqc_mempool = Mem_AllocPool("CSQC", 0, NULL);
-
//[515]: optional fields & funcs
CL_VM_FindEdictFieldOffsets();
PRVM_End;
csqc_loaded = true;
- csqc_sv2csqcents = Mem_Alloc(csqc_mempool, MAX_EDICTS*sizeof(unsigned short));
+ csqc_sv2csqcents = (unsigned short *)Mem_Alloc(csqc_mempool, MAX_EDICTS*sizeof(unsigned short));
memset(csqc_sv2csqcents, 0, MAX_EDICTS*sizeof(unsigned short));
cl.csqc_vidvars.drawcrosshair = false;
// entire entity array was cleared, so just fill in a few fields
ent->state_current.active = true;
ent->render.model = cl.worldmodel = cl.model_precache[1];
- ent->render.scale = 1; // some of the renderer still relies on scale
ent->render.alpha = 1;
ent->render.flags = RENDER_SHADOW | RENDER_LIGHT;
Matrix4x4_CreateFromQuakeEntity(&ent->render.matrix, 0, 0, 0, 0, 0, 0, 1);
- Matrix4x4_Invert_Simple(&ent->render.inversematrix, &ent->render.matrix);
- CL_BoundingBoxForEntity(&ent->render);
+ CL_UpdateRenderEntity(&ent->render);
}
void CL_VM_ShutDown (void)
{
Cmd_ClearCsqcFuncs();
- Cvar_SetValueQuick(&csqc_progcrc, 0);
+ Cvar_SetValueQuick(&csqc_progcrc, -1);
+ Cvar_SetValueQuick(&csqc_progsize, -1);
if(!csqc_loaded)
return;
CSQC_BEGIN
projects / xonotic / darkplaces.git / blobdiff