gl_models.c

   1
   2 #include "quakedef.h"
   3
   4 cvar_t r_quickmodels = {0, "r_quickmodels", "1"};
   5
   6 typedef struct
   7 {
   8         float m[3][4];
   9 } zymbonematrix;
  10
  11 // LordHavoc: vertex arrays
  12
  13 float *aliasvertbuf;
  14 float *aliasvertcolorbuf;
  15 float *aliasvert; // this may point at aliasvertbuf or at vertex arrays in the mesh backend
  16 float *aliasvertcolor; // this may point at aliasvertcolorbuf or at vertex arrays in the mesh backend
  17
  18 float *aliasvertcolor2;
  19 float *aliasvertnorm;
  20 int *aliasvertusage;
  21 zymbonematrix *zymbonepose;
  22
  23 mempool_t *gl_models_mempool;
  24
  25 void gl_models_start(void)
  26 {
  27         // allocate vertex processing arrays
  28         gl_models_mempool = Mem_AllocPool("GL_Models");
  29         aliasvert = aliasvertbuf = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4]));
  30         aliasvertcolor = aliasvertcolorbuf = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4]));
  31         aliasvertnorm = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][3]));
  32         aliasvertcolor2 = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4])); // used temporarily for tinted coloring
  33         zymbonepose = Mem_Alloc(gl_models_mempool, sizeof(zymbonematrix[256]));
  34         aliasvertusage = Mem_Alloc(gl_models_mempool, sizeof(int[MD2MAX_VERTS]));
  35 }
  36
  37 void gl_models_shutdown(void)
  38 {
  39         Mem_FreePool(&gl_models_mempool);
  40 }
  41
  42 void gl_models_newmap(void)
  43 {
  44 }
  45
  46 void GL_Models_Init(void)
  47 {
  48         Cvar_RegisterVariable(&r_quickmodels);
  49
  50         R_RegisterModule("GL_Models", gl_models_start, gl_models_shutdown, gl_models_newmap);
  51 }
  52
  53 /*
  54 void R_AliasTransformVerts(int vertcount)
  55 {
  56         vec3_t point;
  57         float *av;
  58         av = aliasvert;
  59         while (vertcount >= 4)
  60         {
  61                 VectorCopy(av, point);softwaretransform(point, av);av += 4;
  62                 VectorCopy(av, point);softwaretransform(point, av);av += 4;
  63                 VectorCopy(av, point);softwaretransform(point, av);av += 4;
  64                 VectorCopy(av, point);softwaretransform(point, av);av += 4;
  65                 vertcount -= 4;
  66         }
  67         while(vertcount > 0)
  68         {
  69                 VectorCopy(av, point);softwaretransform(point, av);av += 4;
  70                 vertcount--;
  71         }
  72 }
  73 */
  74
  75 void R_AliasLerpVerts(int vertcount,
  76                 float lerp1, const trivertx_t *verts1, const vec3_t fscale1, const vec3_t translate1,
  77                 float lerp2, const trivertx_t *verts2, const vec3_t fscale2, const vec3_t translate2,
  78                 float lerp3, const trivertx_t *verts3, const vec3_t fscale3, const vec3_t translate3,
  79                 float lerp4, const trivertx_t *verts4, const vec3_t fscale4, const vec3_t translate4)
  80 {
  81         int i;
  82         vec3_t scale1, scale2, scale3, scale4, translate;
  83         const float *n1, *n2, *n3, *n4;
  84         float *av, *avn;
  85         av = aliasvert;
  86         avn = aliasvertnorm;
  87         VectorScale(fscale1, lerp1, scale1);
  88         if (lerp2)
  89         {
  90                 VectorScale(fscale2, lerp2, scale2);
  91                 if (lerp3)
  92                 {
  93                         VectorScale(fscale3, lerp3, scale3);
  94                         if (lerp4)
  95                         {
  96                                 VectorScale(fscale4, lerp4, scale4);
  97                                 translate[0] = translate1[0] * lerp1 + translate2[0] * lerp2 + translate3[0] * lerp3 + translate4[0] * lerp4;
  98                                 translate[1] = translate1[1] * lerp1 + translate2[1] * lerp2 + translate3[1] * lerp3 + translate4[1] * lerp4;
  99                                 translate[2] = translate1[2] * lerp1 + translate2[2] * lerp2 + translate3[2] * lerp3 + translate4[2] * lerp4;
 100                                 // generate vertices
 101                                 for (i = 0;i < vertcount;i++)
 102                                 {
 103                                         av[0] = verts1->v[0] * scale1[0] + verts2->v[0] * scale2[0] + verts3->v[0] * scale3[0] + verts4->v[0] * scale4[0] + translate[0];
 104                                         av[1] = verts1->v[1] * scale1[1] + verts2->v[1] * scale2[1] + verts3->v[1] * scale3[1] + verts4->v[1] * scale4[1] + translate[1];
 105                                         av[2] = verts1->v[2] * scale1[2] + verts2->v[2] * scale2[2] + verts3->v[2] * scale3[2] + verts4->v[2] * scale4[2] + translate[2];
 106                                         n1 = m_bytenormals[verts1->lightnormalindex];
 107                                         n2 = m_bytenormals[verts2->lightnormalindex];
 108                                         n3 = m_bytenormals[verts3->lightnormalindex];
 109                                         n4 = m_bytenormals[verts4->lightnormalindex];
 110                                         avn[0] = n1[0] * lerp1 + n2[0] * lerp2 + n3[0] * lerp3 + n4[0] * lerp4;
 111                                         avn[1] = n1[1] * lerp1 + n2[1] * lerp2 + n3[1] * lerp3 + n4[1] * lerp4;
 112                                         avn[2] = n1[2] * lerp1 + n2[2] * lerp2 + n3[2] * lerp3 + n4[2] * lerp4;
 113                                         av += 4;
 114                                         avn += 3;
 115                                         verts1++;verts2++;verts3++;verts4++;
 116                                 }
 117                         }
 118                         else
 119                         {
 120                                 translate[0] = translate1[0] * lerp1 + translate2[0] * lerp2 + translate3[0] * lerp3;
 121                                 translate[1] = translate1[1] * lerp1 + translate2[1] * lerp2 + translate3[1] * lerp3;
 122                                 translate[2] = translate1[2] * lerp1 + translate2[2] * lerp2 + translate3[2] * lerp3;
 123                                 // generate vertices
 124                                 for (i = 0;i < vertcount;i++)
 125                                 {
 126                                         av[0] = verts1->v[0] * scale1[0] + verts2->v[0] * scale2[0] + verts3->v[0] * scale3[0] + translate[0];
 127                                         av[1] = verts1->v[1] * scale1[1] + verts2->v[1] * scale2[1] + verts3->v[1] * scale3[1] + translate[1];
 128                                         av[2] = verts1->v[2] * scale1[2] + verts2->v[2] * scale2[2] + verts3->v[2] * scale3[2] + translate[2];
 129                                         n1 = m_bytenormals[verts1->lightnormalindex];
 130                                         n2 = m_bytenormals[verts2->lightnormalindex];
 131                                         n3 = m_bytenormals[verts3->lightnormalindex];
 132                                         avn[0] = n1[0] * lerp1 + n2[0] * lerp2 + n3[0] * lerp3;
 133                                         avn[1] = n1[1] * lerp1 + n2[1] * lerp2 + n3[1] * lerp3;
 134                                         avn[2] = n1[2] * lerp1 + n2[2] * lerp2 + n3[2] * lerp3;
 135                                         av += 4;
 136                                         avn += 3;
 137                                         verts1++;verts2++;verts3++;
 138                                 }
 139                         }
 140                 }
 141                 else
 142                 {
 143                         translate[0] = translate1[0] * lerp1 + translate2[0] * lerp2;
 144                         translate[1] = translate1[1] * lerp1 + translate2[1] * lerp2;
 145                         translate[2] = translate1[2] * lerp1 + translate2[2] * lerp2;
 146                         // generate vertices
 147                         for (i = 0;i < vertcount;i++)
 148                         {
 149                                 av[0] = verts1->v[0] * scale1[0] + verts2->v[0] * scale2[0] + translate[0];
 150                                 av[1] = verts1->v[1] * scale1[1] + verts2->v[1] * scale2[1] + translate[1];
 151                                 av[2] = verts1->v[2] * scale1[2] + verts2->v[2] * scale2[2] + translate[2];
 152                                 n1 = m_bytenormals[verts1->lightnormalindex];
 153                                 n2 = m_bytenormals[verts2->lightnormalindex];
 154                                 avn[0] = n1[0] * lerp1 + n2[0] * lerp2;
 155                                 avn[1] = n1[1] * lerp1 + n2[1] * lerp2;
 156                                 avn[2] = n1[2] * lerp1 + n2[2] * lerp2;
 157                                 av += 4;
 158                                 avn += 3;
 159                                 verts1++;verts2++;
 160                         }
 161                 }
 162         }
 163         else
 164         {
 165                 translate[0] = translate1[0] * lerp1;
 166                 translate[1] = translate1[1] * lerp1;
 167                 translate[2] = translate1[2] * lerp1;
 168                 // generate vertices
 169                 if (lerp1 != 1)
 170                 {
 171                         // general but almost never used case
 172                         for (i = 0;i < vertcount;i++)
 173                         {
 174                                 av[0] = verts1->v[0] * scale1[0] + translate[0];
 175                                 av[1] = verts1->v[1] * scale1[1] + translate[1];
 176                                 av[2] = verts1->v[2] * scale1[2] + translate[2];
 177                                 n1 = m_bytenormals[verts1->lightnormalindex];
 178                                 avn[0] = n1[0] * lerp1;
 179                                 avn[1] = n1[1] * lerp1;
 180                                 avn[2] = n1[2] * lerp1;
 181                                 av += 4;
 182                                 avn += 3;
 183                                 verts1++;
 184                         }
 185                 }
 186                 else
 187                 {
 188                         // fast normal case
 189                         for (i = 0;i < vertcount;i++)
 190                         {
 191                                 av[0] = verts1->v[0] * scale1[0] + translate[0];
 192                                 av[1] = verts1->v[1] * scale1[1] + translate[1];
 193                                 av[2] = verts1->v[2] * scale1[2] + translate[2];
 194                                 VectorCopy(m_bytenormals[verts1->lightnormalindex], avn);
 195                                 av += 4;
 196                                 avn += 3;
 197                                 verts1++;
 198                         }
 199                 }
 200         }
 201 }
 202
 203 skinframe_t *R_FetchSkinFrame(const entity_render_t *ent)
 204 {
 205         model_t *model = ent->model;
 206         if (model->skinscenes[ent->skinnum].framecount > 1)
 207                 return &model->skinframes[model->skinscenes[ent->skinnum].firstframe + (int) (cl.time * 10) % model->skinscenes[ent->skinnum].framecount];
 208         else
 209                 return &model->skinframes[model->skinscenes[ent->skinnum].firstframe];
 210 }
 211
 212 void R_SetupMDLMD2Frames(const entity_render_t *ent, float colorr, float colorg, float colorb)
 213 {
 214         const md2frame_t *frame1, *frame2, *frame3, *frame4;
 215         const trivertx_t *frame1verts, *frame2verts, *frame3verts, *frame4verts;
 216         const model_t *model = ent->model;
 217
 218         frame1 = &model->mdlmd2data_frames[ent->frameblend[0].frame];
 219         frame2 = &model->mdlmd2data_frames[ent->frameblend[1].frame];
 220         frame3 = &model->mdlmd2data_frames[ent->frameblend[2].frame];
 221         frame4 = &model->mdlmd2data_frames[ent->frameblend[3].frame];
 222         frame1verts = &model->mdlmd2data_pose[ent->frameblend[0].frame * model->numverts];
 223         frame2verts = &model->mdlmd2data_pose[ent->frameblend[1].frame * model->numverts];
 224         frame3verts = &model->mdlmd2data_pose[ent->frameblend[2].frame * model->numverts];
 225         frame4verts = &model->mdlmd2data_pose[ent->frameblend[3].frame * model->numverts];
 226         R_AliasLerpVerts(model->numverts,
 227                 ent->frameblend[0].lerp, frame1verts, frame1->scale, frame1->translate,
 228                 ent->frameblend[1].lerp, frame2verts, frame2->scale, frame2->translate,
 229                 ent->frameblend[2].lerp, frame3verts, frame3->scale, frame3->translate,
 230                 ent->frameblend[3].lerp, frame4verts, frame4->scale, frame4->translate);
 231
 232         R_LightModel(ent, model->numverts, colorr, colorg, colorb, false);
 233
 234         //R_AliasTransformVerts(model->numverts);
 235 }
 236
 237 void R_DrawQ1Q2AliasModelCallback (const void *calldata1, int calldata2)
 238 {
 239         int c, pantsfullbright, shirtfullbright, colormapped;
 240         float pantscolor[3], shirtcolor[3];
 241         float fog;
 242         vec3_t diff;
 243         qbyte *bcolor;
 244         rmeshbufferinfo_t m;
 245         model_t *model;
 246         skinframe_t *skinframe;
 247         const entity_render_t *ent = calldata1;
 248
 249 //      softwaretransformforentity(ent);
 250
 251         fog = 0;
 252         if (fogenabled)
 253         {
 254                 VectorSubtract(ent->origin, r_origin, diff);
 255                 fog = DotProduct(diff,diff);
 256                 if (fog < 0.01f)
 257                         fog = 0.01f;
 258                 fog = exp(fogdensity/fog);
 259                 if (fog > 1)
 260                         fog = 1;
 261                 if (fog < 0.01f)
 262                         fog = 0;
 263                 // fog method: darken, additive fog
 264                 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
 265                 // 2. render fog as additive
 266         }
 267
 268         model = ent->model;
 269
 270         skinframe = R_FetchSkinFrame(ent);
 271
 272         colormapped = !skinframe->merged || (ent->colormap >= 0 && skinframe->base && (skinframe->pants || skinframe->shirt));
 273         if (!colormapped && !fog && !skinframe->glow && !skinframe->fog)
 274         {
 275                 // fastpath for the normal situation (one texture)
 276                 memset(&m, 0, sizeof(m));
 277                 if (ent->effects & EF_ADDITIVE)
 278                 {
 279                         m.blendfunc1 = GL_SRC_ALPHA;
 280                         m.blendfunc2 = GL_ONE;
 281                 }
 282                 else if (ent->alpha != 1.0 || skinframe->fog != NULL)
 283                 {
 284                         m.blendfunc1 = GL_SRC_ALPHA;
 285                         m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
 286                 }
 287                 else
 288                 {
 289                         m.blendfunc1 = GL_ONE;
 290                         m.blendfunc2 = GL_ZERO;
 291                 }
 292                 m.numtriangles = model->numtris;
 293                 m.numverts = model->numverts;
 294                 m.tex[0] = R_GetTexture(skinframe->merged);
 295                 m.matrix = ent->matrix;
 296
 297                 c_alias_polys += m.numtriangles;
 298                 if (R_Mesh_Draw_GetBuffer(&m, true))
 299                 {
 300                         memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 301                         memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 302
 303                         aliasvert = m.vertex;
 304                         aliasvertcolor = m.color;
 305                         R_SetupMDLMD2Frames(ent, m.colorscale * (1 - fog), m.colorscale * (1 - fog), m.colorscale * (1 - fog));
 306                         aliasvert = aliasvertbuf;
 307                         aliasvertcolor = aliasvertcolorbuf;
 308
 309                         R_Mesh_Render();
 310                 }
 311                 return;
 312         }
 313
 314         R_SetupMDLMD2Frames(ent, 1 - fog, 1 - fog, 1 - fog);
 315
 316         if (colormapped)
 317         {
 318                 // 128-224 are backwards ranges
 319                 c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
 320                 bcolor = (qbyte *) (&d_8to24table[c]);
 321                 pantsfullbright = c >= 224;
 322                 VectorScale(bcolor, (1.0f / 255.0f), pantscolor);
 323                 c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
 324                 bcolor = (qbyte *) (&d_8to24table[c]);
 325                 shirtfullbright = c >= 224;
 326                 VectorScale(bcolor, (1.0f / 255.0f), shirtcolor);
 327         }
 328         else
 329         {
 330                 pantscolor[0] = pantscolor[1] = pantscolor[2] = shirtcolor[0] = shirtcolor[1] = shirtcolor[2] = 1;
 331                 pantsfullbright = shirtfullbright = false;
 332         }
 333
 334         memset(&m, 0, sizeof(m));
 335         if (ent->effects & EF_ADDITIVE)
 336         {
 337                 m.blendfunc1 = GL_SRC_ALPHA;
 338                 m.blendfunc2 = GL_ONE;
 339         }
 340         else if (ent->alpha != 1.0 || skinframe->fog != NULL)
 341         {
 342                 m.blendfunc1 = GL_SRC_ALPHA;
 343                 m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
 344         }
 345         else
 346         {
 347                 m.blendfunc1 = GL_ONE;
 348                 m.blendfunc2 = GL_ZERO;
 349         }
 350         m.numtriangles = model->numtris;
 351         m.numverts = model->numverts;
 352         m.tex[0] = colormapped ? R_GetTexture(skinframe->base) : R_GetTexture(skinframe->merged);
 353         m.matrix = ent->matrix;
 354         if (R_Mesh_Draw_GetBuffer(&m, true))
 355         {
 356                 c_alias_polys += m.numtriangles;
 357                 R_ModulateColors(aliasvertcolor, m.color, m.numverts, m.colorscale, m.colorscale, m.colorscale);
 358                 memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 359                 memcpy(m.vertex, aliasvert, m.numverts * sizeof(float[4]));
 360                 memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 361                 R_Mesh_Render();
 362         }
 363
 364         if (colormapped)
 365         {
 366                 if (skinframe->pants)
 367                 {
 368                         memset(&m, 0, sizeof(m));
 369                         m.blendfunc1 = GL_SRC_ALPHA;
 370                         m.blendfunc2 = GL_ONE;
 371                         m.numtriangles = model->numtris;
 372                         m.numverts = model->numverts;
 373                         m.tex[0] = R_GetTexture(skinframe->pants);
 374                         m.matrix = ent->matrix;
 375                         if (R_Mesh_Draw_GetBuffer(&m, true))
 376                         {
 377                                 c_alias_polys += m.numtriangles;
 378                                 if (pantsfullbright)
 379                                         R_FillColors(m.color, m.numverts, pantscolor[0] * m.colorscale, pantscolor[1] * m.colorscale, pantscolor[2] * m.colorscale, ent->alpha);
 380                                 else
 381                                         R_ModulateColors(aliasvertcolor, m.color, m.numverts, pantscolor[0] * m.colorscale, pantscolor[1] * m.colorscale, pantscolor[2] * m.colorscale);
 382                                 memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 383                                 memcpy(m.vertex, aliasvert, m.numverts * sizeof(float[4]));
 384                                 memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 385                                 R_Mesh_Render();
 386                         }
 387                 }
 388                 if (skinframe->shirt)
 389                 {
 390                         memset(&m, 0, sizeof(m));
 391                         m.blendfunc1 = GL_SRC_ALPHA;
 392                         m.blendfunc2 = GL_ONE;
 393                         m.numtriangles = model->numtris;
 394                         m.numverts = model->numverts;
 395                         m.tex[0] = R_GetTexture(skinframe->shirt);
 396                         m.matrix = ent->matrix;
 397                         if (R_Mesh_Draw_GetBuffer(&m, true))
 398                         {
 399                                 c_alias_polys += m.numtriangles;
 400                                 if (shirtfullbright)
 401                                         R_FillColors(m.color, m.numverts, shirtcolor[0] * m.colorscale, shirtcolor[1] * m.colorscale, shirtcolor[2] * m.colorscale, ent->alpha);
 402                                 else
 403                                         R_ModulateColors(aliasvertcolor, m.color, m.numverts, shirtcolor[0] * m.colorscale, shirtcolor[1] * m.colorscale, shirtcolor[2] * m.colorscale);
 404                                 memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 405                                 memcpy(m.vertex, aliasvert, m.numverts * sizeof(float[4]));
 406                                 memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 407                                 R_Mesh_Render();
 408                         }
 409                 }
 410         }
 411         if (skinframe->glow)
 412         {
 413                 memset(&m, 0, sizeof(m));
 414                 m.blendfunc1 = GL_SRC_ALPHA;
 415                 m.blendfunc2 = GL_ONE;
 416                 m.numtriangles = model->numtris;
 417                 m.numverts = model->numverts;
 418                 m.tex[0] = R_GetTexture(skinframe->glow);
 419                 m.matrix = ent->matrix;
 420                 if (R_Mesh_Draw_GetBuffer(&m, true))
 421                 {
 422                         c_alias_polys += m.numtriangles;
 423                         R_FillColors(m.color, m.numverts, (1 - fog) * m.colorscale, (1 - fog) * m.colorscale, (1 - fog) * m.colorscale, ent->alpha);
 424                         memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 425                         memcpy(m.vertex, aliasvert, m.numverts * sizeof(float[4]));
 426                         memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 427                         R_Mesh_Render();
 428                 }
 429         }
 430         if (fog)
 431         {
 432                 memset(&m, 0, sizeof(m));
 433                 m.blendfunc1 = GL_SRC_ALPHA;
 434                 m.blendfunc2 = GL_ONE;
 435                 m.numtriangles = model->numtris;
 436                 m.numverts = model->numverts;
 437                 m.tex[0] = R_GetTexture(skinframe->fog);
 438                 m.matrix = ent->matrix;
 439                 if (R_Mesh_Draw_GetBuffer(&m, false))
 440                 {
 441                         c_alias_polys += m.numtriangles;
 442                         R_FillColors(m.color, m.numverts, fog * m.colorscale, fog * m.colorscale, fog * m.colorscale, ent->alpha);
 443                         memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 444                         memcpy(m.vertex, aliasvert, m.numverts * sizeof(float[4]));
 445                         memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 446                         R_Mesh_Render();
 447                 }
 448         }
 449 }
 450
 451 int ZymoticLerpBones(int count, const zymbonematrix *bonebase, const frameblend_t *blend, const zymbone_t *bone)
 452 {
 453         int i;
 454         float lerp1, lerp2, lerp3, lerp4;
 455         zymbonematrix *out, rootmatrix, m;
 456         const zymbonematrix *bone1, *bone2, *bone3, *bone4;
 457
 458         /*
 459         // LordHavoc: combine transform from zym coordinate space to quake coordinate space with model to world transform matrix
 460         rootmatrix.m[0][0] = softwaretransform_matrix[0][1];
 461         rootmatrix.m[0][1] = -softwaretransform_matrix[0][0];
 462         rootmatrix.m[0][2] = softwaretransform_matrix[0][2];
 463         rootmatrix.m[0][3] = softwaretransform_matrix[0][3];
 464         rootmatrix.m[1][0] = softwaretransform_matrix[1][1];
 465         rootmatrix.m[1][1] = -softwaretransform_matrix[1][0];
 466         rootmatrix.m[1][2] = softwaretransform_matrix[1][2];
 467         rootmatrix.m[1][3] = softwaretransform_matrix[1][3];
 468         rootmatrix.m[2][0] = softwaretransform_matrix[2][1];
 469         rootmatrix.m[2][1] = -softwaretransform_matrix[2][0];
 470         rootmatrix.m[2][2] = softwaretransform_matrix[2][2];
 471         rootmatrix.m[2][3] = softwaretransform_matrix[2][3];
 472         */
 473         rootmatrix.m[0][0] = 1;
 474         rootmatrix.m[0][1] = 0;
 475         rootmatrix.m[0][2] = 0;
 476         rootmatrix.m[0][3] = 0;
 477         rootmatrix.m[1][0] = 0;
 478         rootmatrix.m[1][1] = 1;
 479         rootmatrix.m[1][2] = 0;
 480         rootmatrix.m[1][3] = 0;
 481         rootmatrix.m[2][0] = 0;
 482         rootmatrix.m[2][1] = 0;
 483         rootmatrix.m[2][2] = 1;
 484         rootmatrix.m[2][3] = 0;
 485
 486         bone1 = bonebase + blend[0].frame * count;
 487         lerp1 = blend[0].lerp;
 488         if (blend[1].lerp)
 489         {
 490                 bone2 = bonebase + blend[1].frame * count;
 491                 lerp2 = blend[1].lerp;
 492                 if (blend[2].lerp)
 493                 {
 494                         bone3 = bonebase + blend[2].frame * count;
 495                         lerp3 = blend[2].lerp;
 496                         if (blend[3].lerp)
 497                         {
 498                                 // 4 poses
 499                                 bone4 = bonebase + blend[3].frame * count;
 500                                 lerp4 = blend[3].lerp;
 501                                 for (i = 0, out = zymbonepose;i < count;i++, out++)
 502                                 {
 503                                         // interpolate matrices
 504                                         m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2 + bone3->m[0][0] * lerp3 + bone4->m[0][0] * lerp4;
 505                                         m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2 + bone3->m[0][1] * lerp3 + bone4->m[0][1] * lerp4;
 506                                         m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2 + bone3->m[0][2] * lerp3 + bone4->m[0][2] * lerp4;
 507                                         m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2 + bone3->m[0][3] * lerp3 + bone4->m[0][3] * lerp4;
 508                                         m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2 + bone3->m[1][0] * lerp3 + bone4->m[1][0] * lerp4;
 509                                         m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2 + bone3->m[1][1] * lerp3 + bone4->m[1][1] * lerp4;
 510                                         m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2 + bone3->m[1][2] * lerp3 + bone4->m[1][2] * lerp4;
 511                                         m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2 + bone3->m[1][3] * lerp3 + bone4->m[1][3] * lerp4;
 512                                         m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2 + bone3->m[2][0] * lerp3 + bone4->m[2][0] * lerp4;
 513                                         m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2 + bone3->m[2][1] * lerp3 + bone4->m[2][1] * lerp4;
 514                                         m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2 + bone3->m[2][2] * lerp3 + bone4->m[2][2] * lerp4;
 515                                         m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2 + bone3->m[2][3] * lerp3 + bone4->m[2][3] * lerp4;
 516                                         if (bone->parent >= 0)
 517                                                 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
 518                                         else
 519                                                 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
 520                                         bone1++;
 521                                         bone2++;
 522                                         bone3++;
 523                                         bone4++;
 524                                         bone++;
 525                                 }
 526                         }
 527                         else
 528                         {
 529                                 // 3 poses
 530                                 for (i = 0, out = zymbonepose;i < count;i++, out++)
 531                                 {
 532                                         // interpolate matrices
 533                                         m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2 + bone3->m[0][0] * lerp3;
 534                                         m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2 + bone3->m[0][1] * lerp3;
 535                                         m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2 + bone3->m[0][2] * lerp3;
 536                                         m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2 + bone3->m[0][3] * lerp3;
 537                                         m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2 + bone3->m[1][0] * lerp3;
 538                                         m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2 + bone3->m[1][1] * lerp3;
 539                                         m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2 + bone3->m[1][2] * lerp3;
 540                                         m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2 + bone3->m[1][3] * lerp3;
 541                                         m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2 + bone3->m[2][0] * lerp3;
 542                                         m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2 + bone3->m[2][1] * lerp3;
 543                                         m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2 + bone3->m[2][2] * lerp3;
 544                                         m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2 + bone3->m[2][3] * lerp3;
 545                                         if (bone->parent >= 0)
 546                                                 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
 547                                         else
 548                                                 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
 549                                         bone1++;
 550                                         bone2++;
 551                                         bone3++;
 552                                         bone++;
 553                                 }
 554                         }
 555                 }
 556                 else
 557                 {
 558                         // 2 poses
 559                         for (i = 0, out = zymbonepose;i < count;i++, out++)
 560                         {
 561                                 // interpolate matrices
 562                                 m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2;
 563                                 m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2;
 564                                 m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2;
 565                                 m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2;
 566                                 m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2;
 567                                 m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2;
 568                                 m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2;
 569                                 m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2;
 570                                 m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2;
 571                                 m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2;
 572                                 m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2;
 573                                 m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2;
 574                                 if (bone->parent >= 0)
 575                                         R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
 576                                 else
 577                                         R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
 578                                 bone1++;
 579                                 bone2++;
 580                                 bone++;
 581                         }
 582                 }
 583         }
 584         else
 585         {
 586                 // 1 pose
 587                 if (lerp1 != 1)
 588                 {
 589                         // lerp != 1.0
 590                         for (i = 0, out = zymbonepose;i < count;i++, out++)
 591                         {
 592                                 // interpolate matrices
 593                                 m.m[0][0] = bone1->m[0][0] * lerp1;
 594                                 m.m[0][1] = bone1->m[0][1] * lerp1;
 595                                 m.m[0][2] = bone1->m[0][2] * lerp1;
 596                                 m.m[0][3] = bone1->m[0][3] * lerp1;
 597                                 m.m[1][0] = bone1->m[1][0] * lerp1;
 598                                 m.m[1][1] = bone1->m[1][1] * lerp1;
 599                                 m.m[1][2] = bone1->m[1][2] * lerp1;
 600                                 m.m[1][3] = bone1->m[1][3] * lerp1;
 601                                 m.m[2][0] = bone1->m[2][0] * lerp1;
 602                                 m.m[2][1] = bone1->m[2][1] * lerp1;
 603                                 m.m[2][2] = bone1->m[2][2] * lerp1;
 604                                 m.m[2][3] = bone1->m[2][3] * lerp1;
 605                                 if (bone->parent >= 0)
 606                                         R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
 607                                 else
 608                                         R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
 609                                 bone1++;
 610                                 bone++;
 611                         }
 612                 }
 613                 else
 614                 {
 615                         // lerp == 1.0
 616                         for (i = 0, out = zymbonepose;i < count;i++, out++)
 617                         {
 618                                 if (bone->parent >= 0)
 619                                         R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &bone1->m[0][0], &out->m[0][0]);
 620                                 else
 621                                         R_ConcatTransforms(&rootmatrix.m[0][0], &bone1->m[0][0], &out->m[0][0]);
 622                                 bone1++;
 623                                 bone++;
 624                         }
 625                 }
 626         }
 627         return true;
 628 }
 629
 630 void ZymoticTransformVerts(int vertcount, int *bonecounts, zymvertex_t *vert)
 631 {
 632         int c;
 633         float *out = aliasvert;
 634         zymbonematrix *matrix;
 635         while(vertcount--)
 636         {
 637                 c = *bonecounts++;
 638                 // FIXME: validate bonecounts at load time (must be >= 1)
 639                 // FIXME: need 4th component in origin, for how much of the translate to blend in
 640                 if (c == 1)
 641                 {
 642                         matrix = &zymbonepose[vert->bonenum];
 643                         out[0] = vert->origin[0] * matrix->m[0][0] + vert->origin[1] * matrix->m[0][1] + vert->origin[2] * matrix->m[0][2] + matrix->m[0][3];
 644                         out[1] = vert->origin[0] * matrix->m[1][0] + vert->origin[1] * matrix->m[1][1] + vert->origin[2] * matrix->m[1][2] + matrix->m[1][3];
 645                         out[2] = vert->origin[0] * matrix->m[2][0] + vert->origin[1] * matrix->m[2][1] + vert->origin[2] * matrix->m[2][2] + matrix->m[2][3];
 646                         vert++;
 647                 }
 648                 else
 649                 {
 650                         VectorClear(out);
 651                         while(c--)
 652                         {
 653                                 matrix = &zymbonepose[vert->bonenum];
 654                                 out[0] += vert->origin[0] * matrix->m[0][0] + vert->origin[1] * matrix->m[0][1] + vert->origin[2] * matrix->m[0][2] + matrix->m[0][3];
 655                                 out[1] += vert->origin[0] * matrix->m[1][0] + vert->origin[1] * matrix->m[1][1] + vert->origin[2] * matrix->m[1][2] + matrix->m[1][3];
 656                                 out[2] += vert->origin[0] * matrix->m[2][0] + vert->origin[1] * matrix->m[2][1] + vert->origin[2] * matrix->m[2][2] + matrix->m[2][3];
 657                                 vert++;
 658                         }
 659                 }
 660                 out += 4;
 661         }
 662 }
 663
 664 void ZymoticCalcNormals(int vertcount, int shadercount, int *renderlist)
 665 {
 666         int a, b, c, d;
 667         float *out, v1[3], v2[3], normal[3], s;
 668         int *u;
 669         // clear normals
 670         memset(aliasvertnorm, 0, sizeof(float) * vertcount * 3);
 671         memset(aliasvertusage, 0, sizeof(int) * vertcount);
 672         // parse render list and accumulate surface normals
 673         while(shadercount--)
 674         {
 675                 d = *renderlist++;
 676                 while (d--)
 677                 {
 678                         a = renderlist[0]*4;
 679                         b = renderlist[1]*4;
 680                         c = renderlist[2]*4;
 681                         v1[0] = aliasvert[a+0] - aliasvert[b+0];
 682                         v1[1] = aliasvert[a+1] - aliasvert[b+1];
 683                         v1[2] = aliasvert[a+2] - aliasvert[b+2];
 684                         v2[0] = aliasvert[c+0] - aliasvert[b+0];
 685                         v2[1] = aliasvert[c+1] - aliasvert[b+1];
 686                         v2[2] = aliasvert[c+2] - aliasvert[b+2];
 687                         CrossProduct(v1, v2, normal);
 688                         VectorNormalizeFast(normal);
 689                         // add surface normal to vertices
 690                         a = renderlist[0] * 3;
 691                         aliasvertnorm[a+0] += normal[0];
 692                         aliasvertnorm[a+1] += normal[1];
 693                         aliasvertnorm[a+2] += normal[2];
 694                         aliasvertusage[renderlist[0]]++;
 695                         a = renderlist[1] * 3;
 696                         aliasvertnorm[a+0] += normal[0];
 697                         aliasvertnorm[a+1] += normal[1];
 698                         aliasvertnorm[a+2] += normal[2];
 699                         aliasvertusage[renderlist[1]]++;
 700                         a = renderlist[2] * 3;
 701                         aliasvertnorm[a+0] += normal[0];
 702                         aliasvertnorm[a+1] += normal[1];
 703                         aliasvertnorm[a+2] += normal[2];
 704                         aliasvertusage[renderlist[2]]++;
 705                         renderlist += 3;
 706                 }
 707         }
 708         // FIXME: precalc this
 709         // average surface normals
 710         out = aliasvertnorm;
 711         u = aliasvertusage;
 712         while(vertcount--)
 713         {
 714                 if (*u > 1)
 715                 {
 716                         s = ixtable[*u];
 717                         out[0] *= s;
 718                         out[1] *= s;
 719                         out[2] *= s;
 720                 }
 721                 u++;
 722                 out += 3;
 723         }
 724 }
 725
 726 void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
 727 {
 728         float fog;
 729         vec3_t diff;
 730         int i, *renderlist;
 731         zymtype1header_t *m;
 732         rtexture_t *texture;
 733         rmeshbufferinfo_t mbuf;
 734         const entity_render_t *ent = calldata1;
 735         int shadernum = calldata2;
 736
 737         // find the vertex index list and texture
 738         m = ent->model->zymdata_header;
 739         renderlist = (int *)(m->lump_render.start + (int) m);
 740         for (i = 0;i < shadernum;i++)
 741                 renderlist += renderlist[0] * 3 + 1;
 742         texture = ((rtexture_t **)(m->lump_shaders.start + (int) m))[shadernum];
 743
 744         fog = 0;
 745         if (fogenabled)
 746         {
 747                 VectorSubtract(ent->origin, r_origin, diff);
 748                 fog = DotProduct(diff,diff);
 749                 if (fog < 0.01f)
 750                         fog = 0.01f;
 751                 fog = exp(fogdensity/fog);
 752                 if (fog > 1)
 753                         fog = 1;
 754                 if (fog < 0.01f)
 755                         fog = 0;
 756                 // fog method: darken, additive fog
 757                 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
 758                 // 2. render fog as additive
 759         }
 760
 761         ZymoticLerpBones(m->numbones, (zymbonematrix *)(m->lump_poses.start + (int) m), ent->frameblend, (zymbone_t *)(m->lump_bones.start + (int) m));
 762         ZymoticTransformVerts(m->numverts, (int *)(m->lump_vertbonecounts.start + (int) m), (zymvertex_t *)(m->lump_verts.start + (int) m));
 763         ZymoticCalcNormals(m->numverts, m->numshaders, (int *)(m->lump_render.start + (int) m));
 764
 765         R_LightModel(ent, m->numverts, 1 - fog, 1 - fog, 1 - fog, false);
 766
 767         memset(&mbuf, 0, sizeof(mbuf));
 768         mbuf.numverts = m->numverts;
 769         mbuf.numtriangles = renderlist[0];
 770         if (ent->effects & EF_ADDITIVE)
 771         {
 772                 mbuf.blendfunc1 = GL_SRC_ALPHA;
 773                 mbuf.blendfunc2 = GL_ONE;
 774         }
 775         else if (ent->alpha != 1.0 || R_TextureHasAlpha(texture))
 776         {
 777                 mbuf.blendfunc1 = GL_SRC_ALPHA;
 778                 mbuf.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
 779         }
 780         else
 781         {
 782                 mbuf.blendfunc1 = GL_ONE;
 783                 mbuf.blendfunc2 = GL_ZERO;
 784         }
 785         mbuf.tex[0] = R_GetTexture(texture);
 786         mbuf.matrix = ent->matrix;
 787         if (R_Mesh_Draw_GetBuffer(&mbuf, true))
 788         {
 789                 c_alias_polys += mbuf.numtriangles;
 790                 memcpy(mbuf.index, renderlist + 1, mbuf.numtriangles * sizeof(int[3]));
 791                 memcpy(mbuf.vertex, aliasvert, mbuf.numverts * sizeof(float[4]));
 792                 R_ModulateColors(aliasvertcolor, mbuf.color, mbuf.numverts, mbuf.colorscale, mbuf.colorscale, mbuf.colorscale);
 793                 //memcpy(mbuf.color, aliasvertcolor, mbuf.numverts * sizeof(float[4]));
 794                 memcpy(mbuf.texcoords[0], (float *)(m->lump_texcoords.start + (int) m), mbuf.numverts * sizeof(float[2]));
 795                 R_Mesh_Render();
 796         }
 797
 798         if (fog)
 799         {
 800                 memset(&mbuf, 0, sizeof(mbuf));
 801                 mbuf.numverts = m->numverts;
 802                 mbuf.numtriangles = renderlist[0];
 803                 mbuf.blendfunc1 = GL_SRC_ALPHA;
 804                 mbuf.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
 805                 // FIXME: need alpha mask for fogging...
 806                 //mbuf.tex[0] = R_GetTexture(texture);
 807                 mbuf.matrix = ent->matrix;
 808                 if (R_Mesh_Draw_GetBuffer(&mbuf, false))
 809                 {
 810                         c_alias_polys += mbuf.numtriangles;
 811                         memcpy(mbuf.index, renderlist + 1, mbuf.numtriangles * sizeof(int[3]));
 812                         memcpy(mbuf.vertex, aliasvert, mbuf.numverts * sizeof(float[4]));
 813                         R_FillColors(mbuf.color, mbuf.numverts, fogcolor[0] * mbuf.colorscale, fogcolor[1] * mbuf.colorscale, fogcolor[2] * mbuf.colorscale, ent->alpha * fog);
 814                         //memcpy(mbuf.texcoords[0], (float *)(m->lump_texcoords.start + (int) m), mbuf.numverts * sizeof(float[2]));
 815                         R_Mesh_Render();
 816                 }
 817         }
 818 }
 819
 820 void R_DrawZymoticModel (entity_render_t *ent)
 821 {
 822         int i;
 823         zymtype1header_t *m;
 824         rtexture_t *texture;
 825
 826         if (ent->alpha < (1.0f / 64.0f))
 827                 return; // basically completely transparent
 828
 829         c_models++;
 830
 831         m = ent->model->zymdata_header;
 832         for (i = 0;i < m->numshaders;i++)
 833         {
 834                 texture = ((rtexture_t **)(m->lump_shaders.start + (int) m))[i];
 835                 if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_TextureHasAlpha(texture))
 836                         R_MeshQueue_AddTransparent(ent->origin, R_DrawZymoticModelMeshCallback, ent, i);
 837                 else
 838                         R_MeshQueue_Add(R_DrawZymoticModelMeshCallback, ent, i);
 839         }
 840 }
 841
 842 void R_DrawQ1Q2AliasModel(entity_render_t *ent)
 843 {
 844         if (ent->alpha < (1.0f / 64.0f))
 845                 return; // basically completely transparent
 846
 847         c_models++;
 848
 849         if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_FetchSkinFrame(ent)->fog != NULL)
 850                 R_MeshQueue_AddTransparent(ent->origin, R_DrawQ1Q2AliasModelCallback, ent, 0);
 851         else
 852                 R_MeshQueue_Add(R_DrawQ1Q2AliasModelCallback, ent, 0);
 853 }
 854