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         int blendfunc1, blendfunc2;
 249
 250 //      softwaretransformforentity(ent);
 251
 252         fog = 0;
 253         if (fogenabled)
 254         {
 255                 VectorSubtract(ent->origin, r_origin, diff);
 256                 fog = DotProduct(diff,diff);
 257                 if (fog < 0.01f)
 258                         fog = 0.01f;
 259                 fog = exp(fogdensity/fog);
 260                 if (fog > 1)
 261                         fog = 1;
 262                 if (fog < 0.01f)
 263                         fog = 0;
 264                 // fog method: darken, additive fog
 265                 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
 266                 // 2. render fog as additive
 267         }
 268
 269         model = ent->model;
 270
 271         skinframe = R_FetchSkinFrame(ent);
 272
 273         colormapped = !skinframe->merged || (ent->colormap >= 0 && skinframe->base && (skinframe->pants || skinframe->shirt));
 274         if (!colormapped && !fog && !skinframe->glow && !skinframe->fog)
 275         {
 276                 // fastpath for the normal situation (one texture)
 277                 memset(&m, 0, sizeof(m));
 278                 if (ent->effects & EF_ADDITIVE)
 279                 {
 280                         m.blendfunc1 = GL_SRC_ALPHA;
 281                         m.blendfunc2 = GL_ONE;
 282                 }
 283                 else if (ent->alpha != 1.0 || skinframe->fog != NULL)
 284                 {
 285                         m.blendfunc1 = GL_SRC_ALPHA;
 286                         m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
 287                 }
 288                 else
 289                 {
 290                         m.blendfunc1 = GL_ONE;
 291                         m.blendfunc2 = GL_ZERO;
 292                 }
 293                 m.numtriangles = model->numtris;
 294                 m.numverts = model->numverts;
 295                 m.tex[0] = R_GetTexture(skinframe->merged);
 296                 m.matrix = ent->matrix;
 297
 298                 c_alias_polys += m.numtriangles;
 299                 if (R_Mesh_Draw_GetBuffer(&m, true))
 300                 {
 301                         memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 302                         memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 303
 304                         aliasvert = m.vertex;
 305                         aliasvertcolor = m.color;
 306                         R_SetupMDLMD2Frames(ent, m.colorscale, m.colorscale, m.colorscale);
 307                         aliasvert = aliasvertbuf;
 308                         aliasvertcolor = aliasvertcolorbuf;
 309
 310                         R_Mesh_Render();
 311                 }
 312                 return;
 313         }
 314
 315         R_SetupMDLMD2Frames(ent, 1 - fog, 1 - fog, 1 - fog);
 316
 317         if (colormapped)
 318         {
 319                 // 128-224 are backwards ranges
 320                 c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
 321                 bcolor = (qbyte *) (&d_8to24table[c]);
 322                 pantsfullbright = c >= 224;
 323                 VectorScale(bcolor, (1.0f / 255.0f), pantscolor);
 324                 c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
 325                 bcolor = (qbyte *) (&d_8to24table[c]);
 326                 shirtfullbright = c >= 224;
 327                 VectorScale(bcolor, (1.0f / 255.0f), shirtcolor);
 328         }
 329         else
 330         {
 331                 pantscolor[0] = pantscolor[1] = pantscolor[2] = shirtcolor[0] = shirtcolor[1] = shirtcolor[2] = 1;
 332                 pantsfullbright = shirtfullbright = false;
 333         }
 334
 335         if (ent->effects & EF_ADDITIVE)
 336         {
 337                 blendfunc1 = GL_SRC_ALPHA;
 338                 blendfunc2 = GL_ONE;
 339         }
 340         else if (ent->alpha != 1.0 || skinframe->fog != NULL)
 341         {
 342                 blendfunc1 = GL_SRC_ALPHA;
 343                 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
 344         }
 345         else
 346         {
 347                 blendfunc1 = GL_ONE;
 348                 blendfunc2 = GL_ZERO;
 349         }
 350
 351         memset(&m, 0, sizeof(m));
 352         m.blendfunc1 = blendfunc1;
 353         m.blendfunc2 = blendfunc2;
 354         m.numtriangles = model->numtris;
 355         m.numverts = model->numverts;
 356         m.matrix = ent->matrix;
 357         m.tex[0] = colormapped ? R_GetTexture(skinframe->base) : R_GetTexture(skinframe->merged);
 358         if (m.tex[0] && R_Mesh_Draw_GetBuffer(&m, true))
 359         {
 360                 blendfunc1 = GL_SRC_ALPHA;
 361                 blendfunc2 = GL_ONE;
 362                 c_alias_polys += m.numtriangles;
 363                 R_ModulateColors(aliasvertcolor, m.color, m.numverts, m.colorscale, m.colorscale, m.colorscale);
 364                 memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 365                 memcpy(m.vertex, aliasvert, m.numverts * sizeof(float[4]));
 366                 memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 367                 R_Mesh_Render();
 368         }
 369
 370         if (colormapped)
 371         {
 372                 if (skinframe->pants)
 373                 {
 374                         memset(&m, 0, sizeof(m));
 375                         m.blendfunc1 = blendfunc1;
 376                         m.blendfunc2 = blendfunc2;
 377                         m.numtriangles = model->numtris;
 378                         m.numverts = model->numverts;
 379                         m.matrix = ent->matrix;
 380                         m.tex[0] = R_GetTexture(skinframe->pants);
 381                         if (m.tex[0] && R_Mesh_Draw_GetBuffer(&m, true))
 382                         {
 383                                 blendfunc1 = GL_SRC_ALPHA;
 384                                 blendfunc2 = GL_ONE;
 385                                 c_alias_polys += m.numtriangles;
 386                                 if (pantsfullbright)
 387                                         R_FillColors(m.color, m.numverts, pantscolor[0] * m.colorscale, pantscolor[1] * m.colorscale, pantscolor[2] * m.colorscale, ent->alpha);
 388                                 else
 389                                         R_ModulateColors(aliasvertcolor, m.color, m.numverts, pantscolor[0] * m.colorscale, pantscolor[1] * m.colorscale, pantscolor[2] * m.colorscale);
 390                                 memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 391                                 memcpy(m.vertex, aliasvert, m.numverts * sizeof(float[4]));
 392                                 memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 393                                 R_Mesh_Render();
 394                         }
 395                 }
 396                 if (skinframe->shirt)
 397                 {
 398                         memset(&m, 0, sizeof(m));
 399                         m.blendfunc1 = blendfunc1;
 400                         m.blendfunc2 = blendfunc2;
 401                         m.numtriangles = model->numtris;
 402                         m.numverts = model->numverts;
 403                         m.matrix = ent->matrix;
 404                         m.tex[0] = R_GetTexture(skinframe->shirt);
 405                         if (m.tex[0] && R_Mesh_Draw_GetBuffer(&m, true))
 406                         {
 407                                 blendfunc1 = GL_SRC_ALPHA;
 408                                 blendfunc2 = GL_ONE;
 409                                 c_alias_polys += m.numtriangles;
 410                                 if (shirtfullbright)
 411                                         R_FillColors(m.color, m.numverts, shirtcolor[0] * m.colorscale, shirtcolor[1] * m.colorscale, shirtcolor[2] * m.colorscale, ent->alpha);
 412                                 else
 413                                         R_ModulateColors(aliasvertcolor, m.color, m.numverts, shirtcolor[0] * m.colorscale, shirtcolor[1] * m.colorscale, shirtcolor[2] * m.colorscale);
 414                                 memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 415                                 memcpy(m.vertex, aliasvert, m.numverts * sizeof(float[4]));
 416                                 memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 417                                 R_Mesh_Render();
 418                         }
 419                 }
 420         }
 421         if (skinframe->glow)
 422         {
 423                 memset(&m, 0, sizeof(m));
 424                 m.blendfunc1 = blendfunc1;
 425                 m.blendfunc2 = blendfunc2;
 426                 m.numtriangles = model->numtris;
 427                 m.numverts = model->numverts;
 428                 m.matrix = ent->matrix;
 429                 m.tex[0] = R_GetTexture(skinframe->glow);
 430                 if (m.tex[0] && R_Mesh_Draw_GetBuffer(&m, true))
 431                 {
 432                         blendfunc1 = GL_SRC_ALPHA;
 433                         blendfunc2 = GL_ONE;
 434                         c_alias_polys += m.numtriangles;
 435                         R_FillColors(m.color, m.numverts, (1 - fog) * m.colorscale, (1 - fog) * m.colorscale, (1 - fog) * m.colorscale, ent->alpha);
 436                         memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 437                         memcpy(m.vertex, aliasvert, m.numverts * sizeof(float[4]));
 438                         memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 439                         R_Mesh_Render();
 440                 }
 441         }
 442         if (fog)
 443         {
 444                 memset(&m, 0, sizeof(m));
 445                 m.blendfunc1 = GL_SRC_ALPHA;
 446                 m.blendfunc2 = GL_ONE;
 447                 m.numtriangles = model->numtris;
 448                 m.numverts = model->numverts;
 449                 m.matrix = ent->matrix;
 450                 m.tex[0] = R_GetTexture(skinframe->fog);
 451                 if (m.tex[0] && R_Mesh_Draw_GetBuffer(&m, true))
 452                 {
 453                         c_alias_polys += m.numtriangles;
 454                         R_FillColors(m.color, m.numverts, fogcolor[0] * fog * m.colorscale, fogcolor[1] * fog * m.colorscale, fogcolor[2] * fog * m.colorscale, ent->alpha);
 455                         memcpy(m.index, model->mdlmd2data_indices, m.numtriangles * sizeof(int[3]));
 456                         memcpy(m.vertex, aliasvert, m.numverts * sizeof(float[4]));
 457                         memcpy(m.texcoords[0], model->mdlmd2data_texcoords, m.numverts * sizeof(float[2]));
 458                         R_Mesh_Render();
 459                 }
 460         }
 461 }
 462
 463 int ZymoticLerpBones(int count, const zymbonematrix *bonebase, const frameblend_t *blend, const zymbone_t *bone)
 464 {
 465         int i;
 466         float lerp1, lerp2, lerp3, lerp4;
 467         zymbonematrix *out, rootmatrix, m;
 468         const zymbonematrix *bone1, *bone2, *bone3, *bone4;
 469
 470         /*
 471         // LordHavoc: combine transform from zym coordinate space to quake coordinate space with model to world transform matrix
 472         rootmatrix.m[0][0] = softwaretransform_matrix[0][1];
 473         rootmatrix.m[0][1] = -softwaretransform_matrix[0][0];
 474         rootmatrix.m[0][2] = softwaretransform_matrix[0][2];
 475         rootmatrix.m[0][3] = softwaretransform_matrix[0][3];
 476         rootmatrix.m[1][0] = softwaretransform_matrix[1][1];
 477         rootmatrix.m[1][1] = -softwaretransform_matrix[1][0];
 478         rootmatrix.m[1][2] = softwaretransform_matrix[1][2];
 479         rootmatrix.m[1][3] = softwaretransform_matrix[1][3];
 480         rootmatrix.m[2][0] = softwaretransform_matrix[2][1];
 481         rootmatrix.m[2][1] = -softwaretransform_matrix[2][0];
 482         rootmatrix.m[2][2] = softwaretransform_matrix[2][2];
 483         rootmatrix.m[2][3] = softwaretransform_matrix[2][3];
 484         */
 485         rootmatrix.m[0][0] = 1;
 486         rootmatrix.m[0][1] = 0;
 487         rootmatrix.m[0][2] = 0;
 488         rootmatrix.m[0][3] = 0;
 489         rootmatrix.m[1][0] = 0;
 490         rootmatrix.m[1][1] = 1;
 491         rootmatrix.m[1][2] = 0;
 492         rootmatrix.m[1][3] = 0;
 493         rootmatrix.m[2][0] = 0;
 494         rootmatrix.m[2][1] = 0;
 495         rootmatrix.m[2][2] = 1;
 496         rootmatrix.m[2][3] = 0;
 497
 498         bone1 = bonebase + blend[0].frame * count;
 499         lerp1 = blend[0].lerp;
 500         if (blend[1].lerp)
 501         {
 502                 bone2 = bonebase + blend[1].frame * count;
 503                 lerp2 = blend[1].lerp;
 504                 if (blend[2].lerp)
 505                 {
 506                         bone3 = bonebase + blend[2].frame * count;
 507                         lerp3 = blend[2].lerp;
 508                         if (blend[3].lerp)
 509                         {
 510                                 // 4 poses
 511                                 bone4 = bonebase + blend[3].frame * count;
 512                                 lerp4 = blend[3].lerp;
 513                                 for (i = 0, out = zymbonepose;i < count;i++, out++)
 514                                 {
 515                                         // interpolate matrices
 516                                         m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2 + bone3->m[0][0] * lerp3 + bone4->m[0][0] * lerp4;
 517                                         m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2 + bone3->m[0][1] * lerp3 + bone4->m[0][1] * lerp4;
 518                                         m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2 + bone3->m[0][2] * lerp3 + bone4->m[0][2] * lerp4;
 519                                         m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2 + bone3->m[0][3] * lerp3 + bone4->m[0][3] * lerp4;
 520                                         m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2 + bone3->m[1][0] * lerp3 + bone4->m[1][0] * lerp4;
 521                                         m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2 + bone3->m[1][1] * lerp3 + bone4->m[1][1] * lerp4;
 522                                         m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2 + bone3->m[1][2] * lerp3 + bone4->m[1][2] * lerp4;
 523                                         m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2 + bone3->m[1][3] * lerp3 + bone4->m[1][3] * lerp4;
 524                                         m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2 + bone3->m[2][0] * lerp3 + bone4->m[2][0] * lerp4;
 525                                         m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2 + bone3->m[2][1] * lerp3 + bone4->m[2][1] * lerp4;
 526                                         m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2 + bone3->m[2][2] * lerp3 + bone4->m[2][2] * lerp4;
 527                                         m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2 + bone3->m[2][3] * lerp3 + bone4->m[2][3] * lerp4;
 528                                         if (bone->parent >= 0)
 529                                                 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
 530                                         else
 531                                                 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
 532                                         bone1++;
 533                                         bone2++;
 534                                         bone3++;
 535                                         bone4++;
 536                                         bone++;
 537                                 }
 538                         }
 539                         else
 540                         {
 541                                 // 3 poses
 542                                 for (i = 0, out = zymbonepose;i < count;i++, out++)
 543                                 {
 544                                         // interpolate matrices
 545                                         m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2 + bone3->m[0][0] * lerp3;
 546                                         m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2 + bone3->m[0][1] * lerp3;
 547                                         m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2 + bone3->m[0][2] * lerp3;
 548                                         m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2 + bone3->m[0][3] * lerp3;
 549                                         m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2 + bone3->m[1][0] * lerp3;
 550                                         m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2 + bone3->m[1][1] * lerp3;
 551                                         m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2 + bone3->m[1][2] * lerp3;
 552                                         m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2 + bone3->m[1][3] * lerp3;
 553                                         m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2 + bone3->m[2][0] * lerp3;
 554                                         m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2 + bone3->m[2][1] * lerp3;
 555                                         m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2 + bone3->m[2][2] * lerp3;
 556                                         m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2 + bone3->m[2][3] * lerp3;
 557                                         if (bone->parent >= 0)
 558                                                 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
 559                                         else
 560                                                 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
 561                                         bone1++;
 562                                         bone2++;
 563                                         bone3++;
 564                                         bone++;
 565                                 }
 566                         }
 567                 }
 568                 else
 569                 {
 570                         // 2 poses
 571                         for (i = 0, out = zymbonepose;i < count;i++, out++)
 572                         {
 573                                 // interpolate matrices
 574                                 m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2;
 575                                 m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2;
 576                                 m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2;
 577                                 m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2;
 578                                 m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2;
 579                                 m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2;
 580                                 m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2;
 581                                 m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2;
 582                                 m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2;
 583                                 m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2;
 584                                 m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2;
 585                                 m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2;
 586                                 if (bone->parent >= 0)
 587                                         R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
 588                                 else
 589                                         R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
 590                                 bone1++;
 591                                 bone2++;
 592                                 bone++;
 593                         }
 594                 }
 595         }
 596         else
 597         {
 598                 // 1 pose
 599                 if (lerp1 != 1)
 600                 {
 601                         // lerp != 1.0
 602                         for (i = 0, out = zymbonepose;i < count;i++, out++)
 603                         {
 604                                 // interpolate matrices
 605                                 m.m[0][0] = bone1->m[0][0] * lerp1;
 606                                 m.m[0][1] = bone1->m[0][1] * lerp1;
 607                                 m.m[0][2] = bone1->m[0][2] * lerp1;
 608                                 m.m[0][3] = bone1->m[0][3] * lerp1;
 609                                 m.m[1][0] = bone1->m[1][0] * lerp1;
 610                                 m.m[1][1] = bone1->m[1][1] * lerp1;
 611                                 m.m[1][2] = bone1->m[1][2] * lerp1;
 612                                 m.m[1][3] = bone1->m[1][3] * lerp1;
 613                                 m.m[2][0] = bone1->m[2][0] * lerp1;
 614                                 m.m[2][1] = bone1->m[2][1] * lerp1;
 615                                 m.m[2][2] = bone1->m[2][2] * lerp1;
 616                                 m.m[2][3] = bone1->m[2][3] * lerp1;
 617                                 if (bone->parent >= 0)
 618                                         R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
 619                                 else
 620                                         R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
 621                                 bone1++;
 622                                 bone++;
 623                         }
 624                 }
 625                 else
 626                 {
 627                         // lerp == 1.0
 628                         for (i = 0, out = zymbonepose;i < count;i++, out++)
 629                         {
 630                                 if (bone->parent >= 0)
 631                                         R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &bone1->m[0][0], &out->m[0][0]);
 632                                 else
 633                                         R_ConcatTransforms(&rootmatrix.m[0][0], &bone1->m[0][0], &out->m[0][0]);
 634                                 bone1++;
 635                                 bone++;
 636                         }
 637                 }
 638         }
 639         return true;
 640 }
 641
 642 void ZymoticTransformVerts(int vertcount, int *bonecounts, zymvertex_t *vert)
 643 {
 644         int c;
 645         float *out = aliasvert;
 646         zymbonematrix *matrix;
 647         while(vertcount--)
 648         {
 649                 c = *bonecounts++;
 650                 // FIXME: validate bonecounts at load time (must be >= 1)
 651                 // FIXME: need 4th component in origin, for how much of the translate to blend in
 652                 if (c == 1)
 653                 {
 654                         matrix = &zymbonepose[vert->bonenum];
 655                         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];
 656                         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];
 657                         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];
 658                         vert++;
 659                 }
 660                 else
 661                 {
 662                         VectorClear(out);
 663                         while(c--)
 664                         {
 665                                 matrix = &zymbonepose[vert->bonenum];
 666                                 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];
 667                                 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];
 668                                 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];
 669                                 vert++;
 670                         }
 671                 }
 672                 out += 4;
 673         }
 674 }
 675
 676 void ZymoticCalcNormals(int vertcount, int shadercount, int *renderlist)
 677 {
 678         int a, b, c, d;
 679         float *out, v1[3], v2[3], normal[3], s;
 680         int *u;
 681         // clear normals
 682         memset(aliasvertnorm, 0, sizeof(float) * vertcount * 3);
 683         memset(aliasvertusage, 0, sizeof(int) * vertcount);
 684         // parse render list and accumulate surface normals
 685         while(shadercount--)
 686         {
 687                 d = *renderlist++;
 688                 while (d--)
 689                 {
 690                         a = renderlist[0]*4;
 691                         b = renderlist[1]*4;
 692                         c = renderlist[2]*4;
 693                         v1[0] = aliasvert[a+0] - aliasvert[b+0];
 694                         v1[1] = aliasvert[a+1] - aliasvert[b+1];
 695                         v1[2] = aliasvert[a+2] - aliasvert[b+2];
 696                         v2[0] = aliasvert[c+0] - aliasvert[b+0];
 697                         v2[1] = aliasvert[c+1] - aliasvert[b+1];
 698                         v2[2] = aliasvert[c+2] - aliasvert[b+2];
 699                         CrossProduct(v1, v2, normal);
 700                         VectorNormalizeFast(normal);
 701                         // add surface normal to vertices
 702                         a = renderlist[0] * 3;
 703                         aliasvertnorm[a+0] += normal[0];
 704                         aliasvertnorm[a+1] += normal[1];
 705                         aliasvertnorm[a+2] += normal[2];
 706                         aliasvertusage[renderlist[0]]++;
 707                         a = renderlist[1] * 3;
 708                         aliasvertnorm[a+0] += normal[0];
 709                         aliasvertnorm[a+1] += normal[1];
 710                         aliasvertnorm[a+2] += normal[2];
 711                         aliasvertusage[renderlist[1]]++;
 712                         a = renderlist[2] * 3;
 713                         aliasvertnorm[a+0] += normal[0];
 714                         aliasvertnorm[a+1] += normal[1];
 715                         aliasvertnorm[a+2] += normal[2];
 716                         aliasvertusage[renderlist[2]]++;
 717                         renderlist += 3;
 718                 }
 719         }
 720         // FIXME: precalc this
 721         // average surface normals
 722         out = aliasvertnorm;
 723         u = aliasvertusage;
 724         while(vertcount--)
 725         {
 726                 if (*u > 1)
 727                 {
 728                         s = ixtable[*u];
 729                         out[0] *= s;
 730                         out[1] *= s;
 731                         out[2] *= s;
 732                 }
 733                 u++;
 734                 out += 3;
 735         }
 736 }
 737
 738 void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
 739 {
 740         float fog;
 741         vec3_t diff;
 742         int i, *renderlist;
 743         zymtype1header_t *m;
 744         rtexture_t *texture;
 745         rmeshbufferinfo_t mbuf;
 746         const entity_render_t *ent = calldata1;
 747         int shadernum = calldata2;
 748
 749         // find the vertex index list and texture
 750         m = ent->model->zymdata_header;
 751         renderlist = (int *)(m->lump_render.start + (int) m);
 752         for (i = 0;i < shadernum;i++)
 753                 renderlist += renderlist[0] * 3 + 1;
 754         texture = ((rtexture_t **)(m->lump_shaders.start + (int) m))[shadernum];
 755
 756         fog = 0;
 757         if (fogenabled)
 758         {
 759                 VectorSubtract(ent->origin, r_origin, diff);
 760                 fog = DotProduct(diff,diff);
 761                 if (fog < 0.01f)
 762                         fog = 0.01f;
 763                 fog = exp(fogdensity/fog);
 764                 if (fog > 1)
 765                         fog = 1;
 766                 if (fog < 0.01f)
 767                         fog = 0;
 768                 // fog method: darken, additive fog
 769                 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
 770                 // 2. render fog as additive
 771         }
 772
 773         ZymoticLerpBones(m->numbones, (zymbonematrix *)(m->lump_poses.start + (int) m), ent->frameblend, (zymbone_t *)(m->lump_bones.start + (int) m));
 774         ZymoticTransformVerts(m->numverts, (int *)(m->lump_vertbonecounts.start + (int) m), (zymvertex_t *)(m->lump_verts.start + (int) m));
 775         ZymoticCalcNormals(m->numverts, m->numshaders, (int *)(m->lump_render.start + (int) m));
 776
 777         R_LightModel(ent, m->numverts, 1 - fog, 1 - fog, 1 - fog, false);
 778
 779         memset(&mbuf, 0, sizeof(mbuf));
 780         mbuf.numverts = m->numverts;
 781         mbuf.numtriangles = renderlist[0];
 782         if (ent->effects & EF_ADDITIVE)
 783         {
 784                 mbuf.blendfunc1 = GL_SRC_ALPHA;
 785                 mbuf.blendfunc2 = GL_ONE;
 786         }
 787         else if (ent->alpha != 1.0 || R_TextureHasAlpha(texture))
 788         {
 789                 mbuf.blendfunc1 = GL_SRC_ALPHA;
 790                 mbuf.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
 791         }
 792         else
 793         {
 794                 mbuf.blendfunc1 = GL_ONE;
 795                 mbuf.blendfunc2 = GL_ZERO;
 796         }
 797         mbuf.tex[0] = R_GetTexture(texture);
 798         mbuf.matrix = ent->matrix;
 799         if (R_Mesh_Draw_GetBuffer(&mbuf, true))
 800         {
 801                 c_alias_polys += mbuf.numtriangles;
 802                 memcpy(mbuf.index, renderlist + 1, mbuf.numtriangles * sizeof(int[3]));
 803                 memcpy(mbuf.vertex, aliasvert, mbuf.numverts * sizeof(float[4]));
 804                 R_ModulateColors(aliasvertcolor, mbuf.color, mbuf.numverts, mbuf.colorscale, mbuf.colorscale, mbuf.colorscale);
 805                 //memcpy(mbuf.color, aliasvertcolor, mbuf.numverts * sizeof(float[4]));
 806                 memcpy(mbuf.texcoords[0], (float *)(m->lump_texcoords.start + (int) m), mbuf.numverts * sizeof(float[2]));
 807                 R_Mesh_Render();
 808         }
 809
 810         if (fog)
 811         {
 812                 memset(&mbuf, 0, sizeof(mbuf));
 813                 mbuf.numverts = m->numverts;
 814                 mbuf.numtriangles = renderlist[0];
 815                 mbuf.blendfunc1 = GL_SRC_ALPHA;
 816                 mbuf.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
 817                 // FIXME: need alpha mask for fogging...
 818                 //mbuf.tex[0] = R_GetTexture(texture);
 819                 mbuf.matrix = ent->matrix;
 820                 if (R_Mesh_Draw_GetBuffer(&mbuf, false))
 821                 {
 822                         c_alias_polys += mbuf.numtriangles;
 823                         memcpy(mbuf.index, renderlist + 1, mbuf.numtriangles * sizeof(int[3]));
 824                         memcpy(mbuf.vertex, aliasvert, mbuf.numverts * sizeof(float[4]));
 825                         R_FillColors(mbuf.color, mbuf.numverts, fogcolor[0] * mbuf.colorscale, fogcolor[1] * mbuf.colorscale, fogcolor[2] * mbuf.colorscale, ent->alpha * fog);
 826                         //memcpy(mbuf.texcoords[0], (float *)(m->lump_texcoords.start + (int) m), mbuf.numverts * sizeof(float[2]));
 827                         R_Mesh_Render();
 828                 }
 829         }
 830 }
 831
 832 void R_DrawZymoticModel (entity_render_t *ent)
 833 {
 834         int i;
 835         zymtype1header_t *m;
 836         rtexture_t *texture;
 837
 838         if (ent->alpha < (1.0f / 64.0f))
 839                 return; // basically completely transparent
 840
 841         c_models++;
 842
 843         m = ent->model->zymdata_header;
 844         for (i = 0;i < m->numshaders;i++)
 845         {
 846                 texture = ((rtexture_t **)(m->lump_shaders.start + (int) m))[i];
 847                 if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_TextureHasAlpha(texture))
 848                         R_MeshQueue_AddTransparent(ent->origin, R_DrawZymoticModelMeshCallback, ent, i);
 849                 else
 850                         R_MeshQueue_Add(R_DrawZymoticModelMeshCallback, ent, i);
 851         }
 852 }
 853
 854 void R_DrawQ1Q2AliasModel(entity_render_t *ent)
 855 {
 856         if (ent->alpha < (1.0f / 64.0f))
 857                 return; // basically completely transparent
 858
 859         c_models++;
 860
 861         if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_FetchSkinFrame(ent)->fog != NULL)
 862                 R_MeshQueue_AddTransparent(ent->origin, R_DrawQ1Q2AliasModelCallback, ent, 0);
 863         else
 864                 R_MeshQueue_Add(R_DrawQ1Q2AliasModelCallback, ent, 0);
 865 }
 866