Exemplo n.º 1
0
static void
start_wm(void *userData, const char *name, const char **atts)
{
  int post_ns = 0;
  if ((post_ns = is_ns(name,xcl_ns_uri)))
    {
      if (!strcmp(name+post_ns,"l"))
	{
	  wm_lineword(findAttr(atts, "ref"));
	  wm_unitlemm(xml_id(atts));
	  unit_map_entry();
	}
    }
  else if ((post_ns = is_ns(name,xtf_ns_uri)))
    {
      name = name + post_ns;
      if (!strcmp(name,"w"))
	{
	  wm_lineword(xml_id(atts));
	  kwic_map_entry();
	}
    }
  else if ((post_ns = is_ns(name,norm_ns_uri)))
    {
      name = name + post_ns;
      if (!strcmp(name,"w"))
	{
	  wm_lineword(xml_id(atts));
	  kwic_map_entry();
	}
    }
  charData_discard();
}
Exemplo n.º 2
0
const char *
get_xml_id(const char **atts)
{
  /*Different versions of the expat library handle the xml: prefix differently :( */
  /*And now Oracc harvest uses '|' for the delimiter not :, :(( */
  static const char *xml_id1 = "xml:id";
  static const char *xml_id2 = "http://www.w3.org/XML/1998/namespace:id";
  static const char *xml_id3 = "xml|id";
  static const char *xml_id4 = "http://www.w3.org/XML/1998/namespace|id";
  const char *x = findAttr(atts,xml_id1);
  if (!*x)
    x = findAttr(atts,xml_id2);
  if (!*x)
    x = findAttr(atts,xml_id3);
  if (!*x)
    x = findAttr(atts,xml_id4);
  return x;
}
Exemplo n.º 3
0
void Cities::readFromXMLFile(const std::string &filename) {
  auto xr = XmlReader::FromFile(filename);
  if (!xr) {
    Server::debug()("Failed to load data from " + filename, Color::CHAT_ERROR);
    return;
  }
  for (auto elem : xr.getChildren("city")) {
    City::Name name;
    if (!xr.findAttr(elem, "name", name)) continue;
    createCity(name);
    City &city = _container[name];
    for (auto memberElem : xr.getChildren("member", elem)) {
      std::string username;
      if (!xr.findAttr(memberElem, "username", username)) continue;
      city.addPlayerWithoutAlerting(username);
      _usersToCities[username] = name;
    }
  }
}
Exemplo n.º 4
0
void TerrainType::load(Container &container, const std::string &filename) {
  auto xr = XmlReader::FromFile(filename);

  for (auto elem : xr.getChildren("terrain")) {
    auto t = TerrainType{};

    xr.findAttr(elem, "index", t.index);
    xr.findAttr(elem, "id", t.id);
    xr.findAttr(elem, "color", t.color);

    auto numFrames = 1;
    xr.findAttr(elem, "frames", numFrames);
    auto filename = t.id;
    if (numFrames > 1) filename += "00";
    t.image = {"../../Images/Terrain/" + filename + ".png"};

    container[t.index] = t;
  }
}
Exemplo n.º 5
0
/* 
 * INDEXING CODE 
 */
static void
startElement(void *userData, const char *name, const char **atts)
{
  const char *curr_id = NULL;
  if (!strcmp(name,"o:record"))
    {
      curr_id = findAttr(atts, "xml:id");
      vid_new_id(vidp, curr_id);
      fprintf(pqidsf,"%s\n",curr_id);
      loc8(vid_map_id(vidp,curr_id), 0, lang_mask(atts), &l8);
      indexing = 1;
    }
}
Exemplo n.º 6
0
/* 
 * INDEXING CODE 
 */
static void
startElement(void *userData, const char *name, const char **atts)
{
  const char *curr_text_pq, *curr_text_proj;
  if (!strcmp(name,"xmd"/*"key"*/))
    {
      curr_text_pq = findAttr(atts, "xml:id");
      if (l2)
	{
	  static char qualified_id[128];
	  curr_text_proj = findAttr(atts, "project");
	  sprintf(qualified_id, "%s:%s", curr_text_proj, curr_text_pq);	  
	  fprintf(pqidsf,"%s\n",qualified_id);
	  loc8(vid_map_id(vidp,qualified_id), 0, lang_mask(atts), &l8);
	}
      else
	{
	  fprintf(pqidsf,"%s\n",curr_text_pq);
	  loc8(curr_text_pq, 0, lang_mask(atts), &l8);
	}
      indexing = 1;
    }
}
Exemplo n.º 7
0
Arquivo: xfrag.c Projeto: oracc/oracc
void
gdf_sH(void *userData, const char *name, const char **atts)
{
  const char *xid = (htmlid ? findAttr(atts, "id") : get_xml_id(atts));

  if (unwrap_html)
    {
      if (cued_printStart)
	{
	  cued_printStart = 0;
	  printStart(userData, name, atts);
	}
      else if (!strcmp(name, "body"))
	{
	  charData_discard();
	  cued_printStart = 1;
	}
      else if (((struct frag*)userData)->nesting)
	printStart(userData, name, atts);
      else
	charData_discard();
    }
  else if (xid && !strcmp(((struct frag*)userData)->xid, xid))
    {
      charData_discard();
      printStart(userData, name, atts);
    }
  else if (((struct frag*)userData)->nesting)
    printStart(userData, name, atts);
  else if (!strcmp(name, "o:records"))
    {
      printStart(userData, "o:records", atts);
      need_gdf_closer = 1;
      ((struct frag*)userData)->nesting = 0;
    }
  else if (html_mode && !strcmp(name, "head"))
    {
      fputs("<html xmlns=\"http://www.w3.org/1999/xhtml\">", 
	    ((struct frag*)userData)->fp);
      printStart(userData, name, atts);
    }
  else
    charData_discard();
}
Exemplo n.º 8
0
static void
sH(void *userData, const char *name, const char **atts)
{
  
  if (name[22] == 'f'
      && (!strcmp(name, "http://oracc.org/ns/xtf/1.0:transliteration")
	  || !strcmp(name, "http://oracc.org/ns/xtf/1.0:composite")))
    {
      strcpy(curr_project, findAttr(atts,"project"));
      strcpy(curr_text_id, get_xml_id(atts));
    }
  else
    {
      const char *utf8 = findAttr(atts,"http://oracc.org/ns/gdl/1.0:utf8");
      if (*utf8)
	{
	  static wchar_t wbuf[128];
	  static size_t n, i;
	  char sbuf[512], xbuf[1024], *hex;
	  unsigned char *sn = NULL;
	  const char *form = NULL;

	  if (*(const unsigned char *)utf8 > 127)
	    {
	      n = mbstowcs(wbuf,utf8,128);
	      hex = malloc(n * 8);
	      *hex = '\0';
	      for (i = 0; i < n; ++i)
		{
		  if (i)
		    strcat(hex, ".");
		  sprintf(hex+strlen(hex),"x%05X",wbuf[i]);
		}
	    }
	  else
	    {
	      hex = strdup(utf8);
	    }
	  if (!(sn = psl_hex_to_sign(hex)))
	    sn = (unsigned char *)hex;
	  sprintf(sbuf,"%s:%s",hex,sn);
	  sprintf(xbuf,"%s:%s:%s:%s",curr_project,curr_text_id,hex,sn);
	  free(hex);
	  
	  if (!(curr_sig_hash = hash_find(signiary,(unsigned char*)sbuf)))
	    {
	      curr_sig_hash = hash_create(1);
	      hash_add(signiary,npool_copy((unsigned char*)sbuf,sig_pool),curr_sig_hash);
	    }
	  incr_val(curr_sig_hash, (const unsigned char *)"#count");
	  ++total_sign_instances;

	  if (!(curr_hash = hash_find(pertext,(unsigned char*)xbuf)))
	    {
	      curr_hash = hash_create(1);
	      hash_add(pertext,npool_copy((unsigned char*)xbuf,sig_pool),curr_hash);
	    }
	  incr_val(curr_hash, (const unsigned char *)"#count");

	  form = findAttr(atts, "form");
	  if (form && *form)
	    {
	      incr_val(curr_sig_hash, (const unsigned char *)form);
	      incr_val(curr_hash, (const unsigned char *)form);
	      curr_sig_hash = curr_hash = NULL;
	    }
	}
    }
}
Exemplo n.º 9
0
DrawCount PointArray::drawPoints(QGLShaderProgram& prog, const TransformState& transState,
                                 double quality, bool incrementalDraw) const
{
    TransformState relativeTrans = transState.translate(offset());
    relativeTrans.setUniforms(prog.programId());
    //printActiveShaderAttributes(prog.programId());
    std::vector<ShaderAttribute> activeAttrs = activeShaderAttributes(prog.programId());
    // Figure out shader locations for each point field
    // TODO: attributeLocation() forces the OpenGL usage here to be
    // synchronous.  Does this matter?  (Alternative: bind them ourselves.)
    std::vector<const ShaderAttribute*> attributes;
    for (size_t i = 0; i < m_fields.size(); ++i)
    {
        const GeomField& field = m_fields[i];
        if (field.spec.isArray())
        {
            for (int j = 0; j < field.spec.count; ++j)
            {
                std::string name = tfm::format("%s[%d]", field.name, j);
                attributes.push_back(findAttr(name, activeAttrs));
            }
        }
        else
        {
            attributes.push_back(findAttr(field.name, activeAttrs));
        }
    }
    // Zero out active attributes in case they don't have associated fields
    GLfloat zeros[16] = {0};
    for (size_t i = 0; i < activeAttrs.size(); ++i)
    {
        prog.setAttributeValue((int)i, zeros, activeAttrs[i].rows,
                               activeAttrs[i].cols);
    }
    // Enable attributes which have associated fields
    for (size_t i = 0; i < attributes.size(); ++i)
    {
        if (attributes[i])
            prog.enableAttributeArray(attributes[i]->location);
    }

    DrawCount drawCount;
    ClipBox clipBox(relativeTrans);

    // Draw points in each bucket, with total number drawn depending on how far
    // away the bucket is.  Since the points are shuffled, this corresponds to
    // a stochastic simplification of the full point cloud.
    V3f relCamera = relativeTrans.cameraPos();
    std::vector<const OctreeNode*> nodeStack;
    nodeStack.push_back(m_rootNode.get());
    while (!nodeStack.empty())
    {
        const OctreeNode* node = nodeStack.back();
        nodeStack.pop_back();
        if (clipBox.canCull(node->bbox))
            continue;
        if (!node->isLeaf())
        {
            for (int i = 0; i < 8; ++i)
            {
                OctreeNode* n = node->children[i];
                if (n)
                    nodeStack.push_back(n);
            }
            continue;
        }
        size_t idx = node->beginIndex;
        if (!incrementalDraw)
            node->nextBeginIndex = node->beginIndex;

        DrawCount nodeDrawCount = node->drawCount(relCamera, quality, incrementalDraw);
        drawCount += nodeDrawCount;

        idx = node->nextBeginIndex;
        if (nodeDrawCount.numVertices == 0)
            continue;
        for (size_t i = 0, k = 0; i < m_fields.size(); k+=m_fields[i].spec.arraySize(), ++i)
        {
            const GeomField& field = m_fields[i];
            int arraySize = field.spec.arraySize();
            int vecSize = field.spec.vectorSize();
            for (int j = 0; j < arraySize; ++j)
            {
                const ShaderAttribute* attr = attributes[k+j];
                if (!attr)
                    continue;
                char* data = field.data.get() + idx*field.spec.size() +
                             j*field.spec.elsize;
                if (attr->baseType == TypeSpec::Int || attr->baseType == TypeSpec::Uint)
                {
                    glVertexAttribIPointer(attr->location, vecSize,
                                           glBaseType(field.spec), 0, data);
                }
                else
                {
                    glVertexAttribPointer(attr->location, vecSize,
                                          glBaseType(field.spec),
                                          field.spec.fixedPoint, 0, data);
                }
            }
        }
        glDrawArrays(GL_POINTS, 0, (GLsizei)nodeDrawCount.numVertices);
        node->nextBeginIndex += nodeDrawCount.numVertices;
    }
    //tfm::printf("Drew %d of total points %d, quality %f\n", totDraw, m_npoints, quality);

    // Disable all attribute arrays - leaving these enabled seems to screw with
    // the OpenGL fixed function pipeline in unusual ways.
    for (size_t i = 0; i < attributes.size(); ++i)
    {
        if (attributes[i])
            prog.disableAttributeArray(attributes[i]->location);
    }
    return drawCount;
}
Exemplo n.º 10
0
static void
loc_project(const char **atts)
{
  strcpy(loc_project_buf, findAttr(atts, "project"));
}
Exemplo n.º 11
0
 __INLINE bool
 ElementRef::hasAttr (KeyId keyId)
 {
     return (bool) findAttr(keyId);
 }
Exemplo n.º 12
0
static void
xcl_sH(void *userData, const char *name, const char **atts)
{
  static struct ilem_form *curr_form = NULL;
  const char *vbar = strchr(name,EXPAT_NS_CHAR);
  struct xcl_context *xcp = userData;

  if (!strncmp("http://oracc.org/ns/xcl/1.0",name,vbar-name))
    {
      curr_lnum = atoi(findAttr(atts,"lnum"));
      ++vbar;
      if (vbar[0] == 'l')
	{
	  if (!vbar[1])
	    {
	      curr_xml_id = xpool_copy(findAttr(atts,"xml:id"),xcp->pool);
	      curr_inst = xpool_copy(findAttr(atts,"inst"),xcp->pool);
	      curr_ref = findAttr(atts,"ref");
	      if (*curr_ref)
		curr_ref = xpool_copy(curr_ref,xcp->pool);
	      curr_sig = xpool_copy(findAttr(atts,"sig"),xcp->pool);
	    }
	  else if (vbar[1] == 'l' && !vbar[2])
	    {
	      in_ll = 1;
	    }
	  else if (!strcmp(vbar,"linkset"))
	    {
	    }
	  else if (!strcmp(vbar,"link"))
	    {
	    }
	}
      else if (!strcmp(vbar, "xcl"))
	{
	  xcp->project = xpool_copy(findAttr(atts,"project"),xcp->pool);
	  xcp->linkbase->textid = xcp->textid = xpool_copy(findAttr(atts,"textid"),xcp->pool);
	  xcp->file = xpool_copy(findAttr(atts,"file"),xcp->pool);
	  xcp->langs = xpool_copy(findAttr(atts,"langs"),xcp->pool);
	}
      else if (!strcmp(vbar, "c"))
	{
	  const char *strtok = findAttr(atts, "type");
	  struct xcl_tok_tab *ttp = xcltok(strtok,strlen(strtok));
	  if (ttp && ttp->node_type == xcl_node_c)
	    xcl_chunk(xcp, findAttr(atts, "xml:id"), ttp->subtype);
	  else
	    fprintf(stderr,"unknown xcl chunk token type '%s'\n",strtok);
	}
      else if (!strcmp(vbar, "psu"))
	psu_lang = findAttr(atts,"lang");
      else if (!strcmp(vbar, "d"))
	{
	  const char *strtok = findAttr(atts, "type");
	  struct xcl_tok_tab *ttp = xcltok(strtok,strlen(strtok));
	  if (ttp && ttp->node_type == xcl_node_d)
	    {
	      xcl_discontinuity(xcp, 
				xpool_copy(findAttr(atts,"ref"),xcp->pool),
				ttp->subtype,
				NULL);
	    }
	  else
	    fprintf(stderr,"unknown xcl discontinuity token type '%s'\n",strtok);
	}
      else if (!strcmp(vbar,"mds"))
	curr_meta = xcl_create_meta(xcp,(const char*)npool_copy((unsigned char *)get_xml_id(atts),
								xcp->pool));
      else if (!strcmp(vbar,"m"))
	next_k = findAttr(atts,"k");
      else if (!strcmp(vbar, "multi"))
	{
	  in_multi = 1;
	}      
      else if (!strcmp(vbar, "prop"))
	{
	  if (curr_form)
	    {
	      props_add_prop(curr_form,
			     uxpool_copy(findAttr(atts,"group"),xcp->pool),
			     uxpool_copy(findAttr(atts,"name"),xcp->pool),
			     uxpool_copy(findAttr(atts,"value"),xcp->pool),
			     xpool_copy(findAttr(atts,"ref"),xcp->pool),
			     xpool_copy(findAttr(atts,"xml:id"),xcp->pool),
			     xpool_copy(findAttr(atts,"p"),xcp->pool),
			     atoi(findAttr(atts,"ngram")));
	    }
	  else
	    {
	      fprintf(stderr,"xff loader: invalid XML: found prop outside form\n");
	      return;	  
	    }
	}
    }
}
Exemplo n.º 13
0
static void
sH(void *userData, const char *name, const char **atts)
{
  charData_discard();
  if (!strcmp(name,"system"))
    {
      const char *det;
      const char *mev;
      char *endll;
      mev = findAttr(atts,"mev");
      curr_system = new_system();
      curr_system->n = (const char *)npool_copy((unsigned char *)findAttr(atts,"n"),context->cpool);
      curr_system->mev = new_count();
      curr_system->mev->num = strtoll(mev,&endll,10);
      curr_system->mev->den = (int)strtol(endll+1,&endll,10);
      curr_system->meu = (char *)npool_copy((unsigned char *)endll,
					    context->cpool);
      hash_add(context->systems,
	       (const unsigned char *)curr_system->n,curr_system);
      if ((det = findAttr(atts,"det")))
	hash_add(context->sysdets,
		 npool_copy((unsigned char*)det,context->cpool),
		 curr_system);
    }
  else if (!strcmp(name,"step"))
    {
      struct nsa_step *curr_step = new_step();
      const char *overt = findAttr(atts,"overt");
      const char *aev = findAttr(atts,"aev");
      const char *sex = findAttr(atts,"sex");
      char *slash;
      int overt_star;

      curr_step->ecf = (const char *)npool_copy((unsigned char *)findAttr(atts,"ecf"),context->cpool);
      curr_step->etr = (const char *)npool_copy((unsigned char *)findAttr(atts,"etr"),context->cpool);
      curr_step->atf = (const char *)npool_copy((unsigned char *)findAttr(atts,"atf"),context->cpool);
      curr_step->utf = (const char *)npool_copy((unsigned char *)findAttr(atts,"utf"),context->cpool);
      if (sex && *sex == 'a') /* horrible cheat! */
	curr_step->sex = nsa_sex_asz_axis;
      curr_step->sys = curr_system;
      list_add(curr_system->steps,curr_step);
      if (aev && *aev)
	{
	  curr_step->aev = new_count();
	  slash = strchr(aev,'/');
	  if (!slash)
	    {
	      fprintf(stderr,"nsa: system %s/step %s: bad AEV (should be n/1; actual='%s')\n",curr_system->n,curr_step->atf,aev);
	      curr_step->aev->num = 0;
	      curr_step->aev->den = 1;
	    }
	  else
	    {
	      curr_step->aev->num = strtoll(aev,NULL,10);
	      curr_step->aev->den = (int)strtol(slash+1,NULL,10);
	    }
	}
      curr_step->node = curr_system->steps->last;
      curr_step->sys = curr_system;
      if (!overt || !*overt || strcmp(overt,"no"))
	overt_star = 0;
      else
	overt_star = 1;
      /*	  sH_index_step(curr_step->ecf, curr_step); */
      /* sH_index_step(curr_step->etr, curr_step); */
      sH_index_step(curr_step->utf, curr_step, overt_star);
      if (curr_step->atf && strcmp(curr_step->utf,curr_step->atf))
	sH_index_step(curr_step->atf, curr_step, overt_star);
    }
  else if (!strcmp(name,"ok-com-heads"))
    {
      curr_comhead_sys = (const char *)npool_copy((unsigned char *)findAttr(atts,"sys"),context->cpool);
    }
  else if (!strcmp(name,"igi"))
    last_u = (char *)npool_copy((unsigned char *)findAttr(atts,"u"),context->cpool);
}
Exemplo n.º 14
0
DrawCount PointArray::drawPoints(QGLShaderProgram& prog, const TransformState& transState,
                                 double quality, bool incrementalDraw) const
{
    GLuint vao = getVAO("points");
    glBindVertexArray(vao);

    GLuint vbo = getVBO("point_buffer");
    glBindBuffer(GL_ARRAY_BUFFER, vbo);

    TransformState relativeTrans = transState.translate(offset());
    relativeTrans.setUniforms(prog.programId());
    //printActiveShaderAttributes(prog.programId());
    std::vector<ShaderAttribute> activeAttrs = activeShaderAttributes(prog.programId());
    // Figure out shader locations for each point field
    // TODO: attributeLocation() forces the OpenGL usage here to be
    // synchronous.  Does this matter?  (Alternative: bind them ourselves.)
    std::vector<const ShaderAttribute*> attributes;
    for (size_t i = 0; i < m_fields.size(); ++i)
    {
        const GeomField& field = m_fields[i];
        if (field.spec.isArray())
        {
            for (int j = 0; j < field.spec.count; ++j)
            {
                std::string name = tfm::format("%s[%d]", field.name, j);
                attributes.push_back(findAttr(name, activeAttrs));
            }
        }
        else
        {
            attributes.push_back(findAttr(field.name, activeAttrs));
        }
    }
    // Zero out active attributes in case they don't have associated fields
    GLfloat zeros[16] = {0};
    for (size_t i = 0; i < activeAttrs.size(); ++i)
    {
        prog.setAttributeValue((int)i, zeros, activeAttrs[i].rows,
                               activeAttrs[i].cols);
    }
    // Enable attributes which have associated fields
    for (size_t i = 0; i < attributes.size(); ++i)
    {
        if (attributes[i])
            prog.enableAttributeArray(attributes[i]->location);
    }

    DrawCount drawCount;
    ClipBox clipBox(relativeTrans);

    // Draw points in each bucket, with total number drawn depending on how far
    // away the bucket is.  Since the points are shuffled, this corresponds to
    // a stochastic simplification of the full point cloud.
    V3f relCamera = relativeTrans.cameraPos();
    std::vector<const OctreeNode*> nodeStack;
    nodeStack.push_back(m_rootNode.get());
    while (!nodeStack.empty())
    {
        const OctreeNode* node = nodeStack.back();
        nodeStack.pop_back();
        if (clipBox.canCull(node->bbox))
            continue;
        if (!node->isLeaf())
        {
            for (int i = 0; i < 8; ++i)
            {
                OctreeNode* n = node->children[i];
                if (n)
                    nodeStack.push_back(n);
            }
            continue;
        }
        size_t idx = node->beginIndex;
        if (!incrementalDraw)
            node->nextBeginIndex = node->beginIndex;

        DrawCount nodeDrawCount = node->drawCount(relCamera, quality, incrementalDraw);
        drawCount += nodeDrawCount;

        idx = node->nextBeginIndex;
        if (nodeDrawCount.numVertices == 0)
            continue;

        if (m_fields.size() < 1)
            continue;

        long bufferSize = 0;
        for (size_t i = 0; i < m_fields.size(); ++i)
        {
            const GeomField &field = m_fields[i];
            unsigned int arraySize = field.spec.arraySize();
            unsigned int vecSize = field.spec.vectorSize();

            // tfm::printfln("FIELD-NAME: %s", field.name);
            // tfm::printfln("AS: %i, VS: %i, FSS: %i, FSES: %i, GLBTFSS: %i", arraySize, vecSize, field.spec.size(), field.spec.elsize, sizeof(glBaseType(field.spec)));

            bufferSize += arraySize * vecSize * field.spec.elsize; //sizeof(glBaseType(field.spec));
        }

        bufferSize = bufferSize * (GLsizei)nodeDrawCount.numVertices;

        // TODO: might be able to do something more efficient here, for example use glBufferSubData to avoid re-allocation of memory by glBufferData
        // INITIALIZE THE BUFFER TO FULL SIZE
        // tfm::printfln("INIT BUFFER: %i, BS: %i", vbo, bufferSize);

        glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)bufferSize, NULL, GL_STREAM_DRAW);
        /// ========================================================================
        /// ========================================================================
        GLintptr bufferOffset = 0;

        for (size_t i = 0, k = 0; i < m_fields.size(); k+=m_fields[i].spec.arraySize(), ++i)
        {
            const GeomField& field = m_fields[i];
            int arraySize = field.spec.arraySize();
            int vecSize = field.spec.vectorSize();

            // TODO: should use a single data-array that isn't split into vertex / normal / color / etc. sections, but has interleaved data ?
            // OpenGL has a stride value in glVertexAttribPointer for exactly this purpose, which should be used for better efficiency
            // here we write only the current attribute data into this the buffer (e.g. all positions, then all colors)
            bufferSize = arraySize * vecSize * field.spec.elsize * (GLsizei)nodeDrawCount.numVertices; //sizeof(glBaseType(field.spec))

            char* bufferData = field.data.get() + idx*field.spec.size();
            glBufferSubData(GL_ARRAY_BUFFER, bufferOffset, bufferSize, bufferData);

            // tfm::printfln("UPDATE BUFFER: %i, BS: %i", vbo, bufferSize);

            for (int j = 0; j < arraySize; ++j)
            {
                const ShaderAttribute* attr = attributes[k+j];
                if (!attr)
                    continue;

                // we have to create an intermediate buffer offsets for glVertexAttribPointer, but we can still upload the whole data array earlier !?
                GLintptr intermediate_bufferOffset = bufferOffset + j*field.spec.elsize;

                if (attr->baseType == TypeSpec::Int || attr->baseType == TypeSpec::Uint)
                {
                    glVertexAttribIPointer(attr->location, vecSize,
                                           glBaseType(field.spec), 0, (const GLvoid *)intermediate_bufferOffset);
                }
                else
                {
                    glVertexAttribPointer(attr->location, vecSize,
                                          glBaseType(field.spec),
                                          field.spec.fixedPoint, 0, (const GLvoid *)intermediate_bufferOffset);
                }

                glEnableVertexAttribArray(attr->location);
            }

            bufferOffset += bufferSize;
        }

        glDrawArrays(GL_POINTS, 0, (GLsizei)nodeDrawCount.numVertices);
        node->nextBeginIndex += nodeDrawCount.numVertices;
    }
    //tfm::printf("Drew %d of total points %d, quality %f\n", totDraw, m_npoints, quality);

    // Disable all attribute arrays - leaving these enabled seems to screw with
    // the OpenGL fixed function pipeline in unusual ways.
    for (size_t i = 0; i < attributes.size(); ++i)
    {
        if (attributes[i])
            prog.disableAttributeArray(attributes[i]->location);
    }

    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    return drawCount;
}
Exemplo n.º 15
0
// ----------------------------------
int XML::Node::findAttrInt(const char *name)
{
	char *v = findAttr(name);
    if (!v) return 0;
    return atoi(v);
}
Exemplo n.º 16
0
 __INLINE bool
 ElementRef::hasAttr (KeyId keyId, AttributeType type)
 {
     return (bool) findAttr(keyId, type);
 }
Exemplo n.º 17
0
// ----------------------------------
int XML::Node::findAttrID(const char *name)
{
	char *v = findAttr(name);
    if (!v) return 0;
    return strToID(v);
}
Exemplo n.º 18
0
void XMLCALL Xml::processStartTag(void* data, const char* tag, const char** attrs)
{
    tags.push(findXmlTag(tag));

    switch (tags.top()) {
        case Id::XmlTagDemo:
            pProgramList->SetFolder(filename.GetPath(wxPATH_GET_SEPARATOR) + wxString(findAttr(attrs, Id::XmlAttrFolder)));
            break;

        case Id::XmlTagProgram:
        {
            // Retreive the relevent XML attributes.
            wxString name = findAttr(attrs, Id::XmlAttrName);
            wxString vertex = findAttr(attrs, Id::XmlAttrVertex);
            wxString fragment = findAttr(attrs, Id::XmlAttrFragment);
            wxString blending = findAttr(attrs, Id::XmlAttrBlending);
            wxString reflection = findAttr(attrs, Id::XmlAttrReflection);
            wxString depth = findAttr(attrs, Id::XmlAttrDepth);
            wxString stressText = findAttr(attrs, Id::XmlAttrStress);

            // Set up defaults.
            if (vertex.empty())
                vertex = name;
            if (fragment.empty())
                fragment = name;
            if (blending.empty())
                blending = "off";
            if (reflection.empty())
                reflection = "on";
            if (depth.empty())
                depth = "on";

            Id stress;
            if (stressText.empty())
                stress = Id::StressNone;
            else
                stress = stressText == "vertex" ? Id::StressVertex : Id::StressFragment;

            // Form full path strings.
            vertex = pProgramList->GetFolder() + "/" + vertex + ".vert";
            fragment = pProgramList->GetFolder() + "/" + fragment + ".frag";

            // Create the program object.
            pProgram = pProgramList->NewShader(name, vertex, fragment, blending == "on", reflection == "on", depth == "on", stress);
            break;
        }

        case Id::XmlTagUniform:
        {
            if (!pProgram) {
                wxGetApp().Errorf("XML error: <uniform> outside <shader>.\n");
                break;
            }

            const char* name = findAttr(attrs, Id::XmlAttrName);
            const char* type = findAttr(attrs, Id::XmlAttrType);
            pUniform = pProgram->NewUniform(name, type);
            break;
        }

        case Id::XmlTagTangents:
        {
            if (!pProgram) {
                wxGetApp().Errorf("XML error: <tangents> outside <shader>.\n");
                break;
            }

            pProgram->RequiresTangents();
            break;
        }

        case Id::XmlTagBinormals:
        {
            if (!pProgram) {
                wxGetApp().Errorf("XML error: <binormals> outside <shader>.\n");
                break;
            }

            pProgram->RequiresBinormals();
            break;
        }

        case Id::XmlTagMotion:
        {
            if (!pUniform) {
                wxGetApp().Errorf("XML error: <linear> outside <uniform>.\n");
                break;
            }

            if (pUniform->GetType() == 0) {
                wxGetApp().Errorf("XML error: <motion> specified in <uniform> with unknown 'type'.\n");
                break;
            }

            const char* type = findAttr(attrs, Id::XmlAttrType);
            const char* length = findAttr(attrs, Id::XmlAttrLength);

            pMotion = length ? pUniform->NewMotion(type, length) : 0;
            pProgram->SetMotion();

            break;
        }

        case Id::XmlTagSlider:
        {
            if (!pUniform) {
                wxGetApp().Errorf("XML error: <linear> outside <uniform>.\n");
                break;
            }

            if (pUniform->GetType() == 0) {
                wxGetApp().Errorf("XML error: <slider> specified in <uniform> with unknown 'type'.\n");
                break;
            }

            const char* type = findAttr(attrs, Id::XmlAttrType);
            pSlider = pUniform->NewSlider(type);
            break;
        }

        case Id::XmlTagSilhouette:
        {
            if (!pProgram) {
                wxGetApp().Errorf("XML error: <silhouette> outside <program>.\n");
                break;
            }
            pProgram->SetSilhouette();
            break;
        }

        case Id::XmlTagTextures:
        {
            const char* stage = findAttr(attrs, Id::XmlAttrStage);
            if (stage)
                pProgram->TextureStage(atoi(stage));

            const char* mipmap = findAttr(attrs, Id::XmlAttrMipmap);
            if (mipmap)
                pProgram->Mipmap(atoi(mipmap));
            break;
        }

        case Id::XmlTagModels:
        {
            const char* lod = findAttr(attrs, Id::XmlAttrLod);
            if (lod)
                pProgram->Lod(atoi(lod));
            break;
        }
    }
    content.push(std::string());
}