C++ (Cpp) AddToVertex Examples

Example #1

File: gl_setup.cpp Project: MajorCooke/GZDoom

static void InitVertexData()
{
    TArray<int> * vt_sectorlists;

    int i,j,k;

    vt_sectorlists = new TArray<int>[numvertexes];


    for(i=0; i<numlines; i++)
    {
        line_t * line = &lines[i];

        for(j=0; j<2; j++)
        {
            vertex_t * v = j==0? line->v1 : line->v2;

            for(k=0; k<2; k++)
            {
                sector_t * sec = k==0? line->frontsector : line->backsector;

                if (sec)
                {
                    extsector_t::xfloor &x = sec->e->XFloor;

                    AddToVertex(sec, vt_sectorlists[v-vertexes]);
                    if (sec->heightsec) AddToVertex(sec->heightsec, vt_sectorlists[v-vertexes]);
                }
            }
        }
    }

    for(i=0; i<numvertexes; i++)
    {
        int cnt = vt_sectorlists[i].Size();

        vertexes[i].dirty = true;
        vertexes[i].numheights=0;
        if (cnt>1)
        {
            vertexes[i].numsectors= cnt;
            vertexes[i].sectors=new sector_t*[cnt];
            vertexes[i].heightlist = new float[cnt*2];
            for(int j=0; j<cnt; j++)
            {
                vertexes[i].sectors[j] = &sectors[vt_sectorlists[i][j]];
            }
        }
        else
        {
            vertexes[i].numsectors=0;
        }
    }

    delete [] vt_sectorlists;
}

Example #2

File: gl_vertex.c Project: Mistranger/prboom-plus

//==========================================================================
//
// 
//
//==========================================================================
void gld_InitVertexData()
{
  int i, j, k;
  int vertexes_count, gl_vertexsplit_size, pos;
  int ** vt_sectorlists;
  unsigned int * vt_sectorlists_size;

  if (gl_vertexsplit)
    return;

  vt_sectorlists = calloc(sizeof(vt_sectorlists[0]), numvertexes);
  vt_sectorlists_size = calloc(sizeof(vt_sectorlists_size[0]), numvertexes);

  for(i = 0; i < numlines; i++)
  {
    line_t *line = &lines[i];

    for(j = 0; j < 2; j++)
    {
      vertex_t *v = (j==0 ? line->v1 : line->v2);

      for(k = 0; k < 2; k++)
      {
        sector_t *sec = (k == 0 ? line->frontsector : line->backsector);

        if (sec)
        {
          AddToVertex(sec, &vt_sectorlists[v-vertexes], &vt_sectorlists_size[v-vertexes]);
          if (sec->heightsec >= 0)
          {
            AddToVertex(&sectors[sec->heightsec], &vt_sectorlists[v-vertexes], &vt_sectorlists_size[v-vertexes]);
          }
        }
      }
    }
  }

  vertexes_count = 0;
  for(i = 0; i < numvertexes; i++)
  {
    if (vt_sectorlists_size[i] > 1)
    {
      vertexes_count += vt_sectorlists_size[i];
    }
  }

  gl_vertexsplit_size =
    numvertexes * sizeof(vertexsplit_info_t) +
    vertexes_count * sizeof(gl_vertexsplit->sectors[0]) +
    2 * vertexes_count * sizeof(gl_vertexsplit->heightlist[0]);

  gl_vertexsplit = malloc(gl_vertexsplit_size);
  memset(gl_vertexsplit, 0, gl_vertexsplit_size);

  pos = numvertexes * sizeof(vertexsplit_info_t);
  for(i = 0; i < numvertexes; i++)
  {
    int cnt = vt_sectorlists_size[i];
    vertexsplit_info_t *vi = &gl_vertexsplit[i];

    vi->validcount = -1;
    vi->numheights = 0;
    if (cnt > 1)
    {
      vi->changed = true;
      vi->numsectors = cnt;

      vi->sectors = (sector_t **)((unsigned char*)gl_vertexsplit + pos);
      pos += sizeof(vi->sectors[0]) * cnt;
      vi->heightlist = (float *)((unsigned char*)gl_vertexsplit + pos);
      pos += sizeof(vi->heightlist[0]) * cnt * 2;

      for(j = 0; j < cnt; j++)
      {
        vi->sectors[j] = &sectors[vt_sectorlists[i][j]];
      }
    }
    else
    {
      vi->numsectors=0;
    }
  }

  gl_splitsbysector = malloc(sizeof(gl_splitsbysector[0]) * numsectors);
  memset(gl_splitsbysector, 0, sizeof(gl_splitsbysector[0]) * numsectors);

  for(i = 0; i < numsectors; i++)
  {
    for(j = 0; j < numvertexes; j++)
    {
      vertexsplit_info_t *vi = &gl_vertexsplit[j];

      for(k = 0; k < vi->numsectors; k++)
      {
        if (vi->sectors[k] == &sectors[i])
          AddToSplitBySector(vi, &gl_splitsbysector[i]);
      }
    }
  }

  for(i = 0; i < numvertexes; i++)
    gld_RecalcVertexHeights(&vertexes[i]);

  free(vt_sectorlists);
  free(vt_sectorlists_size);
}