//4 feature darkplaces csqc: add builtins to clientside qc for gl calls
sfx_t *S_FindName(const char *name);
-int Sbar_GetPlayer (int index);
+int Sbar_GetSortedPlayerIndex (int index);
void Sbar_SortFrags (void);
void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
void CSQC_RelinkAllEntities (int drawmask);
VM_SAFEPARMCOUNT(2, VM_CL_setmodel);
e = PRVM_G_EDICT(OFS_PARM0);
+ e->fields.client->modelindex = 0;
+ e->fields.client->model = 0;
+
m = PRVM_G_STRING(OFS_PARM1);
+ mod = NULL;
for (i = 0;i < MAX_MODELS && cl.csqc_model_precache[i];i++)
{
if (!strcmp(cl.csqc_model_precache[i]->name, m))
{
- e->fields.client->model = PRVM_SetEngineString(cl.csqc_model_precache[i]->name);
+ mod = cl.csqc_model_precache[i];
+ e->fields.client->model = PRVM_SetEngineString(mod->name);
e->fields.client->modelindex = -(i+1);
- return;
+ break;
}
}
- for (i = 0;i < MAX_MODELS;i++)
- {
- mod = cl.model_precache[i];
- if (mod && !strcmp(mod->name, m))
+ if( !mod ) {
+ for (i = 0;i < MAX_MODELS;i++)
{
- e->fields.client->model = PRVM_SetEngineString(mod->name);
- e->fields.client->modelindex = i;
- return;
+ mod = cl.model_precache[i];
+ if (mod && !strcmp(mod->name, m))
+ {
+ e->fields.client->model = PRVM_SetEngineString(mod->name);
+ e->fields.client->modelindex = i;
+ break;
+ }
}
}
- e->fields.client->modelindex = 0;
- e->fields.client->model = 0;
- VM_Warning ("setmodel: model '%s' not precached\n", m);
-
- // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
- if (mod)
- {
- SetMinMaxSize (e, mod->normalmins, mod->normalmaxs);
+ if( mod ) {
+ // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
+ //SetMinMaxSize (e, mod->normalmins, mod->normalmaxs);
}
else
+ {
SetMinMaxSize (e, vec3_origin, vec3_origin);
+ VM_Warning ("setmodel: model '%s' not precached\n", m);
+ }
}
// #4 void(entity e, vector min, vector max) setsize
r_refdef.view.frustum_y *= r_refdef.frustumscale_y;
r_refdef.view.ortho_x = scr_fov.value * (3.0 / 4.0) * (float)r_refdef.view.width / (float)r_refdef.view.height / vid_pixelheight.value;
r_refdef.view.ortho_y = scr_fov.value * (3.0 / 4.0);
+ r_refdef.view.clear = true;
+ r_refdef.view.isoverlay = false;
// FIXME: restore cl.csqc_origin
// FIXME: restore cl.csqc_angles
cl.csqc_vidvars.drawworld = true;
r_refdef.view.width = (int)(f[0] * vid.width / vid_conwidth.value);
r_refdef.view.height = (int)(f[1] * vid.height / vid_conheight.value);
break;
- case VF_SIZE_Y:
+ case VF_SIZE_X:
r_refdef.view.width = (int)(k * vid.width / vid_conwidth.value);
break;
- case VF_SIZE_X:
+ case VF_SIZE_Y:
r_refdef.view.height = (int)(k * vid.height / vid_conheight.value);
break;
case VF_VIEWPORT:
case VF_PERSPECTIVE:
r_refdef.view.useperspective = k != 0;
break;
+ case VF_CLEARSCREEN:
+ r_refdef.view.isoverlay = !k;
+ break;
default:
PRVM_G_FLOAT(OFS_RETURN) = 0;
VM_Warning("VM_CL_R_SetView : unknown parm %i\n", c);
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
-//#304 void() renderscene (EXT_CSQC)
-void VM_CL_R_RenderScene (void)
-{
- VM_SAFEPARMCOUNT(0, VM_CL_R_RenderScene);
- // we need to update any RENDER_VIEWMODEL entities at this point because
- // csqc supplies its own view matrix
- CL_UpdateViewEntities();
- // now draw stuff!
- R_RenderView();
-}
-
-//#305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
+//#305 void(vector org, float radius, vector lightcolours[, float style, string cubemapname, float pflags]) adddynamiclight (EXT_CSQC)
void VM_CL_R_AddDynamicLight (void)
{
- float *pos, *col;
- matrix4x4_t matrix;
- VM_SAFEPARMCOUNTRANGE(3, 3, VM_CL_R_AddDynamicLight);
+ vec_t *org;
+ float radius = 300;
+ vec_t *col;
+ int style = -1;
+ const char *cubemapname = NULL;
+ int pflags = PFLAGS_CORONA | PFLAGS_FULLDYNAMIC;
+ float coronaintensity = 1;
+ float coronasizescale = 0.25;
+ qboolean castshadow = true;
+ float ambientscale = 0;
+ float diffusescale = 1;
+ float specularscale = 1;
+ matrix4x4_t matrix;
+ vec3_t forward, left, up;
+ VM_SAFEPARMCOUNTRANGE(3, 8, VM_CL_R_AddDynamicLight);
// if we've run out of dlights, just return
if (r_refdef.scene.numlights >= MAX_DLIGHTS)
return;
- pos = PRVM_G_VECTOR(OFS_PARM0);
+ org = PRVM_G_VECTOR(OFS_PARM0);
+ radius = PRVM_G_FLOAT(OFS_PARM1);
col = PRVM_G_VECTOR(OFS_PARM2);
- Matrix4x4_CreateFromQuakeEntity(&matrix, pos[0], pos[1], pos[2], 0, 0, 0, PRVM_G_FLOAT(OFS_PARM1));
- R_RTLight_Update(&r_refdef.scene.lights[r_refdef.scene.numlights++], false, &matrix, col, -1, NULL, true, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+ if (prog->argc >= 4)
+ {
+ style = (int)PRVM_G_FLOAT(OFS_PARM3);
+ if (style >= MAX_LIGHTSTYLES)
+ {
+ Con_DPrintf("VM_CL_R_AddDynamicLight: out of bounds lightstyle index %i\n", style);
+ style = -1;
+ }
+ }
+ if (prog->argc >= 5)
+ cubemapname = PRVM_G_STRING(OFS_PARM4);
+ if (prog->argc >= 6)
+ pflags = (int)PRVM_G_FLOAT(OFS_PARM5);
+ coronaintensity = (pflags & PFLAGS_CORONA) != 0;
+ castshadow = (pflags & PFLAGS_NOSHADOW) == 0;
+
+ VectorScale(prog->globals.client->v_forward, radius, forward);
+ VectorScale(prog->globals.client->v_right, -radius, left);
+ VectorScale(prog->globals.client->v_up, radius, up);
+ Matrix4x4_FromVectors(&matrix, forward, left, up, org);
+
+ R_RTLight_Update(&r_refdef.scene.lights[r_refdef.scene.numlights++], false, &matrix, col, style, cubemapname, castshadow, coronaintensity, coronasizescale, ambientscale, diffusescale, specularscale, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
}
//============================================================================
int i, frame;
VM_SAFEPARMCOUNT(1, VM_CL_getinputstate);
frame = (int)PRVM_G_FLOAT(OFS_PARM0);
- for (i = 0;i < cl.movement_numqueue;i++)
- if (cl.movement_queue[i].sequence == frame)
+ for (i = 0;i < CL_MAX_USERCMDS;i++)
+ {
+ if (cl.movecmd[i].sequence == frame)
{
- VectorCopy(cl.movement_queue[i].viewangles, prog->globals.client->input_angles);
- //prog->globals.client->input_buttons = cl.movement_queue[i].//FIXME
- VectorCopy(cl.movement_queue[i].move, prog->globals.client->input_movevalues);
- prog->globals.client->input_timelength = cl.movement_queue[i].frametime;
- if(cl.movement_queue[i].crouch)
+ VectorCopy(cl.movecmd[i].viewangles, prog->globals.client->input_angles);
+ prog->globals.client->input_buttons = cl.movecmd[i].buttons; // FIXME: this should not be directly exposed to csqc (translation layer needed?)
+ prog->globals.client->input_movevalues[0] = cl.movecmd[i].forwardmove;
+ prog->globals.client->input_movevalues[1] = cl.movecmd[i].sidemove;
+ prog->globals.client->input_movevalues[2] = cl.movecmd[i].upmove;
+ prog->globals.client->input_timelength = cl.movecmd[i].frametime;
+ if(cl.movecmd[i].crouch)
{
VectorCopy(cl.playercrouchmins, prog->globals.client->pmove_mins);
VectorCopy(cl.playercrouchmaxs, prog->globals.client->pmove_maxs);
VectorCopy(cl.playerstandmaxs, prog->globals.client->pmove_maxs);
}
}
+ }
}
//#346 void(float sens) setsensitivityscaler (EXT_CSQC)
PRVM_G_INT(OFS_RETURN) = OFS_NULL;
Sbar_SortFrags();
- i = Sbar_GetPlayer(i);
- if(i < 0)
+ if (i < 0)
+ i = Sbar_GetSortedPlayerIndex(-1-i);
+ if(i < 0 || i >= cl.maxclients)
return;
t[0] = 0;
switch( attributetype ) {
// float SPA_POSITION = 0;
case 0:
- VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
+ 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:
}
// #443 void(entity e, entity tagentity, string tagname) setattachment
-static void VM_CL_setattachment (void)
+void VM_CL_setattachment (void)
{
prvm_edict_t *e;
prvm_edict_t *tagentity;
}
// #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
-static void VM_CL_gettagindex (void)
+void VM_CL_gettagindex (void)
{
prvm_edict_t *ent;
const char *tag_name;
}
// #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
-static void VM_CL_gettaginfo (void)
+void VM_CL_gettaginfo (void)
{
prvm_edict_t *e;
int tagindex;
{
rtexture_t *texture;
int drawflag;
- int element3i[3];
+ unsigned short elements[3];
}vmpolygons_triangle_t;
typedef struct vmpolygons_s
int max_triangles;
int num_triangles;
vmpolygons_triangle_t *data_triangles;
- int *data_sortedelement3i;
+ unsigned short *data_sortedelement3s;
qboolean begin_active;
rtexture_t *begin_texture;
// FIXME: make VM_CL_R_Polygon functions use Debug_Polygon functions?
vmpolygons_t vmpolygons[PRVM_MAXPROGS];
+//#304 void() renderscene (EXT_CSQC)
+// moved that here to reset the polygons,
+// resetting them earlier causes R_Mesh_Draw to be called with numvertices = 0
+// --blub
+void VM_CL_R_RenderScene (void)
+{
+ vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
+ VM_SAFEPARMCOUNT(0, VM_CL_R_RenderScene);
+ // we need to update any RENDER_VIEWMODEL entities at this point because
+ // csqc supplies its own view matrix
+ CL_UpdateViewEntities();
+ // now draw stuff!
+ R_RenderView();
+
+ polys->num_vertices = polys->num_triangles = 0;
+}
+
static void VM_ResizePolygons(vmpolygons_t *polys)
{
float *oldvertex3f = polys->data_vertex3f;
float *oldcolor4f = polys->data_color4f;
float *oldtexcoord2f = polys->data_texcoord2f;
vmpolygons_triangle_t *oldtriangles = polys->data_triangles;
- int *oldsortedelement3i = polys->data_sortedelement3i;
- polys->max_vertices = polys->max_triangles*3;
+ unsigned short *oldsortedelement3s = polys->data_sortedelement3s;
+ polys->max_vertices = min(polys->max_triangles*3, 65536);
polys->data_vertex3f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[3]));
polys->data_color4f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[4]));
polys->data_texcoord2f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[2]));
polys->data_triangles = (vmpolygons_triangle_t *)Mem_Alloc(polys->pool, polys->max_triangles*sizeof(vmpolygons_triangle_t));
- polys->data_sortedelement3i = (int *)Mem_Alloc(polys->pool, polys->max_triangles*sizeof(int[3]));
+ polys->data_sortedelement3s = (unsigned short *)Mem_Alloc(polys->pool, polys->max_triangles*sizeof(unsigned short[3]));
if (polys->num_vertices)
{
memcpy(polys->data_vertex3f, oldvertex3f, polys->num_vertices*sizeof(float[3]));
if (polys->num_triangles)
{
memcpy(polys->data_triangles, oldtriangles, polys->num_triangles*sizeof(vmpolygons_triangle_t));
- memcpy(polys->data_sortedelement3i, oldsortedelement3i, polys->num_triangles*sizeof(int[3]));
+ memcpy(polys->data_sortedelement3s, oldsortedelement3s, polys->num_triangles*sizeof(unsigned short[3]));
}
if (oldvertex3f)
Mem_Free(oldvertex3f);
Mem_Free(oldtexcoord2f);
if (oldtriangles)
Mem_Free(oldtriangles);
- if (oldsortedelement3i)
- Mem_Free(oldsortedelement3i);
+ if (oldsortedelement3s)
+ Mem_Free(oldsortedelement3s);
}
static void VM_InitPolygons (vmpolygons_t* polys)
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;)
{
int numtriangles = 0;
{
if (polys->data_triangles[surfacelist[surfacelistindex]].texture != tex || polys->data_triangles[surfacelist[surfacelistindex]].drawflag != drawflag)
break;
- VectorCopy(polys->data_triangles[surfacelist[surfacelistindex]].element3i, polys->data_sortedelement3i + 3*numtriangles);
+ VectorCopy(polys->data_triangles[surfacelist[surfacelistindex]].elements, polys->data_sortedelement3s + 3*numtriangles);
numtriangles++;
}
- R_Mesh_Draw(0, polys->num_vertices, numtriangles, polys->data_sortedelement3i, 0, 0);
+ R_Mesh_Draw(0, polys->num_vertices, 0, numtriangles, NULL, polys->data_sortedelement3s, 0, 0);
}
}
mesh.texture = polys->begin_texture;
mesh.num_vertices = polys->begin_vertices;
mesh.num_triangles = polys->begin_vertices-2;
- mesh.data_element3i = polygonelements;
+ mesh.data_element3s = polygonelements;
mesh.data_vertex3f = polys->begin_vertex[0];
mesh.data_color4f = polys->begin_color[0];
mesh.data_texcoord2f = polys->begin_texcoord[0];
polys->max_triangles *= 2;
VM_ResizePolygons(polys);
}
- memcpy(polys->data_vertex3f + polys->num_vertices * 3, polys->begin_vertex[0], polys->num_vertices * sizeof(float[3]));
- memcpy(polys->data_color4f + polys->num_vertices * 4, polys->begin_color[0], polys->num_vertices * sizeof(float[4]));
- memcpy(polys->data_texcoord2f + polys->num_vertices * 2, polys->begin_texcoord[0], polys->num_vertices * sizeof(float[2]));
- for (i = 0;i < polys->begin_vertices-2;i++)
+ if (polys->num_vertices + polys->begin_vertices <= polys->max_vertices)
{
- polys->data_triangles[polys->num_triangles].texture = polys->begin_texture;
- polys->data_triangles[polys->num_triangles].drawflag = polys->begin_drawflag;
- polys->data_triangles[polys->num_triangles].element3i[0] = polys->num_vertices;
- polys->data_triangles[polys->num_triangles].element3i[1] = polys->num_vertices + i+1;
- polys->data_triangles[polys->num_triangles].element3i[2] = polys->num_vertices + i+2;
- polys->num_triangles++;
+ // needle in a haystack!
+ // polys->num_vertices was used for copying where we actually want to copy begin_vertices
+ // that also caused it to not render the first polygon that is added
+ // --blub
+ memcpy(polys->data_vertex3f + polys->num_vertices * 3, polys->begin_vertex[0], polys->begin_vertices * sizeof(float[3]));
+ memcpy(polys->data_color4f + polys->num_vertices * 4, polys->begin_color[0], polys->begin_vertices * sizeof(float[4]));
+ memcpy(polys->data_texcoord2f + polys->num_vertices * 2, polys->begin_texcoord[0], polys->begin_vertices * sizeof(float[2]));
+ for (i = 0;i < polys->begin_vertices-2;i++)
+ {
+ polys->data_triangles[polys->num_triangles].texture = polys->begin_texture;
+ polys->data_triangles[polys->num_triangles].drawflag = polys->begin_drawflag;
+ polys->data_triangles[polys->num_triangles].elements[0] = polys->num_vertices;
+ polys->data_triangles[polys->num_triangles].elements[1] = polys->num_vertices + i+1;
+ polys->data_triangles[polys->num_triangles].elements[2] = polys->num_vertices + i+2;
+ polys->num_triangles++;
+ }
+ polys->num_vertices += polys->begin_vertices;
}
- polys->num_vertices += polys->begin_vertices;
}
polys->begin_active = false;
}
for (i = 0;i < polys->num_triangles;i++)
{
- VectorMAMAM(1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].element3i[0], 1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].element3i[1], 1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].element3i[2], center);
+ VectorMAMAM(1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].elements[0], 1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].elements[1], 1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].elements[2], center);
R_MeshQueue_AddTransparent(center, VM_DrawPolygonCallback, NULL, i, NULL);
}
- polys->num_triangles = 0;
- polys->num_vertices = 0;
+ /*polys->num_triangles = 0; // now done after rendering the scene,
+ polys->num_vertices = 0; // otherwise it's not rendered at all and prints an error message --blub */
}
//void(string texturename, float flag) R_BeginPolygon
VM_InitPolygons(polys);
if (polys->begin_active)
{
- VM_Warning("VM_CL_R_PolygonBegin: called twice without VM_CL_R_PolygonEnd after first\n");
+ VM_Warning("VM_CL_R_PolygonBegin: called twice without VM_CL_R_PolygonBegin after first\n");
return;
}
picname = PRVM_G_STRING(OFS_PARM0);
- polys->begin_texture = picname[0] ? Draw_CachePic(picname, true)->tex : r_texture_white;
+ polys->begin_texture = picname[0] ? Draw_CachePic (picname)->tex : r_texture_white;
polys->begin_drawflag = (int)PRVM_G_FLOAT(OFS_PARM1);
polys->begin_vertices = 0;
polys->begin_active = true;
Con_Printf("Debug_PolygonBegin: called twice without Debug_PolygonEnd after first\n");
return;
}
- debugPolys.begin_texture = picname[0] ? Draw_CachePic(picname, true)->tex : r_texture_white;
+ debugPolys.begin_texture = picname[0] ? Draw_CachePic (picname)->tex : r_texture_white;
debugPolys.begin_drawflag = drawflag;
debugPolys.begin_vertices = 0;
debugPolys.begin_active = true;
VM_gecko_resize, // #492 void gecko_resize( string name, float w, float h )
VM_gecko_get_texture_extent, // #493 vector gecko_get_texture_extent( string name )
VM_crc16, // #494 float(float caseinsensitive, string s, ...) crc16 = #494 (DP_QC_CRC16)
-NULL, // #495
+VM_cvar_type, // #495 float(string name) cvar_type = #495; (DP_QC_CVAR_TYPE)
NULL, // #496
NULL, // #497
NULL, // #498
NULL, // #499
+NULL, // #500
+NULL, // #501
+NULL, // #502
+NULL, // #503
+NULL, // #504
+NULL, // #505
+NULL, // #506
+NULL, // #507
+NULL, // #508
+NULL, // #509
+VM_uri_escape, // #510 string(string in) uri_escape = #510;
+VM_uri_unescape, // #511 string(string in) uri_unescape = #511;
+VM_etof, // #512 float(entity ent) num_for_edict = #512 (DP_QC_NUM_FOR_EDICT)
+NULL, // #513
+NULL, // #514
+NULL, // #515
+NULL, // #516
+NULL, // #517
+NULL, // #518
+NULL, // #519
};
const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);
projects / xonotic / darkplaces.git / blobdiff