Beispiel #1
0
/*!
* Register a callback, returning an integer value suitable for
* passing to glutAddMenuEntry()
*
* \param cb Callback function to be called.
* \param client Data to be passed to the callback.
*
* \return integer callback id
*/
static int
callback(void (*cb)(int, int, void *client), void *client) {
	if (ncb == 0) {
		int i;
		for (i = 0; i < NA(callbacks); ++i)
			callbacks[i].cb = NULL;
	} else if (ncb >= NA(callbacks)) {
		fprintf(stderr,
			"callback() out of callbacks, try changing MAX_CALLBACKS\n");
	}
	
	
	callbacks[ncb].cb = cb;
	callbacks[ncb].client = client;
	return ncb++;
}
Beispiel #2
0
    inline Logical Logical::operator&&(Logical other) const {
	if (isFalse() || other.isFalse()) {
	    return false;
	}
	if (isNA() || other.isNA()) {
	    return NA();
	}
	return true;
    }
Beispiel #3
0
/* Replacement for the driver ndo_start_xmit() method.
 * When this function is invoked because of the dev_queue_xmit() call
 * in generic_xmit_frame() (e.g. because of a txsync on the NIC), we have
 * to call the original ndo_start_xmit() method.
 * In all the other cases (e.g. when the TX request comes from the network
 * stack) we intercept the packet and put it into the RX ring associated
 * to the host stack.
 */
static netdev_tx_t
generic_ndo_start_xmit(struct mbuf *m, struct ifnet *ifp)
{
    struct netmap_generic_adapter *gna =
                        (struct netmap_generic_adapter *)NA(ifp);

    if (likely(m->priority == NM_MAGIC_PRIORITY_TX))
        return gna->save_start_xmit(m, ifp); /* To the driver. */

    /* To a netmap RX ring. */
    return linux_netmap_start_xmit(m, ifp);
}
Beispiel #4
0
/*vsize*/
static bool vsize_insert_cell(struct statistic *s, const void *sample) {
    const libtop_psamp_t *psamp = sample;
    char buf[7];
    
    if(top_prefs_get_mmr()) {
	if(top_uinteger_format_mem_result(buf, sizeof(buf),
					  psamp->vsize, psamp->p_vsize, 0ULL)) {
	    return true;
	}
    } else {
	NA(buf);
    }
    
    return generic_insert_cell(s, buf);
}
Beispiel #5
0
/*reg/mregions*/
static bool mregion_insert_cell(struct statistic *s, const void *sample) {
    const libtop_psamp_t *psamp = sample;
    char buf[GENERIC_INT_SIZE];

    if(top_prefs_get_mmr()) {
	if(top_uinteger_format_result(buf, sizeof(buf),
				      psamp->reg, psamp->p_reg, 0ULL)) {
	    return true;
	}
    } else {
	NA(buf);
    }
    
    return generic_insert_cell(s, buf);
}
Beispiel #6
0
/* Replacement for the driver ndo_start_xmit() method.
 * When this function is invoked because of the dev_queue_xmit() call
 * in generic_xmit_frame() (e.g. because of a txsync on the NIC), we have
 * to call the original ndo_start_xmit() method.
 * In all the other cases (e.g. when the TX request comes from the network
 * stack) we intercept the packet and put it into the RX ring associated
 * to the host stack.
 */
static netdev_tx_t
generic_ndo_start_xmit(struct mbuf *m, struct ifnet *ifp)
{
	struct netmap_generic_adapter *gna =
		(struct netmap_generic_adapter *)NA(ifp);

	if (likely(m->priority == NM_MAGIC_PRIORITY_TX)) {
		/* Reset priority, so that generic_netmap_tx_clean()
		 * knows that it can reclaim this mbuf. */
		m->priority = 0;
		return gna->save_start_xmit(m, ifp); /* To the driver. */
	}

	/* To a netmap RX ring. */
	return linux_netmap_start_xmit(m, ifp);
}
Beispiel #7
0
static struct mbuf *
generic_qdisc_dequeue(struct Qdisc *qdisc)
{
	struct mbuf *m = qdisc_dequeue_head(qdisc);

	if (!m) {
		return NULL;
	}

        if (unlikely(m->priority == NM_MAGIC_PRIORITY_TXQE)) {
            /* nm_os_generic_xmit_frame() asked us an event on this mbuf.
             * We have to set the priority to the normal TX token, so that
             * generic_ndo_start_xmit can pass it to the driver. */
            m->priority = NM_MAGIC_PRIORITY_TX;
            ND(5, "Event met, notify %p", m);
            netmap_generic_irq(NA(qdisc_dev(qdisc)),
                               skb_get_queue_mapping(m), NULL);
        }

	ND(5, "Dequeuing mbuf, len %u", qdisc_qlen(qdisc));

	return m;
}
Beispiel #8
0
Datei: list.c Projekt: edc/mcs
short* foreach(short* list, short** bk)
{
	if (*bk == NULL)
		*bk = list;

	short* peek = NULL;

	while (!EOL(**bk)) {
		if (!NA(**bk)) {
			*bk = *bk + 1;
			return *bk - 1;
		} else {
			/* move following */
			if (peek == NULL) peek = *bk + 1;
			else peek ++;
			**bk = *peek;
			*peek = DEL_ELEMENT;
		}
	}

	*bk = NULL;
	return NULL;
}
Beispiel #9
0
 EndPoint() : value(NA()), type(INCLUSIVE_END_POINT) {}
Beispiel #10
0
static int
alloc_nm_txq_hwq(struct port_info *pi, struct sge_nm_txq *nm_txq)
{
	int rc, cntxt_id;
	size_t len;
	struct adapter *sc = pi->adapter;
	struct netmap_adapter *na = NA(pi->nm_ifp);
	struct fw_eq_eth_cmd c;

	MPASS(na != NULL);
	MPASS(nm_txq->desc != NULL);

	len = na->num_tx_desc * EQ_ESIZE + spg_len;
	bzero(nm_txq->desc, len);

	bzero(&c, sizeof(c));
	c.op_to_vfn = htobe32(V_FW_CMD_OP(FW_EQ_ETH_CMD) | F_FW_CMD_REQUEST |
	    F_FW_CMD_WRITE | F_FW_CMD_EXEC | V_FW_EQ_ETH_CMD_PFN(sc->pf) |
	    V_FW_EQ_ETH_CMD_VFN(0));
	c.alloc_to_len16 = htobe32(F_FW_EQ_ETH_CMD_ALLOC |
	    F_FW_EQ_ETH_CMD_EQSTART | FW_LEN16(c));
	c.autoequiqe_to_viid = htobe32(V_FW_EQ_ETH_CMD_VIID(pi->nm_viid));
	c.fetchszm_to_iqid =
	    htobe32(V_FW_EQ_ETH_CMD_HOSTFCMODE(X_HOSTFCMODE_NONE) |
		V_FW_EQ_ETH_CMD_PCIECHN(pi->tx_chan) | F_FW_EQ_ETH_CMD_FETCHRO |
		V_FW_EQ_ETH_CMD_IQID(sc->sge.nm_rxq[nm_txq->iqidx].iq_cntxt_id));
	c.dcaen_to_eqsize = htobe32(V_FW_EQ_ETH_CMD_FBMIN(X_FETCHBURSTMIN_64B) |
		      V_FW_EQ_ETH_CMD_FBMAX(X_FETCHBURSTMAX_512B) |
		      V_FW_EQ_ETH_CMD_EQSIZE(len / EQ_ESIZE));
	c.eqaddr = htobe64(nm_txq->ba);

	rc = -t4_wr_mbox(sc, sc->mbox, &c, sizeof(c), &c);
	if (rc != 0) {
		device_printf(pi->dev,
		    "failed to create netmap egress queue: %d\n", rc);
		return (rc);
	}

	nm_txq->cntxt_id = G_FW_EQ_ETH_CMD_EQID(be32toh(c.eqid_pkd));
	cntxt_id = nm_txq->cntxt_id - sc->sge.eq_start;
	if (cntxt_id >= sc->sge.neq)
	    panic("%s: nm_txq->cntxt_id (%d) more than the max (%d)", __func__,
		cntxt_id, sc->sge.neq - 1);
	sc->sge.eqmap[cntxt_id] = (void *)nm_txq;

	nm_txq->pidx = nm_txq->cidx = 0;
	MPASS(nm_txq->sidx == na->num_tx_desc);
	nm_txq->equiqidx = nm_txq-> equeqidx = nm_txq->dbidx = 0;

	nm_txq->doorbells = sc->doorbells;
	if (isset(&nm_txq->doorbells, DOORBELL_UDB) ||
	    isset(&nm_txq->doorbells, DOORBELL_UDBWC) ||
	    isset(&nm_txq->doorbells, DOORBELL_WCWR)) {
		uint32_t s_qpp = sc->sge.eq_s_qpp;
		uint32_t mask = (1 << s_qpp) - 1;
		volatile uint8_t *udb;

		udb = sc->udbs_base + UDBS_DB_OFFSET;
		udb += (nm_txq->cntxt_id >> s_qpp) << PAGE_SHIFT;
		nm_txq->udb_qid = nm_txq->cntxt_id & mask;
		if (nm_txq->udb_qid >= PAGE_SIZE / UDBS_SEG_SIZE)
	    		clrbit(&nm_txq->doorbells, DOORBELL_WCWR);
		else {
			udb += nm_txq->udb_qid << UDBS_SEG_SHIFT;
			nm_txq->udb_qid = 0;
		}
		nm_txq->udb = (volatile void *)udb;
	}
Beispiel #11
0
static int
alloc_nm_rxq_hwq(struct port_info *pi, struct sge_nm_rxq *nm_rxq)
{
	int rc, cntxt_id;
	__be32 v;
	struct adapter *sc = pi->adapter;
	struct netmap_adapter *na = NA(pi->nm_ifp);
	struct fw_iq_cmd c;

	MPASS(na != NULL);
	MPASS(nm_rxq->iq_desc != NULL);
	MPASS(nm_rxq->fl_desc != NULL);

	bzero(nm_rxq->iq_desc, pi->qsize_rxq * IQ_ESIZE);
	bzero(nm_rxq->fl_desc, na->num_rx_desc * EQ_ESIZE + spg_len);

	bzero(&c, sizeof(c));
	c.op_to_vfn = htobe32(V_FW_CMD_OP(FW_IQ_CMD) | F_FW_CMD_REQUEST |
	    F_FW_CMD_WRITE | F_FW_CMD_EXEC | V_FW_IQ_CMD_PFN(sc->pf) |
	    V_FW_IQ_CMD_VFN(0));
	c.alloc_to_len16 = htobe32(F_FW_IQ_CMD_ALLOC | F_FW_IQ_CMD_IQSTART |
	    FW_LEN16(c));
	if (pi->flags & INTR_NM_RXQ) {
		KASSERT(nm_rxq->intr_idx < sc->intr_count,
		    ("%s: invalid direct intr_idx %d", __func__,
		    nm_rxq->intr_idx));
		v = V_FW_IQ_CMD_IQANDSTINDEX(nm_rxq->intr_idx);
	} else {
		CXGBE_UNIMPLEMENTED(__func__);	/* XXXNM: needs review */
		v = V_FW_IQ_CMD_IQANDSTINDEX(nm_rxq->intr_idx) |
		    F_FW_IQ_CMD_IQANDST;
	}
	c.type_to_iqandstindex = htobe32(v |
	    V_FW_IQ_CMD_TYPE(FW_IQ_TYPE_FL_INT_CAP) |
	    V_FW_IQ_CMD_VIID(pi->nm_viid) |
	    V_FW_IQ_CMD_IQANUD(X_UPDATEDELIVERY_INTERRUPT));
	c.iqdroprss_to_iqesize = htobe16(V_FW_IQ_CMD_IQPCIECH(pi->tx_chan) |
	    F_FW_IQ_CMD_IQGTSMODE |
	    V_FW_IQ_CMD_IQINTCNTTHRESH(0) |
	    V_FW_IQ_CMD_IQESIZE(ilog2(IQ_ESIZE) - 4));
	c.iqsize = htobe16(pi->qsize_rxq);
	c.iqaddr = htobe64(nm_rxq->iq_ba);
	c.iqns_to_fl0congen |=
	    htobe32(V_FW_IQ_CMD_FL0HOSTFCMODE(X_HOSTFCMODE_NONE) |
		F_FW_IQ_CMD_FL0FETCHRO | F_FW_IQ_CMD_FL0DATARO |
		(fl_pad ? F_FW_IQ_CMD_FL0PADEN : 0));
	c.fl0dcaen_to_fl0cidxfthresh =
	    htobe16(V_FW_IQ_CMD_FL0FBMIN(X_FETCHBURSTMIN_64B) |
		V_FW_IQ_CMD_FL0FBMAX(X_FETCHBURSTMAX_512B));
	c.fl0size = htobe16(na->num_rx_desc + spg_len / EQ_ESIZE);
	c.fl0addr = htobe64(nm_rxq->fl_ba);

	rc = -t4_wr_mbox(sc, sc->mbox, &c, sizeof(c), &c);
	if (rc != 0) {
		device_printf(sc->dev,
		    "failed to create netmap ingress queue: %d\n", rc);
		return (rc);
	}

	nm_rxq->iq_cidx = 0;
	MPASS(nm_rxq->iq_sidx == pi->qsize_rxq - spg_len / IQ_ESIZE);
	nm_rxq->iq_gen = F_RSPD_GEN;
	nm_rxq->iq_cntxt_id = be16toh(c.iqid);
	nm_rxq->iq_abs_id = be16toh(c.physiqid);
	cntxt_id = nm_rxq->iq_cntxt_id - sc->sge.iq_start;
	if (cntxt_id >= sc->sge.niq) {
		panic ("%s: nm_rxq->iq_cntxt_id (%d) more than the max (%d)",
		    __func__, cntxt_id, sc->sge.niq - 1);
	}
	sc->sge.iqmap[cntxt_id] = (void *)nm_rxq;

	nm_rxq->fl_cntxt_id = be16toh(c.fl0id);
	nm_rxq->fl_pidx = nm_rxq->fl_cidx = 0;
	MPASS(nm_rxq->fl_sidx == na->num_rx_desc);
	cntxt_id = nm_rxq->fl_cntxt_id - sc->sge.eq_start;
	if (cntxt_id >= sc->sge.neq) {
		panic("%s: nm_rxq->fl_cntxt_id (%d) more than the max (%d)",
		    __func__, cntxt_id, sc->sge.neq - 1);
	}
	sc->sge.eqmap[cntxt_id] = (void *)nm_rxq;

	nm_rxq->fl_db_val = F_DBPRIO | V_QID(nm_rxq->fl_cntxt_id) | V_PIDX(0);
	if (is_t5(sc))
		nm_rxq->fl_db_val |= F_DBTYPE;

	t4_write_reg(sc, MYPF_REG(A_SGE_PF_GTS), V_SEINTARM(F_QINTR_CNT_EN) |
	    V_INGRESSQID(nm_rxq->iq_cntxt_id));

	return (rc);
}
Beispiel #12
0
 /// Definition of the ideal gas constant [J/mol K]
 inline Real R()   { return kB() * NA(); }
Beispiel #13
0
 /// Definition of the Faraday's constant [C/mol]
 inline Real F()   { return e() * NA(); }
Beispiel #14
0
/* CGAT
 * read and make tables
 * BA -> NA 
 */
static void CGAT(){
  FILE *IN=NULL, *IN_b=NULL, *IN_rev=NULL;
  int **table_value=NULL;
  unsigned short **table_num=NULL;
  int state_a2, state_b=0, state_rev;
  Fasta *fst1 = fasta_new(), *fst2 = fasta_new(), *fst_rev = fasta_new();
  clock_t start, start1, end0, end1, end2;

  /*----- do BA and NA for each fasta-pair-----*/
  /* genomeB file open */
  IN_b = my_fopen_r(idata_b->seqname);
  par.OUT = my_fopen_w(par.outputfile);

  for(idata_b->cnt=0; idata_b->cnt < idata_b->fstnum; idata_b->cnt++){
    start = clock();

    /* MakeTable */
    read_multifasta(IN_b, fst2, FORWARD, &state_b);
    table_value = (int **)my_malloc(idata_b->blocknum[idata_b->cnt] * sizeof(int *), "table_b_value");
    table_num = (unsigned short **)my_malloc(idata_b->blocknum[idata_b->cnt] * sizeof(unsigned short *), "table_b_num");
    Make_SeedTable(fst2, table_value, table_num);

    end0 = clock();
    if(opt.debug) printf("MakeTable time: %.2f sec.\n", (double)(end0-start)/CLOCKS_PER_SEC);

    IN     = my_fopen_r(idata_a->seqname);
    IN_rev = my_fopen_r(idata_a->seqname);
    state_a2=0; state_rev=0;

    for(idata_a->cnt=0; idata_a->cnt < idata_a->fstnum; idata_a->cnt++){      
      printf("\ngenomeA-fasta%d (%d blocks) - genomeB-fasta%d (%d blocks)\n",
	     idata_a->cnt+1, idata_a->blocknum[idata_a->cnt], idata_b->cnt+1, idata_b->blocknum[idata_b->cnt]);
      start1 = clock();

      /*--- BA: the results are stored in aln_for/rev ---*/
      BA(&aln_for, table_value, table_num, FORWARD);
      if(reverse) BA(&aln_rev, table_value, table_num, REVERSE);
      if(idata_a->cnt == idata_a->fstnum -1) table_b_delete(table_value, table_num, idata_b->blocknum[idata_b->cnt]);

      end1 = clock();
      if(opt.debug) printf("BA time: %.2f sec.\n", (double)(end1-start1)/CLOCKS_PER_SEC);
      /*--- (if -b is on) output BA result and skip NA ---*/
      if(block){
	output_BAresult();
	continue;
      }

      /*--- NA: detailed alignmend within colonies in bl ---*/
      NA(IN, fst1, fst2, &aln_for, FORWARD, &state_a2);
      if(reverse) NA(IN_rev, fst_rev, fst2, &aln_rev, REVERSE, &state_rev);

      end2 = clock();
      if(opt.debug) printf("NA time: %.2f sec.\n", (double)(end2-end1)/CLOCKS_PER_SEC);
    }

    free(fst2->head);
    free(fst2->body);
    fclose(IN);
    fclose(IN_rev);
  }

  if(opt.boundary) output_fastaboundary();

  free(fst1); free(fst2); free(fst_rev);
  fclose(IN_b);
  fclose(par.OUT);
}
Beispiel #15
0
 static Vector na() {
   return Vector(NA());
 }
Beispiel #16
0
 void unset_lower_bound() {
   lower_bound_.value = NA();
 }
Beispiel #17
0
 void unset_upper_bound() {
   upper_bound_.value = NA();
 }
Beispiel #18
0
void EncodingEDSRSA(char *M_fname, char *nA_fname, char *eA_fname, char *dA_fname, char *nB_fname, char *eB_fname, char *dB_fname)
{
	std::ifstream in(M_fname);
	int *M_hash = (int*)md5(&in), i;
    BigInt  M(intToChar(M_hash[3])), NA(nA_fname, false), EA(eA_fname, false), DA(dA_fname, false);
    M *= BigInt("10000000000"); M += BigInt(intToChar(M_hash[2]));
    M *= BigInt("10000000000"); M += BigInt(intToChar(M_hash[1]));
    M *= BigInt("10000000000"); M += BigInt(intToChar(M_hash[0]));
    BigInt NB(nB_fname, false), EB(eB_fname, false), DB(dB_fname, false);
    BigInt Signature("1"), Code("1"), Encode("1"), CheckSign("1");
    BigInt DegreeNet[RNet];
	DegreeNet[0] = M;
	DegreeNet[0] %= NA;
	for(i = 1; i < RNet; i++)
	{
		DegreeNet[i] = DegreeNet[i-1] * DegreeNet[i-1];
		DegreeNet[i] %= NA;
	}
    BigInt degreeNum[RNet];
    degreeNum[0] = BigInt("1");
	for(int i = 1; i < RNet; i++)
        degreeNum[i] = degreeNum[i-1] * BigInt("2");
    BigInt I("0");
	for(int j = RNet-1; j >= 0;)
	{
		if(DA >= I + degreeNum[j])
		{
			Signature *= DegreeNet[j];
			Signature %= NA;
			I += degreeNum[j];
		}
		else
			j--;
	}
	//////////////////////////////
	DegreeNet[0] = Signature;
	DegreeNet[0] %= NB;
	for(i = 1; i < RNet; i++)
	{
		DegreeNet[i] = DegreeNet[i-1] * DegreeNet[i-1];
		DegreeNet[i] %= NB;
	}
    I = BigInt("0");
	for(int j = RNet-1; j >= 0;)
	{
		if(EB >= I + degreeNum[j])
		{
			Code *= DegreeNet[j];
			Code %= NB;
			I += degreeNum[j];
		}
		else
			j--;
	}
	//////////////////////////////
	DegreeNet[0] = Code;
	DegreeNet[0] %= NB;
	for(i = 1; i < RNet; i++)
	{
		DegreeNet[i] = DegreeNet[i-1] * DegreeNet[i-1];
		DegreeNet[i] %= NB;
	}
    I = BigInt("0");
	for(int j = RNet-1; j >= 0;)
	{
		if(DB >= I + degreeNum[j])
		{
			Encode *= DegreeNet[j];
			Encode %= NB;
			I += degreeNum[j];
		}
		else
			j--;
	}
	//////////////////////////////
	DegreeNet[0] = Encode;
	DegreeNet[0] %= NA;
	for(i = 1; i < RNet; i++)
	{
		DegreeNet[i] = DegreeNet[i-1] * DegreeNet[i-1];
		DegreeNet[i] %= NA;
	}
    I = BigInt("0");
	for(int j = RNet - 1; j >= 0;)
	{
		if(EA >= I + degreeNum[j])
		{
			CheckSign *= DegreeNet[j];
			CheckSign %= NA;
			I += degreeNum[j];
		}
		else
			j--;
	}
	//////////////////////////////
	M.TextWrite("hash.txt");
	Code.TextWrite("code.txt");
	Encode.TextWrite("encode.txt");
	CheckSign.TextWrite("checksign.txt");
	if( M % NA == CheckSign)
		std::cout<<"OK\n";
	else
		std::cout<<"NOT OK\n";
}
Beispiel #19
0
SmartPointer<Batch> Batch::Merge(SmartPointer<Batch> _A,SmartPointer<Batch> _B)
{
	if (!_A) return _B;
	if (!_B) return _A;

	Batch* A=_A.get();
	Batch* B=_B.get();

	if (A->primitive!=B->primitive) 
		return SmartPointer<Batch>();

	if (A->ambient  !=B->ambient  ) 
		return SmartPointer<Batch>();

	if (A->diffuse  !=B->diffuse  ) 
		return SmartPointer<Batch>();

	if (A->specular !=B->specular ) 
		return SmartPointer<Batch>();

	if (A->emission !=B->emission ) 
		return SmartPointer<Batch>();

	if (A->shininess!=B->shininess) 
		return SmartPointer<Batch>();

	if ((A->vertices && !B->vertices) || (!A->vertices && B->vertices)) 
		return SmartPointer<Batch>();

	if ((A->normals  && !B->normals ) || (!A->normals  && B->normals )) 
		return SmartPointer<Batch>();

	if ((A->colors   && !B->colors  ) || (!A->colors   && B->colors  )) 
		return SmartPointer<Batch>();

	bool ATex0=(A->texture0) && (A->texture0coords);
	bool BTex0=(B->texture0) && (B->texture0coords);
	if ((ATex0 && !BTex0) || (!ATex0 && BTex0) || (ATex0 && BTex0 && A->texture0.get()!=B->texture0.get())) 
		return SmartPointer<Batch>();

	bool ATex1=(A->texture1) && (A->texture1coords);
	bool BTex1=(B->texture1) && (B->texture1coords);
	if ((ATex1 && !BTex1) || (!ATex1 && BTex1) || (ATex1 && BTex1 && A->texture1.get()!=B->texture1.get())) 
		return SmartPointer<Batch>();

	SmartPointer<Batch> ret(new Batch());
	ret->matrix=Mat4f();
	ret->primitive=A->primitive;
	ret->ambient  =A->ambient;
	ret->diffuse  =A->diffuse;
	ret->specular =A->specular;
	ret->emission =A->emission;
	ret->shininess=A->shininess;

	//vertices
	if (A->vertices)
	{
		Vector VA(*(A->vertices));
		{
			Mat4f T=A->matrix;
			float* p=VA.mem();
			for (int i=0;i<VA.size();i+=3,p+=3)
			{
				Vec3f V=T * Vec3f(p[0],p[1],p[2]);
				p[0]=V.x;p[1]=V.y;p[2]=V.z;
			}
		}

		Vector VB(*(B->vertices));
		{
			Mat4f T=B->matrix;
			float* p=VB.mem();
			for (int i=0;i<VB.size();i+=3,p+=3)
			{
				Vec3f V=T * Vec3f(p[0],p[1],p[2]);
				p[0]=V.x;p[1]=V.y;p[2]=V.z;
			}
		}

		ret->vertices.reset(new Vector(VA));
		ret->vertices->append(VB);
	}

	//normals
	if (A->normals)
	{
		Vector NA(*(A->normals));
		{
			Mat4f T=A->matrix.invert();
			float* p=NA.mem();
			for (int i=0;i<NA.size();i+=3,p+=3)
			{
				Vec4f _N=Vec4f(p[0],p[1],p[2],0.0) *  T;
				Vec3f  N=Vec3f(_N.x,_N.y,_N.z).normalize();
				p[0]=N.x;p[1]=N.y;p[2]=N.z;
			}
		}

		Vector NB(*(B->normals));
		{
			Mat4f T=B->matrix.invert();
			float* p=NB.mem();
			for (int i=0;i<NB.size();i+=3,p+=3)
			{
				Vec4f _N=Vec4f(p[0],p[1],p[2],0.0) *  T;
				Vec3f  N=Vec3f(_N.x,_N.y,_N.z).normalize();
				p[0]=N.x;p[1]=N.y;p[2]=N.z;
			}
		}

		ret->normals.reset(new Vector(NA));
		ret->normals->append(NB);
	}

	//colors
	if (A->colors)
	{
		ret->colors.reset(new Vector(*(A->colors)));
		ret->colors->append(*(B->colors));
	}

	//texture 0
	if (ATex0)
	{
		ret->texture0=A->texture0;
		ret->texture0coords.reset(new Vector(*(A->texture0coords)));
		ret->texture0coords->append(*(B->texture0coords));
	}
	
	//texture 1
	if (ATex1)
	{
		ret->texture1=A->texture1;
		ret->texture1coords.reset(new Vector(*(A->texture1coords)));
		ret->texture1coords->append(*(B->texture1coords));
	}

	return ret;
}
Beispiel #20
0
 	/** @brief NA aware equality operator.
	 *
	 *  Returns NA if either or both operands are NA.  Otherwise returns
	 *  whether or not the two values are equal.
	 */ 
	Logical equals(Logical other) const {
	    return (isNA() || other.isNA()) ? NA() : identical(other);
	}
Beispiel #21
0
 explicit constexpr Vector(NA) : data_(nullptr), size_(NA()) {}
Beispiel #22
0
 static constexpr Bool na() {
   return Bool(NA());
 }
Beispiel #23
0
 static constexpr Vector na() {
   return Vector(NA());
 }
Beispiel #24
0
/*!
* Call the indexed callback.
*
* \param idx Callback index.
* \param data Data to be passed to the callback
*/
static void
call_callback(int idx, int data)
{
  if( idx >= 0 && idx < NA(callbacks) && callbacks[idx].cb != NULL )
    callbacks[idx].cb(idx, data, callbacks[idx].client);
}
Beispiel #25
0
 explicit Vector(NA)
     : is_direct_(true),
       size_(NA()),
       data_(nullptr) {}
Beispiel #26
0
    // Inline definitions of operators.
    inline Logical Logical::operator!() const {
	if (isNA()) {
	    return NA();
	}
	return Logical(1 - m_value);
    }