Example #1
0
BunnyPixel example_fragment_shader(const BunnyVertVsOut& fsin,const TinyImage& texture)
{
	BunnyPixel p;
	
	//p.color.head<3>()=fsin.color;
	p.diffuse_color=texture(fsin.texcoord.x(),fsin.texcoord.y()).head<3>();
	
	float f=fsin.p.z();
	Eigen::Vector2f zrange(-0.199768,0.309477);
	f-=zrange[0];
	f/=(zrange[1]-zrange[0]);
	//std::cerr << f << std::endl;
	//p.color[3]=f;
	//p.color=Eigen::Vector4f(f,f,f,f);
	
	p.normal=(fsin.normal/fsin.normal.norm())*0.5f+Eigen::Vector3f(0.5f,0.5f,0.5f);
	p.new_depth=f;
	//depth is already set by rasterizer
	return p;
}
Example #2
0
int zset_range(ldb_context_t* context, const ldb_slice_t* name, 
               int rank_start, int rank_end, int reverse, ldb_list_t **pkeylist, ldb_list_t** pmetalist){
  int retval = 0;
  uint64_t offset, limit, size = 0;
  retval = zset_size(context, name, &size);
  if(retval != LDB_OK && retval != LDB_OK_NOT_EXIST){
    goto end;
  }
  if(rank_start < 0){
    rank_start = rank_start + size; 
  }
  if(rank_end < 0 ){
    rank_end = rank_end + size;
  }
  if(rank_start < 0){
    rank_start = 0;
  }
  if(rank_start > rank_end || rank_start >= (int)size){
    retval = LDB_OK_RANGE_HAVE_NONE;
    goto end;
  }
  if(rank_end >= (int)size){
    rank_end = (int)(size - 1);
    limit = rank_end - rank_start + 10;
  }else{
    limit = rank_end - rank_start + 1;
  }
  offset = rank_start;
  ldb_zset_iterator_t *iterator = NULL;
  if(zrange(context, name, offset, limit, reverse, &iterator)<0){
    retval = LDB_OK_RANGE_HAVE_NONE;
    goto end;
  }
  ldb_list_t *keylist = ldb_list_create();
  ldb_list_t *metlist = ldb_list_create();
  while(1){
    if(!ldb_zset_iterator_valid(iterator)){
      break;
    }
    size_t raw_vlen = 0;
    const char* raw_val = ldb_zset_iterator_val_raw(iterator, &raw_vlen);
    assert(raw_vlen >= LDB_VAL_META_SIZE);
    uint8_t type = leveldb_decode_fixed8(raw_val);
    if((type & LDB_VALUE_TYPE_VAL)&& !(type & LDB_VALUE_TYPE_LAT)){

      ldb_slice_t *key = NULL;
      int64_t value = 0;
      size_t raw_klen = 0;
      const char* raw_key = ldb_zset_iterator_key_raw(iterator, &raw_klen);

      if(decode_zscore_key( raw_key,
                            raw_klen,
                            NULL,
                            &key,
                            &value)==0){ 
        //first node
        ldb_list_node_t* key_node = ldb_list_node_create();
        key_node->type_ = LDB_LIST_NODE_TYPE_SLICE;
        key_node->value_ = value;
        key_node->data_ = key;
        rpush_ldb_list_node(keylist, key_node);
        //second
        uint64_t version = leveldb_decode_fixed64(raw_val + sizeof(uint8_t));
        ldb_list_node_t* met_node = ldb_list_node_create();
        met_node->type_ = LDB_LIST_NODE_TYPE_BASE;
        met_node->value_ = version;
        met_node->data_ = NULL;
        rpush_ldb_list_node(metlist, met_node);
      }
    }
    if(ldb_zset_iterator_next(iterator)){
      break;
    }
  }

  *pkeylist = keylist;
  *pmetalist = metlist;
  ldb_zset_iterator_destroy(iterator);
  retval = LDB_OK;
 
end:
  return retval;
}
Example #3
0
int zset_del_range_by_rank(ldb_context_t* context, const ldb_slice_t* name,
                           const ldb_meta_t* meta, int rank_start, int rank_end, uint64_t *deleted){
  int retval = 0;
  ldb_zset_iterator_t *iterator = NULL;
  uint64_t offset, limit, size = 0;
  retval = zset_size(context, name, &size);
  if(retval == LDB_OK_NOT_EXIST){
    goto end;
  }
  if(retval != LDB_OK){
    goto end;
  }
  if(rank_start < 0){
    rank_start = rank_start + size; 
  }
  if(rank_end < 0 ){
    rank_end = rank_end + size;
  }
  if(rank_start < 0){
    rank_start = 0;
  }
  if(rank_start > rank_end || rank_start >= (int)size){
    retval = LDB_OK_RANGE_HAVE_NONE;
    goto end;
  }
  if(rank_end >= (int)size){
    rank_end = (int)(size - 1);
    limit = rank_end - rank_start + 10;
  }else{
    limit = rank_end - rank_start ;
  }
  offset = rank_start;
  if(zrange(context, name, offset, limit, 0, &iterator)<0){
    retval = LDB_OK_RANGE_HAVE_NONE;
    goto end;
  }
  
  (*deleted) = 0;
  do{
    if((*deleted)==limit){
      break;
    }
    if(!ldb_zset_iterator_valid(iterator)){
      break;
    }
    size_t raw_vlen = 0;
    const char* raw_val = ldb_zset_iterator_val_raw(iterator, &raw_vlen);
    uint8_t type = leveldb_decode_fixed8(raw_val);
    if((type & LDB_VALUE_TYPE_VAL) && !(type & LDB_VALUE_TYPE_LAT)){
      size_t raw_klen = 0;
      const char* raw_key = ldb_zset_iterator_key_raw(iterator, &raw_klen);
      ldb_slice_t *key = NULL;
      if(decode_zscore_key( raw_key,
                            raw_klen,
                            NULL,
                            &key,
                            NULL)== 0){ 
        if(zset_del(context, name, key, meta) == LDB_OK){
          *deleted += 1;
        }
        ldb_slice_destroy(key);
      }
    }
  }while(!ldb_zset_iterator_next(iterator));

  retval = LDB_OK;

end:
  ldb_zset_iterator_destroy(iterator);
  return retval; 
}