enum return_code WRATHAttributeStore:: fragmented_allocate_attribute_data(int number_elements, std::vector< range_type<int> > &out_allocations) { WRATHAutoLockMutex(m_implicit_store_mutex); enum return_code R; int biggest_end(0), start_div_at(out_allocations.size()); R=m_vertex_buffer->fragmented_allocate(attribute_size()*number_elements, out_allocations); if(R==routine_success) { for(int i=start_div_at, end_i=out_allocations.size(); i<end_i; ++i) { WRATHassert(out_allocations[i].m_begin%attribute_size()==0); WRATHassert(out_allocations[i].m_end%attribute_size()==0); out_allocations[i].m_begin/=attribute_size(); out_allocations[i].m_end/=attribute_size(); biggest_end=std::max(out_allocations[i].m_end, biggest_end); } int required_implicit_attr_size(m_implicit_attribute_size*biggest_end); resize_implicit_stores(required_implicit_attr_size); } return R; }
void WRATHAttributeStore:: deallocate_attribute_data(int begin_element, int end_element) { begin_element*=attribute_size(); end_element*=attribute_size(); m_vertex_buffer->deallocate(begin_element, end_element); }
attribute attribute_find ( relation rel, char *name) { /* attribute_find * Locates the given attribute, and returns an attribute structure */ attribute catt,ratt; tuple ctuple; word anum; /* Get the first attribute */ /* catt=attribute_findfirst(rel,&attribute_file); */ catt=relation_attribute_readfirst(rel,&ctuple,&anum); /* Whilst the attribute is valid, and the attribute does * not match the search criteria */ while ( (catt!=NULL) && (name!=NULL) && (strcmp(attribute_name(catt),name)!=0) ) { /* Locate the next field */ catt=relation_attribute_readnext(rel,&ctuple,catt,&anum); } /* Check to see if we actually found anything */ if ( (catt!=NULL) && (name!=NULL) && (strcmp(attribute_name(catt),name)==0) ) { /* We're about to destroy the tuple, which will destroy the attribute * we just found. Make a copy quick! */ /* Create a ptr to an attribute structure */ ratt=(attribute_struct *) malloc(sizeof(attribute_struct)); /* Check that the ptr was allocated. */ check_assign(ratt,"attributes.attribute_find(cpy)"); strcpy(attribute_name(ratt),attribute_name(catt)); attribute_type(ratt)=attribute_type(catt); attribute_size(ratt)=attribute_size(catt); attribute_no(ratt)=attribute_no(catt); close_tuple(&ctuple,TUPLE_DISPOSE); /* Return the ptr */ return(ratt); } else { /* Close the tuple */ close_tuple(&ctuple,TUPLE_DISPOSE); /* Return nothing */ return(NULL); } }
WRATHAttributeStore:: ~WRATHAttributeStore() { deallocate_attribute_data(0,1); if(attributes_allocated()!=0) { WRATHwarning("[" << this << "]" << ":" << m_vertex_buffer << ": Warning: not all attributes de-allocated! " << attributes_allocated() << " attributes remain" << "{ attribute size=" << attribute_size() << " }"); } WRATHPhasedDelete(m_vertex_buffer); WRATHLockMutex(m_allocator_ptr_mutex); if(m_allocator!=NULL) { m_allocator->unregister(this); } for(std::map<unsigned int, per_implicit_store*>::iterator iter=m_implicit_attribute_data.begin(), end=m_implicit_attribute_data.end(); iter!=end; ++iter) { WRATHPhasedDelete(iter->second); } WRATHUnlockMutex(m_allocator_ptr_mutex); }
enum return_code WRATHAttributeStore:: proxy_fragmented_allocate_attribute(int number_elements) const { return (number_elements<=0)? routine_success: m_vertex_buffer->proxy_fragmented_allocate(number_elements*attribute_size()); }
int WRATHAttributeStore:: allocate_attribute_data(int number_elements) { WRATHAutoLockMutex(m_implicit_store_mutex); int raw_value; raw_value=m_vertex_buffer->allocate(number_elements*attribute_size()); if(raw_value==-1) { return raw_value; } WRATHassert(raw_value%attribute_size()==0); raw_value/=attribute_size(); int required_implicit_attr_size(m_implicit_attribute_size*(number_elements+raw_value)); resize_implicit_stores(required_implicit_attr_size); return raw_value; }
void attribute_print(attribute att) { /* attribute_print * Print out the information contained in the specified * attribute */ char fmt[FORMAT_SIZE]; fmt_build(fmt,att); /* Check that the ptr is assigned! */ if (att!=NULL) { switch (attribute_type(att)) { case DT_STRING: leap_printf(DTS_STRING); leap_printf(" "); break; case DT_NUMBER: leap_printf(DTS_NUMBER); leap_printf(" "); break; case DT_BOOLEAN: leap_printf(DTS_BOOLEAN); leap_printf(" "); break; default: leap_printf(DTS_UNSUPPORTED); leap_printf(" "); } if (attribute_size(att)==0) leap_printf("-"); else leap_printf("%d",attribute_size(att)); if (attribute_size(att)<9) leap_printf(" "); else if (attribute_size(att)<99) leap_printf(" "); else leap_printf(" "); leap_printf("%-25.25s \n",attribute_name(att)); } }
int WRATHAttributeStore:: attributes_allocated(void) const { return m_vertex_buffer->bytes_allocated()/attribute_size(); }
int WRATHAttributeStore:: max_fragmented_allocate_possible(void) const { return m_vertex_buffer->max_fragmented_allocate_possible()/attribute_size(); }
////////////////////////////////////// // WRATHAttributeStore methods WRATHAttributeStore:: WRATHAttributeStore(const WRATHAttributeStoreKey &pkey, WRATHAttributeStoreAllocator *allocator, bool allocate_implicit_attribute_data): m_key(pkey), m_value_at_index0(allocator->m_value_at_index0), m_implicit_attribute_format(allocator->m_implicit_attribute_format), m_attribute_format_location(m_key.m_attribute_format_location), m_index_bits(m_key.m_index_bit_count), m_buffer_object_hint(m_key.m_buffer_object_hint), m_implicit_attribute_size(m_value_at_index0.size()), m_allocator(allocator), m_req_implicit_attribute_size(m_implicit_attribute_size) { WRATHassert(m_key.valid()); WRATHAutoLockMutex(m_allocator_ptr_mutex); int bo_end_byte; switch(m_index_bits) { case WRATHAttributeStoreKey::index_8bits: m_index_type=GL_UNSIGNED_BYTE; m_index_type_size=1; bo_end_byte=256*attribute_size(); break; default: WRATHassert(0); //fall through on release builds.. case WRATHAttributeStoreKey::index_16bits: m_index_type=GL_UNSIGNED_SHORT; m_index_type_size=2; bo_end_byte=65536*attribute_size(); break; case WRATHAttributeStoreKey::index_32bits: m_index_type=GL_UNSIGNED_INT; m_index_type_size=4; bo_end_byte=std::numeric_limits<int>::max(); break; } m_vertex_buffer=WRATHNew WRATHBufferAllocator(m_allocator->triple_buffer_enabler(), m_buffer_object_hint, bo_end_byte); for(m_number_non_implicit_attributes=0; m_number_non_implicit_attributes < WRATHDrawCallSpec::attribute_count and m_attribute_format_location[m_number_non_implicit_attributes].valid(); ++m_number_non_implicit_attributes) {} for(int K=0, endK=m_implicit_attribute_format.size(), I=m_number_non_implicit_attributes; K<endK and I<WRATHDrawCallSpec::attribute_count; ++K, ++I) { m_attribute_format_location[I]=m_implicit_attribute_format[K]; } WRATHassert(proxy_attribute_allocate(1)==routine_success); if(allocate_implicit_attribute_data) { add_implicit_store(0); } unsigned int R; R=allocate_attribute_data(1); WRATHassert(R==0); WRATHunused(R); }