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;
}
