void BigMsg::__secure_cap(size_t cap) { if(!cap) return; if(_mem_info.cap >= cap) return; if(!_mem_info.ptr) if(!NetPools::_queue_reusable_bigmsg_mem.deq(_mem_info)) { _mem_info.ptr = new char[GROW_SIZE]; Z_ASSERT(_mem_info.ptr != 0); _mem_info.cap = GROW_SIZE; } if(cap > _mem_info.cap) { size_t newsize = (cap + GROW_SIZE - 1) / GROW_SIZE * GROW_SIZE; void* newptr = realloc(_mem_info.ptr, newsize); if(newptr) { _mem_info.ptr = newptr; _mem_info.cap = newsize; } else { newptr = new char[newsize]; Z_ASSERT(newptr != 0); memcpy(newptr, _mem_info.ptr, _mem_info.cap); delete[] (char*)_mem_info.ptr; _mem_info.ptr = newptr; _mem_info.cap = newsize; } } }
static int __test_compress (z_test_t *test) { z_decompressor_t decompressor; z_compressor_t compressor; unsigned char block[8192]; unsigned int blksize; char buffer[512]; int nitems; int count; int i; z_compressor_init(&compressor, buffer, sizeof(buffer), block, sizeof(block), z_lz4_compress); for (i = 0; i < 1000000; ++i) { char str[64]; int n = snprintf(str, sizeof(str), "Data-%010d:", i); if (z_compressor_add(&compressor, str, n)) { fprintf(stderr, "break %s\n", str); break; } } z_compressor_flush(&compressor); nitems = i; blksize = z_compressor_flushed_size(&compressor); count = 0; z_decompressor_open(&decompressor, block, blksize, z_lz4_decompress); while (1) { char buffer[512]; char *pbuf = buffer; int bufsize = z_decompressor_read(&decompressor, buffer, sizeof(buffer)); if (bufsize <= 0) break; Z_ASSERT(bufsize <= sizeof(buffer), "Unexpected uncompressed size %"PRIu32, bufsize); while (bufsize > 0) { char str[64]; int n = snprintf(str, sizeof(str), "Data-%010d:", count); Z_ASSERT(z_memeq(pbuf, str, n), "Unexpected value %s != %s", str, pbuf); pbuf += n; bufsize -= n; count++; } } z_decompressor_close(&decompressor); return((1 + count) != nitems); }
void Jotter::tc(uint8_t tc_set, REAL s, REAL t) { Z_ASSERT(tc_set < MAX_TEXCOORD_SETS); REAL* p = &_vert_tc[tc_set].x; p[0] = s; p[1] = t; }
SPtr<ocTriTree> ocTriTree::create(const Vec3* verts, size_t vert_count, const INT3* tris, size_t tri_count) { Z_ASSERT( vert_count && tri_count ); ocTriTree* tree = new ocTriTree(); tree->_verts.resize(vert_count); tree->_tris.resize(tri_count); memcpy(&*tree->_verts.begin(), verts, vert_count * sizeof(verts[0])); memcpy(&*tree->_tris.begin(), tris, tri_count * sizeof(tris[0])); tree->_pimpl.get().mesh_interface.SetNbVertices((udword)vert_count); tree->_pimpl.get().mesh_interface.SetNbTriangles((udword)tri_count); tree->_pimpl.get().mesh_interface.SetPointers((const IceMaths::IndexedTriangle*)&*tree->_tris.begin(), (const IceMaths::Point*)&*tree->_verts.begin()); Opcode::OPCODECREATE opcc; opcc.mIMesh = &tree->_pimpl.get().mesh_interface; opcc.mNoLeaf = true; opcc.mQuantized = false; opcc.mKeepOriginal = false; opcc.mCanRemap = false; bool status = tree->_pimpl.get().model.Build(opcc); if(!status) { delete tree; return NULL; } return tree; }
void zp_obj::dump(int level, z_file& outf,int flags) { zo_ftr_entry* f; int indent=level; while(indent--) outf<<" "; //outf<<get_map_key()<<'['<<(int)_offset<<']'<< " "; outf<<get_map_key()<< "["; dump_custom(outf); /* zo_feature_list full_list; get_feature_map(&g_man,full_list,ZO_MT_PROP,false); full_list.reset_iter(); while(f=full_list.get_next()) { ctext name=full_list._internal_iter.key; outf<<name<<','; this->get_feature }*/ outf<<"]\n"; if(!_children) return; size_t size=_children->size(); size_t i; for(i=0;i<size;i++) { zp_obj* item=_children->at(i); Z_ASSERT(item); item->dump(level+1,outf,flags); } }
QtOpenGLRenderThread::QtOpenGLRenderThread(QGLWidget* gl, QtOpenGLWindowDelegate* delegate) : m_GL(gl) , m_Delegate(delegate) , m_Suspended(false) , m_ShuttingDown(false) { Z_ASSERT(delegate != nullptr); }
static int __test_int (z_test_t *test) { z_decompressor_t decompressor; z_compressor_t compressor; unsigned char block[8192]; unsigned int i, count; unsigned int blksize; char buffer[512]; int nitems; z_compressor_init(&compressor, buffer, sizeof(buffer), block, sizeof(block), z_plain_compress); for (i = 0; i < 1000000; ++i) { if (z_compressor_add_int(&compressor, 5)) { fprintf(stderr, "break %"PRIu32"\n", i); break; } } z_compressor_flush(&compressor); nitems = i; blksize = z_compressor_flushed_size(&compressor); count = 0; z_decompressor_open(&decompressor, block, blksize, z_plain_decompress); while (1) { uint8_t buffer[512]; uint8_t *pbuf = buffer; int bufsize = z_decompressor_read(&decompressor, buffer, sizeof(buffer)); if (bufsize <= 0) break; Z_ASSERT(bufsize <= sizeof(buffer), "Unexpected uncompressed size %d", bufsize); while (bufsize > 0) { uint64_t value = 0; int n = z_decompressor_get_int(&decompressor, pbuf, bufsize, &value); Z_ASSERT(value == 5, "Unexpected value %lu count %"PRIu32, value, count); pbuf += n; bufsize -= n; count++; } } z_decompressor_close(&decompressor); return((1 + count) != nitems); }
void d4_assert(bool a) { if(!a) { Z_ASSERT(0); Z_ERROR_MSG(zs_unknown_error,"metakit error"); } }
static void __object_revert (raleighsl_t *fs, raleighsl_object_t *object, raleighsl_txn_atom_t *atom) { raleighsl_number_t *number = RALEIGHSL_NUMBER(object->membufs); Z_ASSERT(atom == &(number->__txn_atom__), "Wrong TXN atom"); number->write_value = number->read_value; number->txn_id = 0; }
void z_bytes_ref_acquire (z_bytes_ref_t *self, const z_bytes_ref_t *other) { if (Z_UNLIKELY(self == NULL)) return; Z_ASSERT(other != NULL, "the ref to acquire must be NOT NULL"); z_bytes_ref_set(self, &(other->slice), other->vtable, other->object); if (self->object != NULL) { self->vtable->inc_ref(self->object); } }
void CtrlSet::detachCtrl(const SPtr<CtrlBase>& ctrl) { vector<SPtr<CtrlBase>>::iterator iter = find(_ctrls.begin(), _ctrls.end(), ctrl); if(iter != _ctrls.end()) _ctrls.erase(iter); else { Z_ASSERT( false ); } }
SkeletonAnimationPtr Mesh::addAnimation(const Utf8String& name) { Z_ASSERT(m_Skeleton != nullptr); SkeletonAnimationPtr animation = std::make_shared<SkeletonAnimation>(m_Skeleton, name); m_Animations.push_back(animation); m_AnimationsByName.insert(std::make_pair(name, animation)); return animation; }
z_status zf_feature_node::append_to_path(z_string &path) { Z_ASSERT(_f); path<< _f->get_name(); if(_index) { path<<'['<<_index<<']'; } return zs_ok; }
int z_compressor_add_int (z_compressor_t *self, uint64_t current) { uint8_t buffer[16]; int n; if (__compressor_emergency_flush(self, 4)) return(1); Z_ASSERT(current >= self->iprev, "the assumption is that the numbers are sorted"); n = z_encode_vint(buffer, current - self->iprev); self->iprev = current; return(__compressor_add_buffer(self, buffer, n)); }
void z_bytes_ref_set (z_bytes_ref_t *self, const z_byte_slice_t *slice, const z_vtable_refs_t *vtable, void *object) { if (Z_UNLIKELY(self == NULL)) return; Z_ASSERT((object == NULL && vtable == NULL) || (object != NULL && vtable != NULL), "vtable must be specified if the object is NOT NULL"); z_byte_slice_copy(&(self->slice), slice); self->vtable = vtable; self->object = object; }
U32 zp_test_result::get_result(U32 index) { Z_ASSERT((_test_results.size()>index+4)); if(_test_results.size()<=index+4) return 0; U32 result=_test_results[index]; if(result==zp_result_extended_value) { result=_test_results_ex[index]; } return result; }
int zmpil_simple_create_derived(zmpil_simple_t *mpil, MPI_Datatype type, int count) /* zmpi_func zmpil_simple_create_derived */ { /* mpil->type = type;*/ Z_TRACE("zmpil_simple_create_derived"); MPI_Type_get_true_extent(type, &mpil->true_lb, &mpil->true_extent); mpil->true_extent *= count; Z_ASSERT(mpil->true_lb == 0); return 0; }
void QtOpenGLRenderThread::start(int width, int height) { Z_ASSERT(!isRunning()); m_GL->doneCurrent(); m_GL->context()->moveToThread(this); ViewportSize size; size.set(width, height); m_ViewportSize.store(size.packed); m_ThreadStartPromise = std::promise<void>(); std::future<void> future = m_ThreadStartPromise.get_future(); QThread::start(); future.wait(); }
zp_obj* zp_obj::get_obj_by_name(ctext type,ctext name) { size_t iter=0; zp_obj* child=0; while(1) { child=get_item_next_obj(type,iter); if(!child) break; /* if(strcmp(name,child->get_label())==0) return child; */ Z_ASSERT((0)); } return 0; }
z_status zp_parser::parse_obj(void* p_obj,const zp_factory* factory,ctext data) { z_status status; Z_ASSERT(p_obj); set_source(data,strlen(data)); reset_results(); factory->clear_all_vars(p_obj); context_set_root(p_obj,factory,0); status=_process_template(zp_mode_parse_input); if(status==zs_matched) { ZT("==========ITEM[%s] MATCHED, CREATING=====\n",factory->get_name()); index_reset(); context_get_current_template_parser().index_reset(); reset_results(); status=_process_template(zp_mode_parse_create); } return status; }
/* ============================================================================ * PRIVATE Compressor methods */ static int __compressor_flush_buffer (z_compressor_t *self, const uint8_t *data, size_t size) { uint8_t *dst = self->dst_buffer + (self->dst_size - self->dst_avail); unsigned int size_len; size_t data_len; Z_ASSERT(size > 0, "Flush size must be not zero: %zu", size); /* write uncompressed block size */ size_len = z_encode_vint(dst, size); dst += size_len; /* write compressed data */ data_len = self->codec(dst, self->dst_avail - size_len, data, size); self->dst_avail -= (data_len > 0) ? (size_len + data_len) : 0; self->bufavail = self->bufsize; z_byte_slice_clear(&(self->bprev)); self->iprev = 0; return(data_len); }
const z_map_entry_t *z_map_merger_next (z_map_merger_t *self) { const z_map_entry_t *smallest_entry = NULL; z_map_iterator_t *iter; if (Z_UNLIKELY(z_dlink_is_empty(&(self->merge_list)))) return(NULL); if (self->smallest_iter != NULL) { if (!z_map_iterator_next(self->smallest_iter)) { z_dlink_del(&(self->smallest_iter->head.merge_list)); } self->smallest_iter = NULL; } /* TODO: Optimize me */ z_dlink_for_each_safe_entry(&(self->merge_list), iter, z_map_iterator_t, head.merge_list, { const z_map_entry_t *entry = z_map_iterator_current(iter); Z_ASSERT(entry != NULL, "NULL Entry for iterator %p", iter); #if 0 fprintf(stderr, "MERGER CMP %p: ", iter); z_dump_map_entry(stderr, entry); #endif if (smallest_entry == NULL) { self->smallest_iter = iter; smallest_entry = entry; } else { int cmp = z_byte_slice_compare(&(entry->key), &(smallest_entry->key)); if (cmp < 0) { self->smallest_iter = iter; smallest_entry = entry; } else if (cmp == 0 && self->skip_equals) { if (!z_map_iterator_next(iter)) { z_dlink_del(&(iter->head.merge_list)); } } } });
z_status zp_parser::_process_stage(zp_mode mode,zp_flags* pflags) { //ZTF; z_status status; zp_flags flags; status=get_flags(flags); if(status) return status; if(pflags) *pflags=flags; //return flags to caller zp_text_parser& tmpl=context_get_current_template_parser(); ctext tpl_start=tmpl.get_index(); if(mode.skip_test) { status=_process_single_item(mode,flags); Z_ASSERT(( status==zs_skipped)); return status; } if(mode.output) { int sanity_check_count=0; bool satified=false; while(1) { Z_ASSERT(sanity_check_count++<100); ctext data_start=get_index(); if(satified) flags.required=0; status=_process_single_item(mode,flags); if(status==zs_matched) { if(flags.multi) { tmpl.set_index(tpl_start); satified=true; continue; } } if(status==zs_skipped) status=zs_matched; if((status==zs_no_match)||(status==zs_eof)) { if(satified) status=zs_matched; } break; } return status; }//End of output if(mode.input_text) { U32 result_index_multi_success_mark=0; U32 testnum=_test_result_current_index; Z_ASSERT((_results)); _test_result_current_index++; if(!mode.create) { U32 result=0; U32 quanity_matched=0; ZT("TEST#%d START>>",testnum); _results->set_result(testnum,zp_result_unknown); SANITY_CHECK( _results->_test_result_tmpl[testnum]=tpl_start; ctext sanity_check_data_index=0; U32 sanity_check_loop_count=0; );
ctext zp_obj::get_template() { const z_obj_fact* ei=get_fact(); Z_ASSERT(0); return ei->parse_string; }
ctext zp_obj::get_map_key() { const z_obj_fact* ei=get_fact(); Z_ASSERT((ei)); return z_obj_fact_get_name(get_fact()); }
void Jotter::tc(uint8_t tc_set, const REAL tc) { Z_ASSERT(tc_set < MAX_TEXCOORD_SETS); _vert_tc[tc_set].x = tc; }
void MorpherCtrl::setChannelWeight(size_t channel_index, REAL weight) { Z_ASSERT( channel_index < _channels.size() ); _channels[channel_index].weight = weight; }
void Jotter::tc(uint8_t tc_set, const Vec3& tc) { Z_ASSERT(tc_set < MAX_TEXCOORD_SETS); *(Vec3*)&_vert_tc[tc_set] = tc; }
void MorpherCtrl::update(REAL dt) { if(!_mesh_node.valid()) return; Z_ASSERT( find(_mesh_node.get_unsafe()->getCtrlSet().getArray().begin(), _mesh_node.get_unsafe()->getCtrlSet().getArray().end(), this) != _mesh_node.get_unsafe()->getCtrlSet().getArray().end()); _anim_ctrl.advance(dt); REAL t = _anim_ctrl.current_stage().getTime(); for(size_t i = 0; i < _channels.size(); ++i) { Channel& ch = _channels[i]; if(ch.eval_weight.anim_data()) ch.weight = ch.eval_weight.sample(t); } SMeshNode* node = (SMeshNode*)_mesh_node.get_unsafe(); Mesh& mesh = *node->mesh().get(); if(isFirstDeformer(_mesh_node.lock(), VertexDeformCtrlBase::ATTRIB_TYPE_POSITION)) {} else {} Vec3* verts; Vec3* norms; if(true) { vector<Vec3>& array_vert = mesh.data.verts.edit(); vector<Vec3>& array_norm = mesh.data.norms.edit(); array_vert.resize(_morpher_data->vert_count); array_norm.resize(_morpher_data->norm_count); verts = VECTOR_BEGIN_PTR(array_vert); norms = VECTOR_BEGIN_PTR(array_norm); } MorpherData* morpher_data = _morpher_data.get(); memcpy(verts, morpher_data->base_verts, sizeof(Vec3) * morpher_data->vert_count); memcpy(norms, morpher_data->base_norms, sizeof(Vec3) * morpher_data->norm_count); for(size_t i = 0; i < _channels.size(); ++i) { Channel& ch = _channels[i]; REAL weight = ch.weight; if(FABS(weight) <= EPSILON) continue; #ifndef _OPENMP if(true) { Vec3* dst = verts; const Vec3* src_end = morpher_data->chans_verts[i] + morpher_data->vert_count; for(const Vec3* src = morpher_data->chans_verts[i]; src != src_end; ++src, ++dst) *dst += *src * weight; } #else if(true) { const Vec3* src = morpher_data->chans_verts[i]; Vec3* dst = verts; ptrdiff_t c = (ptrdiff_t)morpher_data->vert_count; #pragma omp parallel for for(ptrdiff_t j = 0; j < c; ++j) dst[j] += src[j] * weight; } #endif #ifndef _OPENMP if(true) { Vec3* dst = norms; const Vec3* src_end = morpher_data->chans_norms[i] + morpher_data->norm_count; for(const Vec3* src = morpher_data->chans_norms[i]; src != src_end; ++src, ++dst) *dst += *src * weight; } #else if(true) { const Vec3* src = morpher_data->chans_norms[i]; Vec3* dst = norms; ptrdiff_t c = (ptrdiff_t)morpher_data->norm_count; #pragma omp parallel for for(ptrdiff_t j = 0; j < c; ++j) dst[j] += src[j] * weight; } #endif } // about LOD, we can sort processing channels in descending order by the weight, then depending on the LOD, process up to a number of channels node->markDirtyBound(); node->clearSPT(); }
void MorpherCtrl::setChannelWeightAnimData(size_t channel_index, const SPtr< AnimData<REAL> >& animdata) { Z_ASSERT( channel_index < _channels.size() ); _channels[channel_index].eval_weight = animdata; }