-Beautified a function just for fun (better variable names).
authorblack <black@d7cf8633-e32d-0410-b094-e92efae38249>
Mon, 14 Mar 2005 21:16:13 +0000 (21:16 +0000)
committerblack <black@d7cf8633-e32d-0410-b094-e92efae38249>
Mon, 14 Mar 2005 21:16:13 +0000 (21:16 +0000)
-Added the prvm builtin altstr_ins which inserts a new item into an
 altstring.

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@5084 d7cf8633-e32d-0410-b094-e92efae38249

cl_video.h
prvm_cmds.c
r_shadow.c

index 5d9cd2f..bd706bc 100644 (file)
@@ -36,8 +36,11 @@ typedef struct clvideo_s
        cachepic_t cpif;
 
        // if a video is suspended, it is automatically paused (else we'd still have to process the frames)
-    double  lasttime; // used to determine whether the video's resources should be freed or not
-       qboolean suspended; // when lasttime - realtime > THRESHOLD, all but the stream is freed
+       
+       // used to determine whether the video's resources should be freed or not
+    double  lasttime; 
+       // when lasttime - realtime > THRESHOLD, all but the stream is freed
+       qboolean suspended; 
 
        char    filename[MAX_QPATH];
 } clvideo_t;
index 126d3a4..8a0b232 100644 (file)
@@ -104,6 +104,7 @@ float       altstr_count(string)
 string altstr_prepare(string)
 string altstr_get(string,float)
 string altstr_set(string altstr, float num, string set)
+string altstr_ins(string altstr, float num, string set)
 
 perhaps only : Menu : WriteMsg
 ===============================
@@ -3122,6 +3123,40 @@ void VM_altstr_set( void )
        PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr );
 }
 
+/*
+========================
+VM_altstr_ins
+insert after num
+string altstr_ins(string altstr, float num, string set)
+========================
+*/
+void VM_altstr_ins(void)
+{
+       int num;
+       char *setstr;
+       char *set;
+       char *instr;
+       char *in;
+       char *outstr;
+       char *out;
+
+       in = instr = PRVM_G_STRING( OFS_PARM0 );
+       num = PRVM_G_FLOAT( OFS_PARM1 );
+       set = setstr = PRVM_G_STRING( OFS_PARM2 );
+       
+       out = outstr = VM_GetTempString();      
+       for( num = num * 2 + 2 ; *in && num > 0 ; *out++ = *in++ )
+               if( *in == '\\' && !*++in )
+                       break;
+               else if( *in == '\'' )
+                       num--;
+
+       for( ; *set ; *out++ = *set++ );
+
+       strcpy( out, in );
+       PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( outstr );
+}
+
 void VM_Cmd_Init(void)
 {
        // only init the stuff for the current prog
@@ -3952,8 +3987,9 @@ prvm_builtin_t vm_m_builtins[] = {
        VM_altstr_count,
        VM_altstr_prepare,
        VM_altstr_get,
-       VM_altstr_set,  // 85
-       0,0,0,0,0,      // 90
+       VM_altstr_set,
+       VM_altstr_ins,  // 86
+       0,0,0,0,        // 90
        e10,                    // 100
        e100,                   // 200
        e100,                   // 300
index 6bc9c8b..0f0bd69 100644 (file)
@@ -738,10 +738,10 @@ void R_Shadow_PrepareShadowMark(int numtris)
 
 int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int *inelement3i, const int *inneighbor3i, const float *invertex3f, int *outnumvertices, int *outelement3i, float *outvertex3f, const float *projectorigin, float projectdistance, int numshadowmarktris, const int *shadowmarktris)
 {
-       int i, j, tris = 0, vr[3], t, outvertices = 0;
-       float f, temp[3];
-       const int *e, *n;
-       const float *v;
+       int i, j;
+       int outtriangles = 0, outvertices = 0;
+       const int *element;
+       const float *vertex;
 
        if (maxvertexupdate < innumvertices)
        {
@@ -767,22 +767,22 @@ int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int *
 
        for (i = 0;i < numshadowmarktris;i++)
        {
-               t = shadowmarktris[i];
-               e = inelement3i + t * 3;
+               element = inelement3i + shadowmarktris[i] * 3;
                // make sure the vertices are created
                for (j = 0;j < 3;j++)
                {
-                       if (vertexupdate[e[j]] != vertexupdatenum)
+                       if (vertexupdate[element[j]] != vertexupdatenum)
                        {
-                               vertexupdate[e[j]] = vertexupdatenum;
-                               vertexremap[e[j]] = outvertices;
-                               v = invertex3f + e[j] * 3;
+                               float ratio, direction[3];
+                               vertexupdate[element[j]] = vertexupdatenum;
+                               vertexremap[element[j]] = outvertices;
+                               vertex = invertex3f + element[j] * 3;
                                // project one copy of the vertex to the sphere radius of the light
                                // (FIXME: would projecting it to the light box be better?)
-                               VectorSubtract(v, projectorigin, temp);
-                               f = projectdistance / VectorLength(temp);
-                               VectorCopy(v, outvertex3f);
-                               VectorMA(projectorigin, f, temp, (outvertex3f + 3));
+                               VectorSubtract(vertex, projectorigin, direction);
+                               ratio = projectdistance / VectorLength(direction);
+                               VectorCopy(vertex, outvertex3f);
+                               VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
                                outvertex3f += 6;
                                outvertices += 2;
                        }
@@ -791,62 +791,70 @@ int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int *
 
        for (i = 0;i < numshadowmarktris;i++)
        {
-               t = shadowmarktris[i];
-               e = inelement3i + t * 3;
-               n = inneighbor3i + t * 3;
+               int remappedelement[3];
+               int markindex;
+               const int *neighbortriangle;
+
+               markindex = shadowmarktris[i] * 3;
+               element = inelement3i + markindex;
+               neighbortriangle = inneighbor3i + markindex;
                // output the front and back triangles
-               outelement3i[0] = vertexremap[e[0]];
-               outelement3i[1] = vertexremap[e[1]];
-               outelement3i[2] = vertexremap[e[2]];
-               outelement3i[3] = vertexremap[e[2]] + 1;
-               outelement3i[4] = vertexremap[e[1]] + 1;
-               outelement3i[5] = vertexremap[e[0]] + 1;
+               outelement3i[0] = vertexremap[element[0]];
+               outelement3i[1] = vertexremap[element[1]];
+               outelement3i[2] = vertexremap[element[2]];
+               outelement3i[3] = vertexremap[element[2]] + 1;
+               outelement3i[4] = vertexremap[element[1]] + 1;
+               outelement3i[5] = vertexremap[element[0]] + 1;
+
                outelement3i += 6;
-               tris += 2;
+               outtriangles += 2;
                // output the sides (facing outward from this triangle)
-               if (shadowmark[n[0]] != shadowmarkcount)
+               if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
                {
-                       vr[0] = vertexremap[e[0]];
-                       vr[1] = vertexremap[e[1]];
-                       outelement3i[0] = vr[1];
-                       outelement3i[1] = vr[0];
-                       outelement3i[2] = vr[0] + 1;
-                       outelement3i[3] = vr[1];
-                       outelement3i[4] = vr[0] + 1;
-                       outelement3i[5] = vr[1] + 1;
+                       remappedelement[0] = vertexremap[element[0]];
+                       remappedelement[1] = vertexremap[element[1]];
+                       outelement3i[0] = remappedelement[1];
+                       outelement3i[1] = remappedelement[0];
+                       outelement3i[2] = remappedelement[0] + 1;
+                       outelement3i[3] = remappedelement[1];
+                       outelement3i[4] = remappedelement[0] + 1;
+                       outelement3i[5] = remappedelement[1] + 1;
+
                        outelement3i += 6;
-                       tris += 2;
+                       outtriangles += 2;
                }
-               if (shadowmark[n[1]] != shadowmarkcount)
+               if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
                {
-                       vr[1] = vertexremap[e[1]];
-                       vr[2] = vertexremap[e[2]];
-                       outelement3i[0] = vr[2];
-                       outelement3i[1] = vr[1];
-                       outelement3i[2] = vr[1] + 1;
-                       outelement3i[3] = vr[2];
-                       outelement3i[4] = vr[1] + 1;
-                       outelement3i[5] = vr[2] + 1;
+                       remappedelement[1] = vertexremap[element[1]];
+                       remappedelement[2] = vertexremap[element[2]];
+                       outelement3i[0] = remappedelement[2];
+                       outelement3i[1] = remappedelement[1];
+                       outelement3i[2] = remappedelement[1] + 1;
+                       outelement3i[3] = remappedelement[2];
+                       outelement3i[4] = remappedelement[1] + 1;
+                       outelement3i[5] = remappedelement[2] + 1;
+
                        outelement3i += 6;
-                       tris += 2;
+                       outtriangles += 2;
                }
-               if (shadowmark[n[2]] != shadowmarkcount)
+               if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
                {
-                       vr[0] = vertexremap[e[0]];
-                       vr[2] = vertexremap[e[2]];
-                       outelement3i[0] = vr[0];
-                       outelement3i[1] = vr[2];
-                       outelement3i[2] = vr[2] + 1;
-                       outelement3i[3] = vr[0];
-                       outelement3i[4] = vr[2] + 1;
-                       outelement3i[5] = vr[0] + 1;
+                       remappedelement[0] = vertexremap[element[0]];
+                       remappedelement[2] = vertexremap[element[2]];
+                       outelement3i[0] = remappedelement[0];
+                       outelement3i[1] = remappedelement[2];
+                       outelement3i[2] = remappedelement[2] + 1;
+                       outelement3i[3] = remappedelement[0];
+                       outelement3i[4] = remappedelement[2] + 1;
+                       outelement3i[5] = remappedelement[0] + 1;
+
                        outelement3i += 6;
-                       tris += 2;
+                       outtriangles += 2;
                }
        }
        if (outnumvertices)
                *outnumvertices = outvertices;
-       return tris;
+       return outtriangles;
 }
 
 void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f, const int *elements, const int *neighbors, const vec3_t projectorigin, float projectdistance, int nummarktris, const int *marktris)