mystical.unicat/monorepo - Change RLQCP6HZ5VXDNVJCYA3EXDWFFPUGYZRKGAKY7TZS4QGA5ZL4OPBAC

A lot of fixes for Quake2. Can have shaders without some extensions now. known bugs: mouse input not grabbed, not reading lightmap for entities, particles are broken.

Created by GPeTJGuaAryfKVDHpJLoiRAiv9jDq5aAapfNcWjYu16v on September 21, 2023

RLQCP6HZ5VXDNVJCYA3EXDWFFPUGYZRKGAKY7TZS4QGA5ZL4OPBAC

Dependencies

[2] 7KS22PCEQW4NFNBIGVRIPLZ4VZL4W7WPNPGA7B23CYUIXZB37IBQC

In channels

main

Change contents

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 10 [2.1128210]

[2.1128450]

#define THIN_GL_SNIPPET_FLAGS_require(NAME)
#define THIN_GL_SNIPPET_FLAGS_flag(NAME) | THIN_GL_SHADER_FLAG_ ## NAME
#define THIN_GL_SNIPPET_FLAGS_code(CODE)
#define THIN_GL_SNIPPET_FLAGS_string(CODE)
#define THIN_GL_SNIPPET_FLAGS_(ITEM) ALIAS_CPP_CAT(THIN_GL_SNIPPET_FLAGS_, ITEM)

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 17 [2.1128210]
[2.1128518]
[2.1128518]
```
#define THIN_GL_SNIPPET_REQUIRE_flag(NAME)
```
Insertion in quake2/ref_gl/gl_thin_cpp.h at line 23 [2.1128210]
[2.1128735]
[2.1128735]
```
#define THIN_GL_SNIPPET_CODE_flag(NAME)
```

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 32 [2.1128210]

[2.1129246]

      .flags = 0 ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_SNIPPET_FLAGS_, __VA_ARGS__)),                                   \

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 39 [2.1128210]

[2.1129646]

#define THIN_GL_SHADER_FLAGS_require(NAME)
#define THIN_GL_SHADER_FLAGS_flag(NAME) | THIN_GL_SHADER_FLAG_ ## NAME
#define THIN_GL_SHADER_FLAGS_code(CODE)
#define THIN_GL_SHADER_FLAGS_string(CODE)
#define THIN_GL_SHADER_FLAGS_main(CODE)
#define THIN_GL_SHADER_FLAGS_(ITEM) ALIAS_CPP_CAT(THIN_GL_SHADER_FLAGS_, ITEM)

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 47 [2.1128210]
[2.1129713]
[2.1129713]
```
#define THIN_GL_SHADER_REQUIRE_flag(NAME) 
```
Insertion in quake2/ref_gl/gl_thin_cpp.h at line 54 [2.1128210]
[2.1129967]
[2.1129967]
```
#define THIN_GL_SHADER_CODE_flag(NAME)
```

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 62 [2.1128210]

[2.1130443]

      .flags = 0 ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_SHADER_FLAGS_, __VA_ARGS__)),                                    \

Replacement in quake2/ref_gl/gl_thin_cpp.h at line 207 [2.1128210]
B:BD[2.1142215] → [2.1142215:1142235]
```
// clang-format onX
```
[2.1142215]
[2.1142235]
```
// clang-format on
```
Replacement in quake2/ref_gl/gl_thin_cpp.h at line 292 [2.1128210]
B:BD[2.1147557] → [2.1147557:1147563]
```
#endif
```
[2.1147557]
```
#endif
```

Insertion in quake2/ref_gl/gl_thin.h at line 23 [2.1147603]

[2.1148120]


#define THIN_GL_SHADER_FLAG_SUBGROUP_ARITHMETIC 0x00000001
#define THIN_GL_SHADER_FLAG_ARITHMETIC_INT64    0x00000002

Insertion in quake2/ref_gl/gl_thin.h at line 169 [2.1147603]
[2.1151510]
[2.1151510]
```
  uint32_t flags;
```
Insertion in quake2/ref_gl/gl_thin.h at line 180 [2.1147603]
[2.1151665]
[2.1151665]
```
  uint32_t flags;
```

Deletion in quake2/ref_gl/gl_thin.c at line 13 [2.1166326]

B:BD[2.1166807] → [2.1166807:1167102]

const char shader_prelude[] = "#version 460 core\n"
                              "#extension GL_KHR_shader_subgroup_arithmetic : enable\n"
                              "#extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable\n"
                              "#define _Bool bool\n";

Insertion in quake2/ref_gl/gl_thin.c at line 121 [2.1166326]

[2.1170136]

  }
}
static uint32_t script_builder_collect_flags(const struct GL_ShaderSnippet *shader) {
  uint32_t flags = shader->flags;
  for(uint32_t i = 0; i < 8; i++) {
    if(shader->requires[i] == NULL)
      break;
    flags |= script_builder_collect_flags(shader->requires[i]);
  }
  return flags;
}
static void script_builder_add_prelude(const struct GL_ShaderSnippet *shader) {
  uint32_t flags = script_builder_collect_flags(shader);
  script_builder_add("#version 460 core\n");
  if(flags & THIN_GL_SHADER_FLAG_SUBGROUP_ARITHMETIC) {
    script_builder_add("#extension GL_KHR_shader_subgroup_arithmetic : enable\n");
  }
  if(flags & THIN_GL_SHADER_FLAG_ARITHMETIC_INT64) {
    script_builder_add("#extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable\n");

Insertion in quake2/ref_gl/gl_thin.c at line 143 [2.1166326]
[2.1170140]
[2.1170140]
```
  script_builder_add("#define _Bool bool\n");
```

Replacement in quake2/ref_gl/gl_thin.c at line 323 [2.1166326]

B:BD[2.1176333] → [2.1176333:1176379]

    script_builder_add("%s", shader_prelude);

[2.1176333]

[2.1176379]

    script_builder_add_prelude((const struct GL_ShaderSnippet *)state->vertex_shader);

Replacement in quake2/ref_gl/gl_thin.c at line 339 [2.1166326]

B:BD[2.1177125] → [2.1177125:1177171]

    script_builder_add("%s", shader_prelude);

[2.1177125]

[2.1177171]

    script_builder_add_prelude((const struct GL_ShaderSnippet *)state->fragment_shader);

Replacement in quake2/ref_gl/gl_thin.c at line 966 [2.1166326]

B:BD[2.1200095] → [2.1200095:1200141]

    script_builder_add("%s", shader_prelude);

[2.1200095]

[2.1200141]

    script_builder_add_prelude((const struct GL_ShaderSnippet *)state->shader);

Insertion in quake2/ref_gl/gl_thin.c at line 987 [2.1166326]
[2.1201198]
[2.1201198]
```
    printf("%.*s\n", _.script_builder_len, _.script_builder_ptr);
```
Replacement in quake2/ref_gl/gl_sprite.c at line 55 [2.1203127]
B:BD[2.1205026] → [2.1205026:1205061]
```
void GL_draw_sprite(entity_t *e) {
```
[2.1205026]
[2.1205061]
```
void GL_draw_sprite(entity_t *e, model_t *model) {
```
Replacement in quake2/ref_gl/gl_sprite.c at line 64 [2.1203127]
B:BD[2.1205240] → [2.1205240:1205290]
```
  psprite = (dsprite_t *)currentmodel->extradata;
```
[2.1205240]
[2.1205290]
```
  psprite = (dsprite_t *)model->extradata;
```

Replacement in quake2/ref_gl/gl_sprite.c at line 103 [2.1203127]

B:BD[2.1206511] → [2.1206511:1206605]

                   &(struct GL_DrawAssets){.image[0] = currentmodel->skins[e->frame]->texnum,

[2.1206511]

[2.1206605]

                   &(struct GL_DrawAssets){.image[0] = model->skins[e->frame]->texnum,

Replacement in quake2/ref_gl/gl_rsurf.c at line 30 [2.1211734]
B:BD[2.1212624] → [2.1212624:1212654]
```
msurface_t *r_alpha_surfaces;
```
[2.1212624]
[2.1212654]
```
//msurface_t *r_alpha_surfaces;
```

Replacement in quake2/ref_gl/gl_rsurf.c at line 70 [2.1211734]

B:BD[2.1214146] → [2.1214146:1214314]

extern void R_SetCacheState(msurface_t *surf);
extern void R_BuildLightMap(msurface_t *surf, byte *dest_rgb0, byte *dest_r1, byte *dest_g1, byte *dest_b1, int stride);

[2.1214146]

[2.1214314]

extern void R_SetCacheState(model_t *model, msurface_t *surf);
extern void R_BuildLightMap(model_t *model, msurface_t *surf, byte *dest_rgb0, byte *dest_r1, byte *dest_g1, byte *dest_b1, int stride);

Replacement in quake2/ref_gl/gl_rsurf.c at line 272 [2.1211734]

B:BD[2.1223989] → [2.1223989:1224059]

static void GL_RenderLightmappedPoly(msurface_t *surf, float alpha) {

[2.1223989]

[2.1224059]

static void GL_RenderLightmappedPoly(model_t *model, msurface_t *surf, float alpha) {

Replacement in quake2/ref_gl/gl_rsurf.c at line 311 [2.1211734]

B:BD[2.1225102] → [2.1225102:1225209]

    R_BuildLightMap(surf, (void *)temp_rgb0, (void *)temp_r1, (void *)temp_g1, (void *)temp_b1, smax * 3);

[2.1225102]

[2.1225209]

    R_BuildLightMap(model, surf, (void *)temp_rgb0, (void *)temp_r1, (void *)temp_g1, (void *)temp_b1, smax * 3);

Replacement in quake2/ref_gl/gl_rsurf.c at line 314 [2.1211734]
B:BD[2.1225231] → [2.1225231:1225260]
```
      R_SetCacheState(surf);
```
[2.1225231]
[2.1225260]
```
      R_SetCacheState(model, surf);
```

Replacement in quake2/ref_gl/gl_rsurf.c at line 333 [2.1211734]

B:BD[2.1226140] → [2.1226140:1226222]

                                 .element_buffer = &currentmodel->element_buffer,

[2.1226140]

[2.1226222]

                                 .element_buffer = &model->element_buffer,

Replacement in quake2/ref_gl/gl_rsurf.c at line 335 [2.1211734]

B:BD[2.1226303] → [2.1226303:1226476]

                                 .vertex_buffers[0] = &currentmodel->position_buffer,
                                 .vertex_buffers[1] = &currentmodel->attribute_buffer,

[2.1226303]

[2.1226476]

                                 .vertex_buffers[0] = &model->position_buffer,
                                 .vertex_buffers[1] = &model->attribute_buffer,

Replacement in quake2/ref_gl/gl_rsurf.c at line 374 [2.1211734]
B:BD[2.1228204] → [2.1228204:1228237]
```
void R_DrawAlphaSurfaces(void) {
```
[2.1228204]
[2.1228237]
```
void R_DrawAlphaSurfaces(model_t *model) {
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 377 [2.1211734]
B:BD[2.1228255] → [2.1228255:1228309]
```
  for(s = r_alpha_surfaces; s; s = s->texturechain) {
```
[2.1228255]
[2.1228309]
```
  for(s = model->r_alpha_surfaces; s; s = s->texturechain) {
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 382 [2.1211734]
B:BD[2.1228441] → [2.1228441:1228481]
```
    GL_RenderLightmappedPoly(s, alpha);
```
[2.1228441]
[2.1228481]
```
    GL_RenderLightmappedPoly(model, s, alpha);
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 385 [2.1211734]
B:BD[2.1228486] → [2.1228486:1228513]
```
  r_alpha_surfaces = NULL;
```
[2.1228486]
[2.1228513]
```
  model->r_alpha_surfaces = NULL;
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 393 [2.1211734]
B:BD[2.1228577] → [2.1228577:1228621]
```
void R_DrawInlineBModel(int cmodel_index) {
```
[2.1228577]
[2.1228621]
```
void R_DrawInlineBModel(model_t *model) {
```

Replacement in quake2/ref_gl/gl_rsurf.c at line 404 [2.1211734]

B:BD[2.1228864] → [2.1228864:1228957]

      R_MarkLights(cmodel_index, lt, 1 << k, currentmodel->nodes + currentmodel->firstnode);

[2.1228864]

[2.1228957]

      R_MarkLights(model, lt, 1 << k, model->nodes + model->firstnode);

Replacement in quake2/ref_gl/gl_rsurf.c at line 408 [2.1211734]

B:BD[2.1228968] → [2.1228968:1229036]

  psurf = &currentmodel->surfaces[currentmodel->firstmodelsurface];

[2.1228968]

[2.1229036]

  psurf = &model->surfaces[model->firstmodelsurface];

Replacement in quake2/ref_gl/gl_rsurf.c at line 415 [2.1211734]

B:BD[2.1229134] → [2.1229134:1229199]

  for(i = 0; i < currentmodel->nummodelsurfaces; i++, psurf++) {

[2.1229134]

[2.1229199]

  for(i = 0; i < model->nummodelsurfaces; i++, psurf++) {

Replacement in quake2/ref_gl/gl_rsurf.c at line 425 [2.1211734]

B:BD[2.1229604] → [2.1229604:1229686]

        psurf->texturechain = r_alpha_surfaces;
        r_alpha_surfaces = psurf;

[2.1229604]

[2.1229686]

        psurf->texturechain = model->r_alpha_surfaces;
        model->r_alpha_surfaces = psurf;

Replacement in quake2/ref_gl/gl_rsurf.c at line 428 [2.1211734]
B:BD[2.1229701] → [2.1229701:1229749]
```
        GL_RenderLightmappedPoly(psurf, alpha);
```
[2.1229701]
[2.1229749]
```
        GL_RenderLightmappedPoly(model, psurf, alpha);
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 439 [2.1211734]
B:BD[2.1229829] → [2.1229829:1229866]
```
void R_DrawBrushModel(entity_t *e) {
```
[2.1229829]
[2.1229866]
```
void R_DrawBrushModel(entity_t *e, model_t *model) {
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 444 [2.1211734]
B:BD[2.1229913] → [2.1229913:1229955]
```
  if(currentmodel->nummodelsurfaces == 0)
```
[2.1229913]
[2.1229955]
```
  if(model->nummodelsurfaces == 0)
```

Replacement in quake2/ref_gl/gl_rsurf.c at line 452 [2.1211734]

B:BD[2.1230092] → [2.1230092:1230198]

      mins[i] = e->origin[i] - currentmodel->radius;
      maxs[i] = e->origin[i] + currentmodel->radius;

[2.1230092]

[2.1230198]

      mins[i] = e->origin[i] - model->radius;
      maxs[i] = e->origin[i] + model->radius;

Replacement in quake2/ref_gl/gl_rsurf.c at line 457 [2.1211734]

B:BD[2.1230236] → [2.1230236:1230340]

    VectorAdd(e->origin, currentmodel->mins, mins);
    VectorAdd(e->origin, currentmodel->maxs, maxs);

[2.1230236]

[2.1230340]

    VectorAdd(e->origin, model->mins, mins);
    VectorAdd(e->origin, model->maxs, maxs);

Replacement in quake2/ref_gl/gl_rsurf.c at line 485 [2.1211734]
B:BD[2.1231092] → [2.1231092:1231140]
```
  R_DrawInlineBModel(r_newrefdef.cmodel_index);
```
[2.1231092]
[2.1231140]
```
  R_DrawInlineBModel(model);
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 501 [2.1211734]
B:BD[2.1231351] → [2.1231351:1231412]
```
void R_RecursiveWorldNode(int cmodel_index, mnode_t *node) {
```
[2.1231351]
[2.1231412]
```
void R_RecursiveWorldNode(model_t *model, mnode_t *node) {
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 568 [2.1211734]
B:BD[2.1232759] → [2.1232759:1232819]
```
  R_RecursiveWorldNode(cmodel_index, node->children[side]);
```
[2.1232759]
[2.1232819]
```
  R_RecursiveWorldNode(model, node->children[side]);
```

Replacement in quake2/ref_gl/gl_rsurf.c at line 571 [2.1211734]

B:BD[2.1232836] → [2.1232836:1232949]

  for(c = node->numsurfaces, surf = r_worldmodel[cmodel_index]->surfaces + node->firstsurface; c; c--, surf++) {

[2.1232836]

[2.1232949]

  for(c = node->numsurfaces, surf = model->surfaces + node->firstsurface; c; c--, surf++) {

Replacement in quake2/ref_gl/gl_rsurf.c at line 580 [2.1211734]

B:BD[2.1233293] → [2.1233293:1233369]

      surf->texturechain = r_alpha_surfaces;
      r_alpha_surfaces = surf;

[2.1233293]

[2.1233369]

      surf->texturechain = model->r_alpha_surfaces;
      model->r_alpha_surfaces = surf;

Replacement in quake2/ref_gl/gl_rsurf.c at line 583 [2.1211734]
B:BD[2.1233382] → [2.1233382:1233423]
```
      GL_RenderLightmappedPoly(surf, 1);
```
[2.1233382]
[2.1233423]
```
      GL_RenderLightmappedPoly(model, surf, 1);
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 588 [2.1211734]
B:BD[2.1233466] → [2.1233466:1233527]
```
  R_RecursiveWorldNode(cmodel_index, node->children[!side]);
```
[2.1233466]
[2.1233527]
```
  R_RecursiveWorldNode(model, node->children[!side]);
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 596 [2.1211734]
B:BD[2.1233576] → [2.1233576:1233613]
```
void R_DrawWorld(int cmodel_index) {
```
[2.1233576]
[2.1233613]
```
void R_DrawWorld(model_t *model) {
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 605 [2.1211734]
B:BD[2.1233727] → [2.1233727:1233779]
```
  if(r_worldmodel[cmodel_index]->type != mod_brush)
```
[2.1233727]
[2.1233779]
```
  if(model->type != mod_brush)
```
Deletion in quake2/ref_gl/gl_rsurf.c at line 608 [2.1211734]
B:BD[2.1233792] → [2.1233792:1233838]
```
  currentmodel = r_worldmodel[cmodel_index];
```
Replacement in quake2/ref_gl/gl_rsurf.c at line 619 [2.1211734]
B:BD[2.1234168] → [2.1234168:1234241]
```
  R_RecursiveWorldNode(cmodel_index, r_worldmodel[cmodel_index]->nodes);
```
[2.1234168]
[2.1234241]
```
  R_RecursiveWorldNode(model, model->nodes);
```

Replacement in quake2/ref_gl/gl_rsurf.c at line 623 [2.1211734]

B:BD[2.1234267] → [2.1234267:1234350]

    extern void GL_draw_sky(uint32_t cmodel_index);
    GL_draw_sky(cmodel_index);

[2.1234267]

[2.1234350]

    extern void GL_draw_sky(int cmodel_index);
    GL_draw_sky(model->cmodel_index);

Replacement in quake2/ref_gl/gl_rsurf.c at line 636 [2.1211734]
B:BD[2.1234479] → [2.1234479:1234517]
```
void R_MarkLeaves(int cmodel_index) {
```
[2.1234479]
[2.1234517]
```
void R_MarkLeaves(model_t *model) {
```

Replacement in quake2/ref_gl/gl_rsurf.c at line 656 [2.1211734]

B:BD[2.1234976] → [2.1234976:1235058]

  if(r_novis->value || r_viewcluster == -1 || !r_worldmodel[cmodel_index]->vis) {

[2.1234976]

[2.1235058]

  if(r_novis->value || r_viewcluster == -1 || !model->vis) {

Replacement in quake2/ref_gl/gl_rsurf.c at line 658 [2.1211734]

B:BD[2.1235081] → [2.1235081:1235347]

    for(i = 0; i < r_worldmodel[cmodel_index]->numleafs; i++)
      r_worldmodel[cmodel_index]->leafs[i].visframe = r_visframecount;
    for(i = 0; i < r_worldmodel[cmodel_index]->numnodes; i++)
      r_worldmodel[cmodel_index]->nodes[i].visframe = r_visframecount;

[2.1235081]

[2.1235347]

    for(i = 0; i < model->numleafs; i++)
      model->leafs[i].visframe = r_visframecount;
    for(i = 0; i < model->numnodes; i++)
      model->nodes[i].visframe = r_visframecount;

Replacement in quake2/ref_gl/gl_rsurf.c at line 665 [2.1211734]
B:BD[2.1235364] → [2.1235364:1235431]
```
  vis = Mod_ClusterPVS(r_viewcluster, r_worldmodel[cmodel_index]);
```
[2.1235364]
[2.1235431]
```
  vis = Mod_ClusterPVS(r_viewcluster, model);
```

Replacement in quake2/ref_gl/gl_rsurf.c at line 668 [2.1211734]

B:BD[2.1235543] → [2.1235543:1235744]

    memcpy(fatvis, vis, (r_worldmodel[cmodel_index]->numleafs + 7) / 8);
    vis = Mod_ClusterPVS(r_viewcluster2, r_worldmodel[cmodel_index]);
    c = (r_worldmodel[cmodel_index]->numleafs + 31) / 32;

[2.1235543]

[2.1235744]

    memcpy(fatvis, vis, (model->numleafs + 7) / 8);
    vis = Mod_ClusterPVS(r_viewcluster2, model);
    c = (model->numleafs + 31) / 32;

Replacement in quake2/ref_gl/gl_rsurf.c at line 676 [2.1211734]

B:BD[2.1235839] → [2.1235839:1235951]

  for(i = 0, leaf = r_worldmodel[cmodel_index]->leafs; i < r_worldmodel[cmodel_index]->numleafs; i++, leaf++) {

[2.1235839]

[2.1235951]

  for(i = 0, leaf = model->leafs; i < model->numleafs; i++, leaf++) {

Replacement in quake2/ref_gl/gl_rsurf.c at line 771 [2.1211734]
B:BD[2.1238542] → [2.1238542:1238592]
```
void GL_CreateSurfaceLightmap(msurface_t *surf) {
```
[2.1238542]
[2.1238592]
```
void GL_CreateSurfaceLightmap(model_t *model, msurface_t *surf) {
```

Replacement in quake2/ref_gl/gl_rsurf.c at line 803 [2.1211734]

B:BD[2.1239571] → [2.1239571:1239679]

  R_SetCacheState(surf);
  R_BuildLightMap(surf, base_rgb0, base_r1, base_g1, base_b1, LIGHTMAP_WIDTH * 3);

[2.1239571]

[2.1239679]

  R_SetCacheState(model, surf);
  R_BuildLightMap(model, surf, base_rgb0, base_r1, base_g1, base_b1, LIGHTMAP_WIDTH * 3);

Replacement in quake2/ref_gl/gl_rmain.c at line 31 [2.1246349]
B:BD[2.1247275] → [2.1247275:1247316]
```
extern void GL_draw_sprite(entity_t *e);
```
[2.1247275]
[2.1247316]
```
extern void GL_draw_sprite(entity_t *e, model_t *model);
```
Deletion in quake2/ref_gl/gl_rmain.c at line 101 [2.1246349]
B:BD[2.1250224] → [2.1250224:1250247]
```
model_t *currentmodel;
```

Replacement in quake2/ref_gl/gl_rmain.c at line 241 [2.1246349]

B:BD[2.1253206] → [2.1253206:1253275]

      currentmodel = currententity->model;
      if(!currentmodel) {

[2.1253206]

[2.1253275]

      model_t *model = currententity->model;
      if(!model) {

Replacement in quake2/ref_gl/gl_rmain.c at line 246 [2.1246349]
B:BD[2.1253336] → [2.1253336:1253371]
```
      switch(currentmodel->type) {
```
[2.1253336]
[2.1253371]
```
      switch(model->type) {
```
Replacement in quake2/ref_gl/gl_rmain.c at line 248 [2.1246349]
B:BD[2.1253393] → [2.1253393:1253434]
```
        R_DrawAliasModel(currententity);
```
[2.1253393]
[2.1253434]
```
        R_DrawAliasModel(currententity, model);
```
Replacement in quake2/ref_gl/gl_rmain.c at line 251 [2.1246349]
B:BD[2.1253471] → [2.1253471:1253512]
```
        R_DrawBrushModel(currententity);
```
[2.1253471]
[2.1253512]
```
        R_DrawBrushModel(currententity, model);
```
Replacement in quake2/ref_gl/gl_rmain.c at line 254 [2.1246349]
B:BD[2.1253550] → [2.1253550:1253589]
```
        GL_draw_sprite(currententity);
```
[2.1253550]
[2.1253589]
```
        GL_draw_sprite(currententity, model);
```
Replacement in quake2/ref_gl/gl_rmain.c at line 274 [2.1246349]
B:BD[2.1254088] → [2.1254088:1254131]
```
      currentmodel = currententity->model;
```
[2.1254088]
[2.1254131]
```
      model_t *model = currententity->model;
```
Replacement in quake2/ref_gl/gl_rmain.c at line 276 [2.1246349]
B:BD[2.1254132] → [2.1254132:1254158]
```
      if(!currentmodel) {
```
[2.1254132]
[2.1254158]
```
      if(!model) {
```
Replacement in quake2/ref_gl/gl_rmain.c at line 280 [2.1246349]
B:BD[2.1254219] → [2.1254219:1254254]
```
      switch(currentmodel->type) {
```
[2.1254219]
[2.1254254]
```
      switch(model->type) {
```
Replacement in quake2/ref_gl/gl_rmain.c at line 282 [2.1246349]
B:BD[2.1254276] → [2.1254276:1254317]
```
        R_DrawAliasModel(currententity);
```
[2.1254276]
[2.1254317]
```
        R_DrawAliasModel(currententity, model);
```
Replacement in quake2/ref_gl/gl_rmain.c at line 285 [2.1246349]
B:BD[2.1254354] → [2.1254354:1254395]
```
        R_DrawBrushModel(currententity);
```
[2.1254354]
[2.1254395]
```
        R_DrawBrushModel(currententity, model);
```
Replacement in quake2/ref_gl/gl_rmain.c at line 288 [2.1246349]
B:BD[2.1254433] → [2.1254433:1254472]
```
        GL_draw_sprite(currententity);
```
[2.1254433]
[2.1254472]
```
        GL_draw_sprite(currententity, model);
```
Insertion in quake2/ref_gl/gl_rmain.c at line 505 [2.1246349]
[2.1260444]
[2.1260444]
```
  model_t *model = r_worldmodel[r_newrefdef.cmodel_index];
```
Replacement in quake2/ref_gl/gl_rmain.c at line 512 [2.1246349]
B:BD[2.1260519] → [2.1260519:1260562]
```
  R_PushDlights(r_newrefdef.cmodel_index);
```
[2.1260519]
[2.1260562]
```
  R_PushDlights(model);
```

Replacement in quake2/ref_gl/gl_rmain.c at line 523 [2.1246349]

B:BD[2.1260657] → [2.1260657:1260741]

  R_MarkLeaves(r_newrefdef.cmodel_index); // done here so we know if we're in water

[2.1260657]

[2.1260741]

  R_MarkLeaves(model); // done here so we know if we're in water

Replacement in quake2/ref_gl/gl_rmain.c at line 525 [2.1246349]
B:BD[2.1260742] → [2.1260742:1260783]
```
  R_DrawWorld(r_newrefdef.cmodel_index);
```
[2.1260742]
[2.1260783]
```
  R_DrawWorld(model);
```
Replacement in quake2/ref_gl/gl_rmain.c at line 531 [2.1246349]
B:BD[2.1260835] → [2.1260835:1260860]
```
  R_DrawAlphaSurfaces();
```
[2.1260835]
[2.1260860]
```
  R_DrawAlphaSurfaces(model);
```

Replacement in quake2/ref_gl/gl_rmain.c at line 561 [2.1246349]

B:BD[2.1261517] → [2.1261517:1261593]

  shadelight = R_LightPoint(r_newrefdef.cmodel_index, r_newrefdef.vieworg);

[2.1261517]

[2.1261593]

  shadelight = R_LightPoint(r_worldmodel[r_newrefdef.cmodel_index], r_newrefdef.vieworg);

Replacement in quake2/ref_gl/gl_particle.c at line 142 [2.1275050]

B:BD[2.1283825] → [2.1283825:1283889]

        vec2(incandescence / 256, incandescence_velocity / 256)

[2.1283825]

[2.1283889]

        vec2(incandescence / 256, incandescence_velocity / 256),
        vec2(1, 0)

Insertion in quake2/ref_gl/gl_particle.c at line 329 [2.1275050]
[2.1291693]
[2.1291693]

Replacement in quake2/ref_gl/gl_particle.c at line 331 [2.1275050]

B:BD[2.1291713] → [2.1291713:1291743]

THIN_GL_SHADER(post_simulate,

[2.1291713]

[2.1291743]

THIN_GL_SHADER(postsimulate,
  main(
    uint count = u_particle_counter.alive;
    u_particle_indirect.draw.count = count;
    for(uint i = 0; i < count; i++) {
      u_particle_alive.item[i] = u_particle_emitted.item[i];
    }
  )
)
// clang-format on
struct GL_ComputeState postsimulate_compute_state = {.shader = &postsimulate_shader,
                                                     .global[0] = {0, &indirect_resource},
                                                     .global[1] = {0, &counter_resource},
                                                     .global[2] = {0, &alive_resource},
                                                     .global[3] = {0, &emitted_resource}};
// clang-format off
THIN_GL_SHADER(postsimulate_sort,

Replacement in quake2/ref_gl/gl_particle.c at line 384 [2.1275050]

B:BD[2.1292945] → [2.1292945:1293031]

struct GL_ComputeState postsimulate_compute_state = {.shader = &post_simulate_shader,

[2.1292945]

[2.1293031]

struct GL_ComputeState postsimulate_sort_compute_state = {.shader = &postsimulate_sort_shader,

Replacement in quake2/ref_gl/gl_particle.c at line 668 [2.1275050]

B:BD[2.1306303] → [2.1306303:1306411]

  glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
  GL_compute(&postsimulate_compute_state, NULL, 1, 1, 1);

[2.1306303]

[2.1306411]

  if(false) {
    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
    GL_compute(&postsimulate_sort_compute_state, NULL, 1, 1, 1);

Replacement in quake2/ref_gl/gl_particle.c at line 672 [2.1275050]

B:BD[2.1306412] → [2.1306412:1306639]

  glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT | GL_COMMAND_BARRIER_BIT);
  GL_compute_indirect(&sort_particles_fill_pass_state, NULL, &sort_parameters_buffer,
                      offsetof(struct GL_sort_parameters, fill));

[2.1306412]

[2.1306639]

    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT | GL_COMMAND_BARRIER_BIT);
    GL_compute_indirect(&sort_particles_fill_pass_state, NULL, &sort_parameters_buffer,
                        offsetof(struct GL_sort_parameters, fill));

Replacement in quake2/ref_gl/gl_particle.c at line 676 [2.1275050]

B:BD[2.1306640] → [2.1306640:1306848]

  glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
  GL_compute_indirect(&sort_particles_radix_pass_1_state, NULL, &sort_parameters_buffer,
                      offsetof(struct GL_sort_parameters, radix_1));

[2.1306640]

[2.1306848]

    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
    GL_compute_indirect(&sort_particles_radix_pass_1_state, NULL, &sort_parameters_buffer,
                        offsetof(struct GL_sort_parameters, radix_1));

Replacement in quake2/ref_gl/gl_particle.c at line 680 [2.1275050]

B:BD[2.1306849] → [2.1306849:1307055]

  glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
  GL_compute_indirect(&sort_particles_rotate_pass_state, NULL, &sort_parameters_buffer,
                      offsetof(struct GL_sort_parameters, rotate));

[2.1306849]

[2.1307055]

    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
    GL_compute_indirect(&sort_particles_rotate_pass_state, NULL, &sort_parameters_buffer,
                        offsetof(struct GL_sort_parameters, rotate));

Replacement in quake2/ref_gl/gl_particle.c at line 684 [2.1275050]

B:BD[2.1307056] → [2.1307056:1307264]

  glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
  GL_compute_indirect(&sort_particles_radix_pass_2_state, NULL, &sort_parameters_buffer,
                      offsetof(struct GL_sort_parameters, radix_2));

[2.1307056]

[2.1307264]

    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
    GL_compute_indirect(&sort_particles_radix_pass_2_state, NULL, &sort_parameters_buffer,
                        offsetof(struct GL_sort_parameters, radix_2));

Replacement in quake2/ref_gl/gl_particle.c at line 688 [2.1275050]

B:BD[2.1307265] → [2.1307265:1307483]

  glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
  GL_compute_indirect(&sort_particles_sortedmatrix_pass_state, NULL, &sort_parameters_buffer,
                      offsetof(struct GL_sort_parameters, sortedmatrix));

[2.1307265]

[2.1307483]

    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
    GL_compute_indirect(&sort_particles_sortedmatrix_pass_state, NULL, &sort_parameters_buffer,
                        offsetof(struct GL_sort_parameters, sortedmatrix));
  } else {
    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
    GL_compute(&postsimulate_compute_state, NULL, 1, 1, 1);
  }

Replacement in quake2/ref_gl/gl_model_not_found.c at line 98 [2.1308441]

B:BD[2.1312860] → [2.1312860:1312940]

    shadelight = R_LightPoint(r_newrefdef.cmodel_index, currententity->origin);

[2.1312860]

[2.1312940]

    shadelight = R_LightPoint(r_worldmodel[r_newrefdef.cmodel_index], currententity->origin);

Insertion in quake2/ref_gl/gl_model.h at line 234 [2.1314018]
[2.1319011]
[2.1319011]
```
  bool old_lightmap;
```
Insertion in quake2/ref_gl/gl_model.h at line 237 [2.1314018]
[2.1319012]
[2.1319012]
```
  int lightdatasize;
```
Insertion in quake2/ref_gl/gl_model.h at line 254 [2.1314018]
[2.1319436]
[2.1319436]
```
  msurface_t *r_alpha_surfaces;
```
Replacement in quake2/ref_gl/gl_model.c at line 24 [2.1319869]
B:BD[2.1320663] → [2.1320663:1320683]
```
model_t *loadmodel;
```
[2.1320663]
[2.1320683]
```
//model_t *model;
```
Replacement in quake2/ref_gl/gl_model.c at line 163 [2.1319869]
B:BD[2.1323673] → [2.1323673:1323724]
```
  model_t *mod = (model_t *)ud;
  loadmodel = mod;
```
[2.1323673]
[2.1323724]
```
  model_t *model = (model_t *)ud;
```

Replacement in quake2/ref_gl/gl_model.c at line 175 [2.1319869]

B:BD[2.1323881] → [2.1323881:1323946]

    loadmodel->extradata = HunkAllocator_Begin(&hunk, 0x200000);

[2.1323881]

[2.1323946]

    model->extradata = HunkAllocator_Begin(&hunk, 0x200000);

Replacement in quake2/ref_gl/gl_model.c at line 177 [2.1319869]
B:BD[2.1324001] → [2.1324001:1324046]
```
    GL_MD2_Load(mod, &hunk, (void *)buffer);
```
[2.1324001]
[2.1324046]
```
    GL_MD2_Load(model, &hunk, (void *)buffer);
```

Replacement in quake2/ref_gl/gl_model.c at line 181 [2.1319869]

B:BD[2.1324081] → [2.1324081:1324198]

    loadmodel->extradata = HunkAllocator_Begin(&hunk, 0x10000);
    Mod_LoadSpriteModel(mod, &hunk, (void *)buffer);

[2.1324081]

[2.1324198]

    model->extradata = HunkAllocator_Begin(&hunk, 0x10000);
    Mod_LoadSpriteModel(model, &hunk, (void *)buffer);

Replacement in quake2/ref_gl/gl_model.c at line 186 [2.1319869]

B:BD[2.1324230] → [2.1324230:1324348]

    loadmodel->extradata = HunkAllocator_Begin(&hunk, 0x1000000);
    Mod_LoadBrushModel(mod, &hunk, (void *)buffer);

[2.1324230]

[2.1324348]

    model->extradata = HunkAllocator_Begin(&hunk, 0x1000000);
    model->old_lightmap = false;
    Mod_LoadBrushModel(model, &hunk, (void *)buffer);

Replacement in quake2/ref_gl/gl_model.c at line 192 [2.1319869]

B:BD[2.1324371] → [2.1324371:1324451]

    ri.Sys_Error(ERR_DROP, "Mod_NumForName: unknown fileid for %s", mod->name);

[2.1324371]

[2.1324451]

    ri.Sys_Error(ERR_DROP, "Mod_NumForName: unknown fileid for %s", model->name);

Replacement in quake2/ref_gl/gl_model.c at line 196 [2.1319869]
B:BD[2.1324467] → [2.1324467:1324522]
```
  loadmodel->extradatasize = HunkAllocator_End(&hunk);
```
[2.1324467]
[2.1324522]
```
  model->extradatasize = HunkAllocator_End(&hunk);
```

Replacement in quake2/ref_gl/gl_model.c at line 278 [2.1319869]

B:BD[2.1326256] → [2.1326256:1326319]

void Mod_LoadLighting(lump_t *l, struct HunkAllocator *hunk) {

[2.1326256]

[2.1326319]

void Mod_LoadLighting(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 280 [2.1319869]
B:BD[2.1326339] → [2.1326339:1326372]
```
    loadmodel->lightdata = NULL;
```
[2.1326339]
[2.1326372]
```
    model->lightdata = NULL;
```

Replacement in quake2/ref_gl/gl_model.c at line 283 [2.1319869]

B:BD[2.1326388] → [2.1326388:1326519]

  loadmodel->lightdata = HunkAllocator_Alloc(hunk, l->filelen);
  memcpy(loadmodel->lightdata, mod_base + l->fileofs, l->filelen);

[2.1326388]

[2.1326519]

  model->lightdatasize = l->filelen;
  model->lightdata = HunkAllocator_Alloc(hunk, l->filelen);
  memcpy(model->lightdata, mod_base + l->fileofs, l->filelen);

Replacement in quake2/ref_gl/gl_model.c at line 293 [2.1319869]

B:BD[2.1326583] → [2.1326583:1326648]

void Mod_LoadVisibility(lump_t *l, struct HunkAllocator *hunk) {

[2.1326583]

[2.1326648]

void Mod_LoadVisibility(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 297 [2.1319869]
B:BD[2.1326678] → [2.1326678:1326705]
```
    loadmodel->vis = NULL;
```
[2.1326678]
[2.1326705]
```
    model->vis = NULL;
```

Replacement in quake2/ref_gl/gl_model.c at line 300 [2.1319869]

B:BD[2.1326721] → [2.1326721:1326840]

  loadmodel->vis = HunkAllocator_Alloc(hunk, l->filelen);
  memcpy(loadmodel->vis, mod_base + l->fileofs, l->filelen);

[2.1326721]

[2.1326840]

  model->vis = HunkAllocator_Alloc(hunk, l->filelen);
  memcpy(model->vis, mod_base + l->fileofs, l->filelen);

Replacement in quake2/ref_gl/gl_model.c at line 303 [2.1319869]

B:BD[2.1326841] → [2.1326841:1327121]

  loadmodel->vis->numclusters = LittleLong(loadmodel->vis->numclusters);
  for(i = 0; i < loadmodel->vis->numclusters; i++) {
    loadmodel->vis->bitofs[i][0] = LittleLong(loadmodel->vis->bitofs[i][0]);
    loadmodel->vis->bitofs[i][1] = LittleLong(loadmodel->vis->bitofs[i][1]);

[2.1326841]

[2.1327121]

  model->vis->numclusters = LittleLong(model->vis->numclusters);
  for(i = 0; i < model->vis->numclusters; i++) {
    model->vis->bitofs[i][0] = LittleLong(model->vis->bitofs[i][0]);
    model->vis->bitofs[i][1] = LittleLong(model->vis->bitofs[i][1]);

Replacement in quake2/ref_gl/gl_model.c at line 315 [2.1319869]

B:BD[2.1327187] → [2.1327187:1327250]

void Mod_LoadVertexes(lump_t *l, struct HunkAllocator *hunk) {

[2.1327187]

[2.1327250]

void Mod_LoadVertexes(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 322 [2.1319869]

B:BD[2.1327373] → [2.1327373:1327459]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", loadmodel->name);

[2.1327373]

[2.1327459]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", model->name);

Replacement in quake2/ref_gl/gl_model.c at line 326 [2.1319869]
B:BD[2.1327553] → [2.1327553:1327616]
```
  loadmodel->vertexes = out;
  loadmodel->numvertexes = count;
```
[2.1327553]
[2.1327616]
```
  model->vertexes = out;
  model->numvertexes = count;
```

Replacement in quake2/ref_gl/gl_model.c at line 357 [2.1319869]

B:BD[2.1328160] → [2.1328160:1328224]

void Mod_LoadSubmodels(lump_t *l, struct HunkAllocator *hunk) {

[2.1328160]

[2.1328224]

void Mod_LoadSubmodels(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 364 [2.1319869]

B:BD[2.1328348] → [2.1328348:1328434]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", loadmodel->name);

[2.1328348]

[2.1328434]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", model->name);

Replacement in quake2/ref_gl/gl_model.c at line 368 [2.1319869]

B:BD[2.1328528] → [2.1328528:1328593]

  loadmodel->submodels = out;
  loadmodel->numsubmodels = count;

[2.1328528]

[2.1328593]

  model->submodels = out;
  model->numsubmodels = count;

Replacement in quake2/ref_gl/gl_model.c at line 389 [2.1319869]

B:BD[2.1329124] → [2.1329124:1329184]

void Mod_LoadEdges(lump_t *l, struct HunkAllocator *hunk) {

[2.1329124]

[2.1329184]

void Mod_LoadEdges(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 396 [2.1319869]

B:BD[2.1329303] → [2.1329303:1329389]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", loadmodel->name);

[2.1329303]

[2.1329389]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", model->name);

Replacement in quake2/ref_gl/gl_model.c at line 400 [2.1319869]
B:BD[2.1329489] → [2.1329489:1329546]
```
  loadmodel->edges = out;
  loadmodel->numedges = count;
```
[2.1329489]
[2.1329546]
```
  model->edges = out;
  model->numedges = count;
```

Replacement in quake2/ref_gl/gl_model.c at line 414 [2.1319869]

B:BD[2.1329766] → [2.1329766:1329828]

void Mod_LoadTexinfo(lump_t *l, struct HunkAllocator *hunk) {

[2.1329766]

[2.1329828]

void Mod_LoadTexinfo(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 423 [2.1319869]

B:BD[2.1329998] → [2.1329998:1330084]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", loadmodel->name);

[2.1329998]

[2.1330084]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", model->name);

Replacement in quake2/ref_gl/gl_model.c at line 427 [2.1319869]
B:BD[2.1330178] → [2.1330178:1330239]
```
  loadmodel->texinfo = out;
  loadmodel->numtexinfo = count;
```
[2.1330178]
[2.1330239]
```
  model->texinfo = out;
  model->numtexinfo = count;
```
Replacement in quake2/ref_gl/gl_model.c at line 437 [2.1319869]
B:BD[2.1330462] → [2.1330462:1330507]
```
      out->next = loadmodel->texinfo + next;
```
[2.1330462]
[2.1330507]
```
      out->next = model->texinfo + next;
```
Replacement in quake2/ref_gl/gl_model.c at line 467 [2.1319869]
B:BD[2.1331425] → [2.1331425:1331459]
```
    out = &loadmodel->texinfo[i];
```
[2.1331425]
[2.1331459]
```
    out = &model->texinfo[i];
```
Replacement in quake2/ref_gl/gl_model.c at line 481 [2.1319869]
B:BD[2.1331683] → [2.1331683:1331724]
```
void CalcSurfaceExtents(msurface_t *s) {
```
[2.1331683]
[2.1331724]
```
void CalcSurfaceExtents(model_t *model, msurface_t *s) {
```
Replacement in quake2/ref_gl/gl_model.c at line 494 [2.1319869]
B:BD[2.1331951] → [2.1331951:1331999]
```
    e = loadmodel->surfedges[s->firstedge + i];
```
[2.1331951]
[2.1331999]
```
    e = model->surfedges[s->firstedge + i];
```
Replacement in quake2/ref_gl/gl_model.c at line 496 [2.1319869]
B:BD[2.1332014] → [2.1332014:1332072]
```
      v = &loadmodel->vertexes[loadmodel->edges[e].v[0]];
```
[2.1332014]
[2.1332072]
```
      v = &model->vertexes[model->edges[e].v[0]];
```
Replacement in quake2/ref_gl/gl_model.c at line 498 [2.1319869]
B:BD[2.1332081] → [2.1332081:1332140]
```
      v = &loadmodel->vertexes[loadmodel->edges[-e].v[1]];
```
[2.1332081]
[2.1332140]
```
      v = &model->vertexes[model->edges[-e].v[1]];
```
Replacement in quake2/ref_gl/gl_model.c at line 523 [2.1319869]
B:BD[2.1332825] → [2.1332825:1332874]
```
void GL_CreateSurfaceLightmap(msurface_t *surf);
```
[2.1332825]
[2.1332874]
```
void GL_CreateSurfaceLightmap(model_t *model, msurface_t *surf);
```
Replacement in quake2/ref_gl/gl_model.c at line 525 [2.1319869]
B:BD[2.1332910] → [2.1332910:1332954]
```
void GL_BeginBuildingLightmaps(model_t *m);
```
[2.1332910]
[2.1332954]
```
void GL_BeginBuildingLightmaps(model_t *model);
```

Replacement in quake2/ref_gl/gl_model.c at line 532 [2.1319869]

B:BD[2.1333011] → [2.1333011:1333071]

void Mod_LoadFaces(lump_t *l, struct HunkAllocator *hunk) {

[2.1333011]

[2.1333071]

void Mod_LoadFaces(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 541 [2.1319869]

B:BD[2.1333234] → [2.1333234:1333320]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", loadmodel->name);

[2.1333234]

[2.1333320]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", model->name);

Deletion in quake2/ref_gl/gl_model.c at line 544 [2.1319869]
B:BD[2.1333413] → [2.1333413:1333477]
```
  loadmodel->surfaces = out;
  loadmodel->numsurfaces = count;
```
Replacement in quake2/ref_gl/gl_model.c at line 545 [2.1319869]
B:BD[2.1333478] → [2.1333478:1333506]
```
  currentmodel = loadmodel;
```
[2.1333478]
[2.1333506]
```
  model->surfaces = out;
  model->numsurfaces = count;
```
Replacement in quake2/ref_gl/gl_model.c at line 548 [2.1319869]
B:BD[2.1333507] → [2.1333507:1333547]
```
  GL_BeginBuildingLightmaps(loadmodel);
```
[2.1333507]
[2.1333547]
```
  GL_BeginBuildingLightmaps(model);
```
Replacement in quake2/ref_gl/gl_model.c at line 565 [2.1319869]
B:BD[2.1334082] → [2.1334082:1334083]
[2.1334082]
[2.1334083]
```
  
```
Replacement in quake2/ref_gl/gl_model.c at line 576 [2.1319869]
B:BD[2.1334387] → [2.1334387:1334434]
```
    out->plane = loadmodel->planes + planenum;
```
[2.1334387]
[2.1334434]
```
    out->plane = model->planes + planenum;
```
Replacement in quake2/ref_gl/gl_model.c at line 579 [2.1319869]
B:BD[2.1334470] → [2.1334470:1334516]
```
    if(ti < 0 || ti >= loadmodel->numtexinfo)
```
[2.1334470]
[2.1334516]
```
    if(ti < 0 || ti >= model->numtexinfo)
```
Replacement in quake2/ref_gl/gl_model.c at line 581 [2.1319869]
B:BD[2.1334584] → [2.1334584:1334628]
```
    out->texinfo = loadmodel->texinfo + ti;
```
[2.1334584]
[2.1334628]
```
    out->texinfo = model->texinfo + ti;
```
Replacement in quake2/ref_gl/gl_model.c at line 583 [2.1319869]
B:BD[2.1334629] → [2.1334629:1334658]
```
    CalcSurfaceExtents(out);
```
[2.1334629]
[2.1334658]
```
    CalcSurfaceExtents(model, out);
```
Insertion in quake2/ref_gl/gl_model.c at line 589 [2.1319869]
[2.1334757]
[2.1334757]

Replacement in quake2/ref_gl/gl_model.c at line 593 [2.1319869]

B:BD[2.1334903] → [2.1334903:1334959]

    else
      out->samples = loadmodel->lightdata + i;

[2.1334903]

[2.1334959]

    else {
      out->samples = model->lightdata + i;

Replacement in quake2/ref_gl/gl_model.c at line 596 [2.1319869]

B:BD[2.1334960] → [2.1334960:1334995]

    GL_CreateSurfaceLightmap(out);

[2.1334960]

[2.1334995]

      int smax = (out->extents[0] >> 4) + 1;
      int tmax = (out->extents[1] >> 4) + 1;
      int size = smax * tmax;
      if(i + (size * 3) * 4 > model->lightdatasize) {
        model->old_lightmap = true;
      }
    }
  }
  in = (void *)(mod_base + l->fileofs);
  out = model->surfaces;
  for(surfnum = 0; surfnum < count; surfnum++, in++, out++) {
    GL_CreateSurfaceLightmap(model, out);

Replacement in quake2/ref_gl/gl_model.c at line 622 [2.1319869]

B:BD[2.1335258] → [2.1335258:1335322]

      int lindex = currentmodel->surfedges[out->firstedge + i];

[2.1335258]

[2.1335322]

      int lindex = model->surfedges[out->firstedge + i];

Replacement in quake2/ref_gl/gl_model.c at line 625 [2.1319869]

B:BD[2.1335346] → [2.1335346:1335456]

        r_pedge = &currentmodel->edges[lindex];
        vec = currentmodel->vertexes[r_pedge->v[0]].position;

[2.1335346]

[2.1335456]

        r_pedge = &model->edges[lindex];
        vec = model->vertexes[r_pedge->v[0]].position;

Replacement in quake2/ref_gl/gl_model.c at line 628 [2.1319869]

B:BD[2.1335471] → [2.1335471:1335582]

        r_pedge = &currentmodel->edges[-lindex];
        vec = currentmodel->vertexes[r_pedge->v[1]].position;

[2.1335471]

[2.1335582]

        r_pedge = &model->edges[-lindex];
        vec = model->vertexes[r_pedge->v[1]].position;

Replacement in quake2/ref_gl/gl_model.c at line 670 [2.1319869]
B:BD[2.1337428] → [2.1337428:1337458]
```
  loadmodel->element_buffer =
```
[2.1337428]
[2.1337458]
```
  model->element_buffer =
```
Replacement in quake2/ref_gl/gl_model.c at line 672 [2.1319869]
B:BD[2.1337570] → [2.1337570:1337601]
```
  loadmodel->position_buffer =
```
[2.1337570]
[2.1337601]
```
  model->position_buffer =
```
Replacement in quake2/ref_gl/gl_model.c at line 674 [2.1319869]
B:BD[2.1337707] → [2.1337707:1337739]
```
  loadmodel->attribute_buffer =
```
[2.1337707]
[2.1337739]
```
  model->attribute_buffer =
```

Replacement in quake2/ref_gl/gl_model.c at line 702 [2.1319869]

B:BD[2.1338286] → [2.1338286:1338346]

void Mod_LoadNodes(lump_t *l, struct HunkAllocator *hunk) {

[2.1338286]

[2.1338346]

void Mod_LoadNodes(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 709 [2.1319869]

B:BD[2.1338471] → [2.1338471:1338557]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", loadmodel->name);

[2.1338471]

[2.1338557]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", model->name);

Replacement in quake2/ref_gl/gl_model.c at line 713 [2.1319869]
B:BD[2.1338651] → [2.1338651:1338708]
```
  loadmodel->nodes = out;
  loadmodel->numnodes = count;
```
[2.1338651]
[2.1338708]
```
  model->nodes = out;
  model->numnodes = count;
```
Replacement in quake2/ref_gl/gl_model.c at line 723 [2.1319869]
B:BD[2.1338927] → [2.1338927:1338967]
```
    out->plane = loadmodel->planes + p;
```
[2.1338927]
[2.1338967]
```
    out->plane = model->planes + p;
```
Replacement in quake2/ref_gl/gl_model.c at line 732 [2.1319869]
B:BD[2.1339208] → [2.1339208:1339257]
```
        out->children[j] = loadmodel->nodes + p;
```
[2.1339208]
[2.1339257]
```
        out->children[j] = model->nodes + p;
```

Replacement in quake2/ref_gl/gl_model.c at line 734 [2.1319869]

B:BD[2.1339268] → [2.1339268:1339337]

        out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));

[2.1339268]

[2.1339337]

        out->children[j] = (mnode_t *)(model->leafs + (-1 - p));

Replacement in quake2/ref_gl/gl_model.c at line 738 [2.1319869]

B:BD[2.1339348] → [2.1339348:1339413]

  Mod_SetParent(loadmodel->nodes, NULL); // sets nodes and leafs

[2.1339348]

[2.1339413]

  Mod_SetParent(model->nodes, NULL); // sets nodes and leafs

Replacement in quake2/ref_gl/gl_model.c at line 746 [2.1319869]

B:BD[2.1339472] → [2.1339472:1339532]

void Mod_LoadLeafs(lump_t *l, struct HunkAllocator *hunk) {

[2.1339472]

[2.1339532]

void Mod_LoadLeafs(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 754 [2.1319869]

B:BD[2.1339678] → [2.1339678:1339764]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", loadmodel->name);

[2.1339678]

[2.1339764]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", model->name);

Replacement in quake2/ref_gl/gl_model.c at line 758 [2.1319869]
B:BD[2.1339858] → [2.1339858:1339915]
```
  loadmodel->leafs = out;
  loadmodel->numleafs = count;
```
[2.1339858]
[2.1339915]
```
  model->leafs = out;
  model->numleafs = count;
```

Replacement in quake2/ref_gl/gl_model.c at line 773 [2.1319869]

B:BD[2.1340243] → [2.1340243:1340329]

    out->firstmarksurface = loadmodel->marksurfaces + LittleShort(in->firstleafface);

[2.1340243]

[2.1340329]

    out->firstmarksurface = model->marksurfaces + LittleShort(in->firstleafface);

Replacement in quake2/ref_gl/gl_model.c at line 796 [2.1319869]

B:BD[2.1340815] → [2.1340815:1340882]

void Mod_LoadMarksurfaces(lump_t *l, struct HunkAllocator *hunk) {

[2.1340815]

[2.1340882]

void Mod_LoadMarksurfaces(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 803 [2.1319869]

B:BD[2.1341006] → [2.1341006:1341092]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", loadmodel->name);

[2.1341006]

[2.1341092]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", model->name);

Replacement in quake2/ref_gl/gl_model.c at line 807 [2.1319869]

B:BD[2.1341186] → [2.1341186:1341257]

  loadmodel->marksurfaces = out;
  loadmodel->nummarksurfaces = count;

[2.1341186]

[2.1341257]

  model->marksurfaces = out;
  model->nummarksurfaces = count;

Replacement in quake2/ref_gl/gl_model.c at line 812 [2.1319869]
B:BD[2.1341317] → [2.1341317:1341362]
```
    if(j < 0 || j >= loadmodel->numsurfaces)
```
[2.1341317]
[2.1341362]
```
    if(j < 0 || j >= model->numsurfaces)
```
Replacement in quake2/ref_gl/gl_model.c at line 814 [2.1319869]
B:BD[2.1341437] → [2.1341437:1341475]
```
    out[i] = loadmodel->surfaces + j;
```
[2.1341437]
[2.1341475]
```
    out[i] = model->surfaces + j;
```

Replacement in quake2/ref_gl/gl_model.c at line 823 [2.1319869]

B:BD[2.1341542] → [2.1341542:1341606]

void Mod_LoadSurfedges(lump_t *l, struct HunkAllocator *hunk) {

[2.1341542]

[2.1341606]

void Mod_LoadSurfedges(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 829 [2.1319869]

B:BD[2.1341711] → [2.1341711:1341797]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", loadmodel->name);

[2.1341711]

[2.1341797]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", model->name);

Replacement in quake2/ref_gl/gl_model.c at line 832 [2.1319869]

B:BD[2.1341879] → [2.1341879:1341980]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: bad surfedges count in %s: %i", loadmodel->name, count);

[2.1341879]

[2.1341980]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: bad surfedges count in %s: %i", model->name, count);

Replacement in quake2/ref_gl/gl_model.c at line 836 [2.1319869]

B:BD[2.1342039] → [2.1342039:1342104]

  loadmodel->surfedges = out;
  loadmodel->numsurfedges = count;

[2.1342039]

[2.1342104]

  model->surfedges = out;
  model->numsurfedges = count;

Replacement in quake2/ref_gl/gl_model.c at line 848 [2.1319869]

B:BD[2.1342226] → [2.1342226:1342287]

void Mod_LoadPlanes(lump_t *l, struct HunkAllocator *hunk) {

[2.1342226]

[2.1342287]

void Mod_LoadPlanes(model_t *model, lump_t *l, struct HunkAllocator *hunk) {

Replacement in quake2/ref_gl/gl_model.c at line 857 [2.1319869]

B:BD[2.1342429] → [2.1342429:1342515]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", loadmodel->name);

[2.1342429]

[2.1342515]

    ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s", model->name);

Replacement in quake2/ref_gl/gl_model.c at line 861 [2.1319869]
B:BD[2.1342613] → [2.1342613:1342672]
```
  loadmodel->planes = out;
  loadmodel->numplanes = count;
```
[2.1342613]
[2.1342672]
```
  model->planes = out;
  model->numplanes = count;
```

Replacement in quake2/ref_gl/gl_model.c at line 883 [2.1319869]

B:BD[2.1343042] → [2.1343042:1343124]

void Mod_LoadBrushModel(model_t *mod, struct HunkAllocator *hunk, void *buffer) {

[2.1343042]

[2.1343124]

void Mod_LoadBrushModel(model_t *model, struct HunkAllocator *hunk, void *buffer) {

Replacement in quake2/ref_gl/gl_model.c at line 888 [2.1319869]
B:BD[2.1343171] → [2.1343171:1343203]
```
  // if(loadmodel != mod_known)
```
[2.1343171]
[2.1343203]
```
  // if(model != mod_known)
```

Replacement in quake2/ref_gl/gl_model.c at line 895 [2.1319869]

B:BD[2.1343365] → [2.1343365:1343475]

    ri.Sys_Error(ERR_DROP, "Mod_LoadBrushModel: %s has wrong version number (%i should be %i)", mod->name, i,

[2.1343365]

[2.1343475]

    ri.Sys_Error(ERR_DROP, "Mod_LoadBrushModel: %s has wrong version number (%i should be %i)", model->name, i,

Replacement in quake2/ref_gl/gl_model.c at line 906 [2.1319869]

B:BD[2.1343684] → [2.1343684:1344405]

  Mod_LoadVertexes(&header->lumps[LUMP_VERTEXES], hunk);
  Mod_LoadEdges(&header->lumps[LUMP_EDGES], hunk);
  Mod_LoadSurfedges(&header->lumps[LUMP_SURFEDGES], hunk);
  Mod_LoadLighting(&header->lumps[LUMP_LIGHTING], hunk);
  Mod_LoadPlanes(&header->lumps[LUMP_PLANES], hunk);
  Mod_LoadTexinfo(&header->lumps[LUMP_TEXINFO], hunk);
  Mod_LoadFaces(&header->lumps[LUMP_FACES], hunk);
  Mod_LoadMarksurfaces(&header->lumps[LUMP_LEAFFACES], hunk);
  Mod_LoadVisibility(&header->lumps[LUMP_VISIBILITY], hunk);
  Mod_LoadLeafs(&header->lumps[LUMP_LEAFS], hunk);
  Mod_LoadNodes(&header->lumps[LUMP_NODES], hunk);
  Mod_LoadSubmodels(&header->lumps[LUMP_MODELS], hunk);
  mod->numframes = 2; // regular and alternate animation

[2.1343684]

[2.1344405]

  Mod_LoadVertexes(model, &header->lumps[LUMP_VERTEXES], hunk);
  Mod_LoadEdges(model, &header->lumps[LUMP_EDGES], hunk);
  Mod_LoadSurfedges(model, &header->lumps[LUMP_SURFEDGES], hunk);
  Mod_LoadLighting(model, &header->lumps[LUMP_LIGHTING], hunk);
  Mod_LoadPlanes(model, &header->lumps[LUMP_PLANES], hunk);
  Mod_LoadTexinfo(model, &header->lumps[LUMP_TEXINFO], hunk);
  Mod_LoadFaces(model, &header->lumps[LUMP_FACES], hunk);
  Mod_LoadMarksurfaces(model, &header->lumps[LUMP_LEAFFACES], hunk);
  Mod_LoadVisibility(model, &header->lumps[LUMP_VISIBILITY], hunk);
  Mod_LoadLeafs(model, &header->lumps[LUMP_LEAFS], hunk);
  Mod_LoadNodes(model, &header->lumps[LUMP_NODES], hunk);
  Mod_LoadSubmodels(model, &header->lumps[LUMP_MODELS], hunk);

Replacement in quake2/ref_gl/gl_model.c at line 919 [2.1319869]
B:BD[2.1344406] → [2.1344406:1344437]
```
  loadmodel->type = mod_brush;
```
[2.1344406]
[2.1344437]
```
  model->numframes = 2; // regular and alternate animation
  model->type = mod_brush;
```
Replacement in quake2/ref_gl/gl_model.c at line 925 [2.1319869]
B:BD[2.1344474] → [2.1344474:1344517]
```
  for(i = 0; i < mod->numsubmodels; i++) {
```
[2.1344474]
[2.1344517]
```
  for(i = 0; i < model->numsubmodels; i++) {
```

Replacement in quake2/ref_gl/gl_model.c at line 928 [2.1319869]

B:BD[2.1344540] → [2.1344540:1344624]

    bm = &mod->submodels[i];
    starmod = &mod_inline[loadmodel->cmodel_index][i];

[2.1344540]

[2.1344624]

    bm = &model->submodels[i];
    starmod = &mod_inline[model->cmodel_index][i];

Replacement in quake2/ref_gl/gl_model.c at line 931 [2.1319869]
B:BD[2.1344625] → [2.1344625:1344652]
```
    *starmod = *loadmodel;
```
[2.1344625]
[2.1344652]
```
    *starmod = *model;
```
Replacement in quake2/ref_gl/gl_model.c at line 936 [2.1319869]
B:BD[2.1344786] → [2.1344786:1344836]
```
    if(starmod->firstnode >= loadmodel->numnodes)
```
[2.1344786]
[2.1344836]
```
    if(starmod->firstnode >= model->numnodes)
```
Replacement in quake2/ref_gl/gl_model.c at line 944 [2.1319869]
B:BD[2.1345039] → [2.1345039:1345068]
```
      *loadmodel = *starmod;
```
[2.1345039]
[2.1345068]
```
      *model = *starmod;
```
Replacement in quake2/ref_gl/gl_model.c at line 949 [2.1319869]
B:BD[2.1345112] → [2.1345112:1345153]
```
  r_worldmodel[mod->cmodel_index] = mod;
```
[2.1345112]
[2.1345153]
```
  r_worldmodel[model->cmodel_index] = model;
```
Replacement in quake2/ref_gl/gl_mesh.c at line 154 [2.1353154]
B:BD[2.1358958] → [2.1358958:1358995]
```
void R_DrawAliasModel(entity_t *e) {
```
[2.1358958]
[2.1358995]
```
void R_DrawAliasModel(entity_t *e, model_t *model) {
```

Replacement in quake2/ref_gl/gl_mesh.c at line 219 [2.1353154]

B:BD[2.1361119] → [2.1361119:1361199]

    shadelight = R_LightPoint(r_newrefdef.cmodel_index, currententity->origin);

[2.1361119]

[2.1361199]

    shadelight = R_LightPoint(r_worldmodel[r_newrefdef.cmodel_index], currententity->origin);

Replacement in quake2/ref_gl/gl_mesh.c at line 320 [2.1353154]
B:BD[2.1364118] → [2.1364118:1364155]
```
      skin = currentmodel->skins[0];
```
[2.1364118]
[2.1364155]
```
      skin = model->skins[0];
```
Replacement in quake2/ref_gl/gl_mesh.c at line 322 [2.1353154]
B:BD[2.1364166] → [2.1364166:1364224]
```
      skin = currentmodel->skins[currententity->skinnum];
```
[2.1364166]
[2.1364224]
```
      skin = model->skins[currententity->skinnum];
```
Replacement in quake2/ref_gl/gl_mesh.c at line 324 [2.1353154]
B:BD[2.1364240] → [2.1364240:1364279]
```
        skin = currentmodel->skins[0];
```
[2.1364240]
[2.1364279]
```
        skin = model->skins[0];
```

Replacement in quake2/ref_gl/gl_mesh.c at line 331 [2.1353154]

B:BD[2.1364354] → [2.1364354:1364447]

  const struct RenderMesh *render_mesh = (const struct RenderMesh *)currentmodel->extradata;

[2.1364354]

[2.1364447]

  const struct RenderMesh *render_mesh = (const struct RenderMesh *)model->extradata;

Replacement in quake2/ref_gl/gl_mesh.c at line 334 [2.1353154]

B:BD[2.1364536] → [2.1364536:1364651]

    ri.Con_Printf(PRINT_ALL, "R_DrawAliasModel %s: no such frame %d\n", currentmodel->name, currententity->frame);

[2.1364536]

[2.1364651]

    ri.Con_Printf(PRINT_ALL, "R_DrawAliasModel %s: no such frame %d\n", model->name, currententity->frame);

Replacement in quake2/ref_gl/gl_mesh.c at line 340 [2.1353154]

B:BD[2.1364813] → [2.1364813:1364934]

    ri.Con_Printf(PRINT_ALL, "R_DrawAliasModel %s: no such oldframe %d\n", currentmodel->name, currententity->oldframe);

[2.1364813]

[2.1364934]

    ri.Con_Printf(PRINT_ALL, "R_DrawAliasModel %s: no such oldframe %d\n", model->name, currententity->oldframe);

Replacement in quake2/ref_gl/gl_local.h at line 339 [2.1373560]
B:BD[2.1385360] → [2.1385360:1385390]
```
extern model_t *currentmodel;
```
[2.1385360]
[2.1385390]
```
//extern model_t *currentmodel;
```

Replacement in quake2/ref_gl/gl_local.h at line 432 [2.1373560]

B:BD[2.1387668] → [2.1387668:1387759]

struct SH1 R_LightPoint(int cmodel_index, vec3_t p);
void R_PushDlights(int cmodel_index);

[2.1387668]

[2.1387759]

struct SH1 R_LightPoint(model_t *model, vec3_t p);
void R_PushDlights(model_t *model);

Replacement in quake2/ref_gl/gl_local.h at line 450 [2.1373560]

B:BD[2.1388145] → [2.1388145:1388320]

void R_DrawAliasModel(entity_t *e);
void R_DrawBrushModel(entity_t *e);
void R_DrawSpriteModel(entity_t *e);
void R_DrawBeam(entity_t *e);
void R_DrawWorld(int cmodel_index);

[2.1388145]

[2.1388320]

void R_DrawAliasModel(entity_t *e, model_t *model);
void R_DrawBrushModel(entity_t *e, model_t *model);
void R_DrawSpriteModel(entity_t *e, model_t *model);
void R_DrawBeam(entity_t *e, model_t *model);
void R_DrawWorld(model_t *model);

Replacement in quake2/ref_gl/gl_local.h at line 456 [2.1373560]
B:BD[2.1388348] → [2.1388348:1388380]
```
void R_DrawAlphaSurfaces(void);
```
[2.1388348]
[2.1388380]
```
void R_DrawAlphaSurfaces(model_t *model);
```
Replacement in quake2/ref_gl/gl_local.h at line 463 [2.1373560]
B:BD[2.1388634] → [2.1388634:1388671]
```
void R_MarkLeaves(int cmodel_index);
```
[2.1388634]
[2.1388671]
```
void R_MarkLeaves(model_t *model);
```

Replacement in quake2/ref_gl/gl_local.h at line 470 [2.1373560]

B:BD[2.1388857] → [2.1388857:1388934]

void R_MarkLights(int codel_index, dlight_t *light, int bit, mnode_t *node);

[2.1388857]

[2.1388934]

void R_MarkLights(model_t *model, dlight_t *light, int bit, mnode_t *node);

Replacement in quake2/ref_gl/gl_light.c at line 49 [2.1393042]

B:BD[2.1394282] → [2.1394282:1394361]

void R_MarkLights(int cmodel_index, dlight_t *light, int bit, mnode_t *node) {

[2.1394282]

[2.1394361]

void R_MarkLights(model_t *model, dlight_t *light, int bit, mnode_t *node) {

Replacement in quake2/ref_gl/gl_light.c at line 55 [2.1393042]
B:BD[2.1394429] → [2.1394429:1394481]
```
  if(r_worldmodel[cmodel_index]->type != mod_brush)
```
[2.1394429]
[2.1394481]
```
  if(model->type != mod_brush)
```

Replacement in quake2/ref_gl/gl_light.c at line 65 [2.1393042]

B:BD[2.1394686] → [2.1394686:1394749]

    R_MarkLights(cmodel_index, light, bit, node->children[0]);

[2.1394686]

[2.1394749]

    R_MarkLights(model, light, bit, node->children[0]);

Replacement in quake2/ref_gl/gl_light.c at line 69 [2.1393042]

B:BD[2.1394814] → [2.1394814:1394877]

    R_MarkLights(cmodel_index, light, bit, node->children[1]);

[2.1394814]

[2.1394877]

    R_MarkLights(model, light, bit, node->children[1]);

Replacement in quake2/ref_gl/gl_light.c at line 74 [2.1393042]
B:BD[2.1394917] → [2.1394917:1394985]
```
  surf = r_worldmodel[cmodel_index]->surfaces + node->firstsurface;
```
[2.1394917]
[2.1394985]
```
  surf = model->surfaces + node->firstsurface;
```

Replacement in quake2/ref_gl/gl_light.c at line 83 [2.1393042]

B:BD[2.1395200] → [2.1395200:1395322]

  R_MarkLights(cmodel_index, light, bit, node->children[0]);
  R_MarkLights(cmodel_index, light, bit, node->children[1]);

[2.1395200]

[2.1395322]

  R_MarkLights(model, light, bit, node->children[0]);
  R_MarkLights(model, light, bit, node->children[1]);

Replacement in quake2/ref_gl/gl_light.c at line 92 [2.1393042]
B:BD[2.1395373] → [2.1395373:1395412]
```
void R_PushDlights(int cmodel_index) {
```
[2.1395373]
[2.1395412]
```
void R_PushDlights(model_t *model) {
```

Replacement in quake2/ref_gl/gl_light.c at line 103 [2.1393042]

B:BD[2.1395698] → [2.1395698:1395776]

    R_MarkLights(cmodel_index, l, 1 << i, r_worldmodel[cmodel_index]->nodes);

[2.1395698]

[2.1395776]

    R_MarkLights(model, l, 1 << i, model->nodes);

Replacement in quake2/ref_gl/gl_light.c at line 118 [2.1393042]

B:BD[2.1396047] → [2.1396047:1396132]

int RecursiveLightPoint(int cmodel_index, mnode_t *node, vec3_t start, vec3_t end) {

[2.1396047]

[2.1396132]

int RecursiveLightPoint(model_t *model, mnode_t *node, vec3_t start, vec3_t end) {

Replacement in quake2/ref_gl/gl_light.c at line 143 [2.1393042]

B:BD[2.1396617] → [2.1396617:1396697]

    return RecursiveLightPoint(cmodel_index, node->children[side], start, end);

[2.1396617]

[2.1396697]

    return RecursiveLightPoint(model, node->children[side], start, end);

Replacement in quake2/ref_gl/gl_light.c at line 151 [2.1393042]

B:BD[2.1396906] → [2.1396906:1396981]

  r = RecursiveLightPoint(cmodel_index, node->children[side], start, mid);

[2.1396906]

[2.1396981]

  r = RecursiveLightPoint(model, node->children[side], start, mid);

Replacement in quake2/ref_gl/gl_light.c at line 162 [2.1393042]
B:BD[2.1397178] → [2.1397178:1397246]
```
  surf = r_worldmodel[cmodel_index]->surfaces + node->firstsurface;
```
[2.1397178]
[2.1397246]
```
  surf = model->surfaces + node->firstsurface;
```

Replacement in quake2/ref_gl/gl_light.c at line 204 [2.1393042]

B:BD[2.1398475] → [2.1398475:1398799]

        pointcolor.f[1] += lightmap[0] * scale[0] * (1.0 / 255) * 2.0f - 1.0f;
        pointcolor.f[2] += lightmap[1] * scale[1] * (1.0 / 255) * 2.0f - 1.0f;
        pointcolor.f[3] += lightmap[2] * scale[2] * (1.0 / 255) * 2.0f - 1.0f;
        lightmap += 3 * ((surf->extents[0] >> 4) + 1) * ((surf->extents[1] >> 4) + 1);

[2.1398475]

[2.1398799]

        if(!model->old_lightmap) {
          pointcolor.f[1] += lightmap[0] * scale[0] * (1.0 / 255) * 2.0f - 1.0f;
          pointcolor.f[2] += lightmap[1] * scale[1] * (1.0 / 255) * 2.0f - 1.0f;
          pointcolor.f[3] += lightmap[2] * scale[2] * (1.0 / 255) * 2.0f - 1.0f;
          lightmap += 3 * ((surf->extents[0] >> 4) + 1) * ((surf->extents[1] >> 4) + 1);

Replacement in quake2/ref_gl/gl_light.c at line 210 [2.1393042]

B:BD[2.1398800] → [2.1398800:1399124]

        pointcolor.f[5] += lightmap[0] * scale[0] * (1.0 / 255) * 2.0f - 1.0f;
        pointcolor.f[6] += lightmap[1] * scale[1] * (1.0 / 255) * 2.0f - 1.0f;
        pointcolor.f[7] += lightmap[2] * scale[2] * (1.0 / 255) * 2.0f - 1.0f;
        lightmap += 3 * ((surf->extents[0] >> 4) + 1) * ((surf->extents[1] >> 4) + 1);

[2.1398800]

[2.1399124]

          pointcolor.f[5] += lightmap[0] * scale[0] * (1.0 / 255) * 2.0f - 1.0f;
          pointcolor.f[6] += lightmap[1] * scale[1] * (1.0 / 255) * 2.0f - 1.0f;
          pointcolor.f[7] += lightmap[2] * scale[2] * (1.0 / 255) * 2.0f - 1.0f;
          lightmap += 3 * ((surf->extents[0] >> 4) + 1) * ((surf->extents[1] >> 4) + 1);

Replacement in quake2/ref_gl/gl_light.c at line 215 [2.1393042]

B:BD[2.1399125] → [2.1399125:1399457]

        pointcolor.f[9] += (lightmap[0] * scale[0] * (1.0 / 255)) * 2.0f - 1.0f;
        pointcolor.f[10] += (lightmap[1] * scale[1] * (1.0 / 255)) * 2.0f - 1.0f;
        pointcolor.f[11] += (lightmap[2] * scale[2] * (1.0 / 255)) * 2.0f - 1.0f;
        lightmap += 3 * ((surf->extents[0] >> 4) + 1) * ((surf->extents[1] >> 4) + 1);

[2.1399125]

[2.1399457]

          pointcolor.f[9] += (lightmap[0] * scale[0] * (1.0 / 255)) * 2.0f - 1.0f;
          pointcolor.f[10] += (lightmap[1] * scale[1] * (1.0 / 255)) * 2.0f - 1.0f;
          pointcolor.f[11] += (lightmap[2] * scale[2] * (1.0 / 255)) * 2.0f - 1.0f;
          lightmap += 3 * ((surf->extents[0] >> 4) + 1) * ((surf->extents[1] >> 4) + 1);
        }

Replacement in quake2/ref_gl/gl_light.c at line 227 [2.1393042]

B:BD[2.1399514] → [2.1399514:1399591]

  return RecursiveLightPoint(cmodel_index, node->children[!side], mid, end);

[2.1399514]

[2.1399591]

  return RecursiveLightPoint(model, node->children[!side], mid, end);

Replacement in quake2/ref_gl/gl_light.c at line 235 [2.1393042]
B:BD[2.1399645] → [2.1399645:1399699]
```
struct SH1 R_LightPoint(int cmodel_index, vec3_t p) {
```
[2.1399645]
[2.1399699]
```
struct SH1 R_LightPoint(model_t *model, vec3_t p) {
```
Replacement in quake2/ref_gl/gl_light.c at line 244 [2.1393042]
B:BD[2.1399801] → [2.1399801:1399848]
```
  if(!r_worldmodel[cmodel_index]->lightdata) {
```
[2.1399801]
[2.1399848]
```
  if(!model->lightdata) {
```

Replacement in quake2/ref_gl/gl_light.c at line 252 [2.1393042]

B:BD[2.1399982] → [2.1399982:1400066]

  r = RecursiveLightPoint(cmodel_index, r_worldmodel[cmodel_index]->nodes, p, end);

[2.1399982]

[2.1400066]

  r = RecursiveLightPoint(model, model->nodes, p, end);

Replacement in quake2/ref_gl/gl_light.c at line 358 [2.1393042]
B:BD[2.1402612] → [2.1402612:1402653]
```
void R_SetCacheState(msurface_t *surf) {
```
[2.1402612]
[2.1402653]
```
void R_SetCacheState(model_t *model, msurface_t *surf) {
```

Replacement in quake2/ref_gl/gl_light.c at line 373 [2.1393042]

B:BD[2.1402963] → [2.1402963:1403078]

void R_BuildLightMap(msurface_t *surf, byte *dest_rgb0, byte *dest_r1, byte *dest_g1, byte *dest_b1, int stride) {

[2.1402963]

[2.1403078]

void R_BuildLightMap(model_t *model, msurface_t *surf, byte *dest_rgb0, byte *dest_r1, byte *dest_g1, byte *dest_b1, int stride) {

Replacement in quake2/ref_gl/gl_light.c at line 412 [2.1393042]

B:BD[2.1404292] → [2.1404292:1404486]

  lightmap_rgb0 = surf->samples + (size * 3) * 0;
  lightmap_r1 = surf->samples + (size * 3) * 1;
  lightmap_g1 = surf->samples + (size * 3) * 2;
  lightmap_b1 = surf->samples + (size * 3) * 3;

[2.1404292]

[2.1404486]

  int newsize = model->old_lightmap ? 0 : size * 3;
  int newstride = model->old_lightmap ? 1 : 4;
  float newscale = model->old_lightmap ? 0.0f : 1.0f;

Insertion in quake2/ref_gl/gl_light.c at line 416 [2.1393042]

[2.1404487]

  lightmap_rgb0 = surf->samples + newsize * 0;
  lightmap_r1 = surf->samples + newsize * 1;
  lightmap_g1 = surf->samples + newsize * 2;
  lightmap_b1 = surf->samples + newsize * 3;

Insertion in quake2/ref_gl/gl_light.c at line 453 [2.1393042]

[2.1405716]


        color.f[1] *= newscale;
        color.f[2] *= newscale;
        color.f[3] *= newscale;
        color.f[5] *= newscale;
        color.f[6] *= newscale;
        color.f[7] *= newscale;
        color.f[9] *= newscale;
        color.f[10] *= newscale;
        color.f[11] *= newscale;

Replacement in quake2/ref_gl/gl_light.c at line 468 [2.1393042]

B:BD[2.1405803] → [2.1405803:1405945]

      lightmap_rgb0 += size * 3 * 4;
      lightmap_r1 += size * 3 * 4;
      lightmap_g1 += size * 3 * 4;
      lightmap_b1 += size * 3 * 4;

[2.1405803]

[2.1405945]

      lightmap_rgb0 += size * 3 * newstride;
      lightmap_r1 += size * 3 * newstride;
      lightmap_g1 += size * 3 * newstride;
      lightmap_b1 += size * 3 * newstride;

Insertion in quake2/ref_gl/gl_light.c at line 506 [2.1393042]

[2.1407207]


        color.f[1] *= newscale;
        color.f[2] *= newscale;
        color.f[3] *= newscale;
        color.f[5] *= newscale;
        color.f[6] *= newscale;
        color.f[7] *= newscale;
        color.f[9] *= newscale;
        color.f[10] *= newscale;
        color.f[11] *= newscale;

Insertion in quake2/ref_gl/gl_light.c at line 520 [2.1393042]
[2.1407268]
[2.1407268]

Replacement in quake2/ref_gl/gl_light.c at line 522 [2.1393042]

B:BD[2.1407297] → [2.1407297:1407431]

    lightmap_rgb0 += size * 3 * 4;
    lightmap_r1 += size * 3 * 4;
    lightmap_g1 += size * 3 * 4;
    lightmap_b1 += size * 3 * 4;

[2.1407297]

[2.1407431]

    lightmap_rgb0 += size * 3 * newstride;
    lightmap_r1 += size * 3 * newstride;
    lightmap_g1 += size * 3 * newstride;
    lightmap_b1 += size * 3 * newstride;

Insertion in quake2/ref_gl/gl_compute.c at line 10 [2.1453550]
[2.1453855]
[2.1453855]
```
  flag(SUBGROUP_ARITHMETIC),
```
Insertion in quake2/ref_gl/gl_compute.c at line 60 [2.1453550]
[2.1455079]
[2.1455079]
```
  flag(ARITHMETIC_INT64),
```

A lot of fixes for Quake2. Can have shaders without some extensions now. known bugs: mouse input not grabbed, not reading lightmap for entities, particles are broken.

Dependencies

In channels

Change contents

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 10 [2.1128210]

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 17 [2.1128210]

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 23 [2.1128210]

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 32 [2.1128210]

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 39 [2.1128210]

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 47 [2.1128210]

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 54 [2.1128210]

Insertion in quake2/ref_gl/gl_thin_cpp.h at line 62 [2.1128210]

Replacement in quake2/ref_gl/gl_thin_cpp.h at line 207 [2.1128210]

Replacement in quake2/ref_gl/gl_thin_cpp.h at line 292 [2.1128210]

Insertion in quake2/ref_gl/gl_thin.h at line 23 [2.1147603]

Insertion in quake2/ref_gl/gl_thin.h at line 169 [2.1147603]

Insertion in quake2/ref_gl/gl_thin.h at line 180 [2.1147603]

Deletion in quake2/ref_gl/gl_thin.c at line 13 [2.1166326]

Insertion in quake2/ref_gl/gl_thin.c at line 121 [2.1166326]

Insertion in quake2/ref_gl/gl_thin.c at line 143 [2.1166326]

Replacement in quake2/ref_gl/gl_thin.c at line 323 [2.1166326]

Replacement in quake2/ref_gl/gl_thin.c at line 339 [2.1166326]

Replacement in quake2/ref_gl/gl_thin.c at line 966 [2.1166326]

Insertion in quake2/ref_gl/gl_thin.c at line 987 [2.1166326]

Replacement in quake2/ref_gl/gl_sprite.c at line 55 [2.1203127]

Replacement in quake2/ref_gl/gl_sprite.c at line 64 [2.1203127]

Replacement in quake2/ref_gl/gl_sprite.c at line 103 [2.1203127]

Replacement in quake2/ref_gl/gl_rsurf.c at line 30 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 70 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 272 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 311 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 314 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 333 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 335 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 374 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 377 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 382 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 385 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 393 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 404 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 408 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 415 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 425 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 428 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 439 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 444 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 452 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 457 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 485 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 501 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 568 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 571 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 580 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 583 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 588 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 596 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 605 [2.1211734]

Deletion in quake2/ref_gl/gl_rsurf.c at line 608 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 619 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 623 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 636 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 656 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 658 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 665 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 668 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 676 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 771 [2.1211734]

Replacement in quake2/ref_gl/gl_rsurf.c at line 803 [2.1211734]

Replacement in quake2/ref_gl/gl_rmain.c at line 31 [2.1246349]

Deletion in quake2/ref_gl/gl_rmain.c at line 101 [2.1246349]

Replacement in quake2/ref_gl/gl_rmain.c at line 241 [2.1246349]

Replacement in quake2/ref_gl/gl_rmain.c at line 246 [2.1246349]

Replacement in quake2/ref_gl/gl_rmain.c at line 248 [2.1246349]

Replacement in quake2/ref_gl/gl_rmain.c at line 251 [2.1246349]

Replacement in quake2/ref_gl/gl_rmain.c at line 254 [2.1246349]

Replacement in quake2/ref_gl/gl_rmain.c at line 274 [2.1246349]

Replacement in quake2/ref_gl/gl_rmain.c at line 276 [2.1246349]

Replacement in quake2/ref_gl/gl_rmain.c at line 280 [2.1246349]

Replacement in quake2/ref_gl/gl_rmain.c at line 282 [2.1246349]

Replacement in quake2/ref_gl/gl_rmain.c at line 285 [2.1246349]