X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=clvm_cmds.c;h=cd35395fa6a480983b862e0788674b981ed1a6af;hp=e43ce8942943368d9a3d2c245ddd0db592c2ed4f;hb=7a96ec58916ceea50684acf4c00eaef551199fef;hpb=79e332ad14e7ec9dbd2702a2d28127f7600f0678

diff --git a/clvm_cmds.c b/clvm_cmds.c
index e43ce894..cd35395f 100644
--- a/clvm_cmds.c
+++ b/clvm_cmds.c
@@ -77,7 +77,7 @@ void VM_CL_setmodel (void)
 {
 	prvm_edict_t	*e;
 	const char		*m;
-	model_t *mod;
+	dp_model_t *mod;
 	int				i;
 
 	VM_SAFEPARMCOUNT(2, VM_CL_setmodel);
@@ -363,7 +363,7 @@ void VM_CL_precache_model (void)
 {
 	const char	*name;
 	int			i;
-	model_t		*m;
+	dp_model_t		*m;
 
 	VM_SAFEPARMCOUNT(1, VM_CL_precache_model);
 
@@ -384,7 +384,7 @@ void VM_CL_precache_model (void)
 		{
 			if (!cl.csqc_model_precache[i])
 			{
-				cl.csqc_model_precache[i] = (model_t*)m;
+				cl.csqc_model_precache[i] = (dp_model_t*)m;
 				PRVM_G_FLOAT(OFS_RETURN) = -(i+1);
 				return;
 			}
@@ -689,6 +689,7 @@ void VM_CL_R_ClearScene (void)
 	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;
@@ -763,10 +764,10 @@ void VM_CL_R_SetView (void)
 		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:
@@ -843,7 +844,7 @@ void VM_CL_R_SetView (void)
 		r_refdef.view.useperspective = k != 0;
 		break;
 	case VF_CLEARSCREEN:
-		r_refdef.view.clear = k ? true : false;
+		r_refdef.view.isoverlay = !k;
 		break;
 	default:
 		PRVM_G_FLOAT(OFS_RETURN) = 0;
@@ -853,21 +854,54 @@ void VM_CL_R_SetView (void)
 	PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 
-//#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);
 }
 
 //============================================================================
@@ -1009,7 +1043,7 @@ static void VM_CL_setmodelindex (void)
 //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
 static void VM_CL_modelnameforindex (void)
 {
-	model_t *model;
+	dp_model_t *model;
 
 	VM_SAFEPARMCOUNT(1, VM_CL_modelnameforindex);
 
@@ -1774,9 +1808,9 @@ static void VM_CL_te_flamejet (void)
 //====================================================================
 //DP_QC_GETSURFACE
 
-extern void clippointtosurface(model_t *model, msurface_t *surface, vec3_t p, vec3_t out);
+extern void clippointtosurface(dp_model_t *model, msurface_t *surface, vec3_t p, vec3_t out);
 
-static msurface_t *cl_getsurface(model_t *model, int surfacenum)
+static msurface_t *cl_getsurface(dp_model_t *model, int surfacenum)
 {
 	if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces)
 		return NULL;
@@ -1786,7 +1820,7 @@ static msurface_t *cl_getsurface(model_t *model, int surfacenum)
 // #434 float(entity e, float s) getsurfacenumpoints
 static void VM_CL_getsurfacenumpoints(void)
 {
-	model_t *model;
+	dp_model_t *model;
 	msurface_t *surface;
 	VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenumpoints);
 	// return 0 if no such surface
@@ -1804,7 +1838,7 @@ static void VM_CL_getsurfacenumpoints(void)
 static void VM_CL_getsurfacepoint(void)
 {
 	prvm_edict_t *ed;
-	model_t *model;
+	dp_model_t *model;
 	msurface_t *surface;
 	int pointnum;
 	VM_SAFEPARMCOUNT(3, VM_CL_getsurfacenumpoints);
@@ -1831,7 +1865,7 @@ static void VM_CL_getsurfacepoint(void)
 static void VM_CL_getsurfacepointattribute(void)
 {
 	prvm_edict_t *ed;
-	model_t *model;
+	dp_model_t *model;
 	msurface_t *surface;
 	int pointnum;
 	int attributetype;
@@ -1897,7 +1931,7 @@ static void VM_CL_getsurfacepointattribute(void)
 // #436 vector(entity e, float s) getsurfacenormal
 static void VM_CL_getsurfacenormal(void)
 {
-	model_t *model;
+	dp_model_t *model;
 	msurface_t *surface;
 	vec3_t normal;
 	VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenormal);
@@ -1916,7 +1950,7 @@ static void VM_CL_getsurfacenormal(void)
 // #437 string(entity e, float s) getsurfacetexture
 static void VM_CL_getsurfacetexture(void)
 {
-	model_t *model;
+	dp_model_t *model;
 	msurface_t *surface;
 	VM_SAFEPARMCOUNT(2, VM_CL_getsurfacetexture);
 	PRVM_G_INT(OFS_RETURN) = OFS_NULL;
@@ -1932,7 +1966,7 @@ static void VM_CL_getsurfacenearpoint(void)
 	vec3_t clipped, p;
 	vec_t dist, bestdist;
 	prvm_edict_t *ed;
-	model_t *model = NULL;
+	dp_model_t *model = NULL;
 	msurface_t *surface;
 	vec_t *point;
 	VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenearpoint);
@@ -1975,7 +2009,7 @@ static void VM_CL_getsurfacenearpoint(void)
 static void VM_CL_getsurfaceclippedpoint(void)
 {
 	prvm_edict_t *ed;
-	model_t *model;
+	dp_model_t *model;
 	msurface_t *surface;
 	vec3_t p, out;
 	VM_SAFEPARMCOUNT(3, VM_CL_getsurfaceclippedpoint);
@@ -1998,7 +2032,7 @@ void VM_CL_setattachment (void)
 	const char *tagname;
 	prvm_eval_t *v;
 	int modelindex;
-	model_t *model;
+	dp_model_t *model;
 	VM_SAFEPARMCOUNT(3, VM_CL_setattachment);
 
 	e = PRVM_G_EDICT(OFS_PARM0);
@@ -2046,7 +2080,7 @@ void VM_CL_setattachment (void)
 
 int CL_GetTagIndex (prvm_edict_t *e, const char *tagname)
 {
-	model_t *model = CL_GetModelFromEdict(e);
+	dp_model_t *model = CL_GetModelFromEdict(e);
 	if (model)
 		return Mod_Alias_GetTagIndexForName(model, (int)e->fields.client->skin, tagname);
 	else
@@ -2069,7 +2103,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 	int reqframe, attachloop;
 	matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
 	prvm_edict_t *attachent;
-	model_t *model;
+	dp_model_t *model;
 	float scale;
 
 	*out = identitymatrix; // warnings and errors return identical matrix
@@ -2264,7 +2298,7 @@ typedef struct vmpolygons_triangle_s
 {
 	rtexture_t		*texture;
 	int				drawflag;
-	int				element3i[3];
+	unsigned short	elements[3];
 }vmpolygons_triangle_t;
 
 typedef struct vmpolygons_s
@@ -2281,7 +2315,7 @@ 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;
@@ -2318,13 +2352,13 @@ static void VM_ResizePolygons(vmpolygons_t *polys)
 	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]));
@@ -2334,7 +2368,7 @@ static void VM_ResizePolygons(vmpolygons_t *polys)
 	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);
@@ -2344,8 +2378,8 @@ static void VM_ResizePolygons(vmpolygons_t *polys)
 		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)
@@ -2386,10 +2420,10 @@ static void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t
 		{
 			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);
 	}
 }
 
@@ -2402,7 +2436,7 @@ void VMPolygons_Store(vmpolygons_t *polys)
 		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];
@@ -2417,23 +2451,26 @@ void VMPolygons_Store(vmpolygons_t *polys)
 			polys->max_triangles *= 2;
 			VM_ResizePolygons(polys);
 		}
-		// 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++)
+		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;
 }
@@ -2455,7 +2492,7 @@ void VM_CL_AddPolygonsToMeshQueue (void)
 
 	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);
 	}