Array StreamPeer::_get_partial_data(int p_bytes) { Array ret; DVector<uint8_t> data; data.resize(p_bytes); if (data.size() != p_bytes) { ret.push_back(ERR_OUT_OF_MEMORY); ret.push_back(DVector<uint8_t>()); return ret; } DVector<uint8_t>::Write w = data.write(); int received; Error err = get_partial_data(&w[0], p_bytes, received); w = DVector<uint8_t>::Write(); if (err != OK) { data.resize(0); } else if (received != data.size()) { data.resize(received); } ret.push_back(err); ret.push_back(data); return ret; }
void AudioServer::sample_set_signed_data(RID p_sample, const DVector<float>& p_buffer) { SampleFormat format = sample_get_format(p_sample); ERR_EXPLAIN("IMA ADPCM is not supported."); ERR_FAIL_COND(format==SAMPLE_FORMAT_IMA_ADPCM); int len = p_buffer.size(); ERR_FAIL_COND( len == 0 ); DVector<uint8_t> data; DVector<uint8_t>::Write w; DVector<float>::Read r = p_buffer.read(); switch(format) { case SAMPLE_FORMAT_PCM8: { data.resize(len); w=data.write(); int8_t *samples8 = (int8_t*)w.ptr(); for(int i=0;i<len;i++) { float sample = Math::floor( r[i] * (1<<8) ); if (sample<-128) sample=-128; else if (sample>127) sample=127; samples8[i]=sample; } } break; case SAMPLE_FORMAT_PCM16: { data.resize(len*2); w=data.write(); int16_t *samples16 = (int16_t*)w.ptr(); for(int i=0;i<len;i++) { float sample = Math::floor( r[i] * (1<<16) ); if (sample<-32768) sample=-32768; else if (sample>32767) sample=32767; samples16[i]=sample; } } break; } w = DVector<uint8_t>::Write(); sample_set_data(p_sample,data); }
Dictionary PolygonPathFinder::_get_data() const{ Dictionary d; DVector<Vector2> p; DVector<int> ind; Array connections; p.resize(points.size()-2); connections.resize(points.size()-2); ind.resize(edges.size()*2); DVector<float> penalties; penalties.resize(points.size()-2); { DVector<Vector2>::Write wp=p.write(); DVector<float>::Write pw=penalties.write(); for(int i=0;i<points.size()-2;i++) { wp[i]=points[i].pos; pw[i]=points[i].penalty; DVector<int> c; c.resize(points[i].connections.size()); { DVector<int>::Write cw=c.write(); int idx=0; for (Set<int>::Element *E=points[i].connections.front();E;E=E->next()) { cw[idx++]=E->get(); } } connections[i]=c; } } { DVector<int>::Write iw=ind.write(); int idx=0; for (Set<Edge>::Element *E=edges.front();E;E=E->next()) { iw[idx++]=E->get().points[0]; iw[idx++]=E->get().points[1]; } } d["bounds"]=bounds; d["points"]=p; d["penalties"]=penalties; d["connections"]=connections; d["segments"]=ind; return d; }
static void _decompress_etc(Image *p_img) { ERR_FAIL_COND(p_img->get_format() != Image::FORMAT_ETC); int imgw = p_img->get_width(); int imgh = p_img->get_height(); DVector<uint8_t> src = p_img->get_data(); DVector<uint8_t> dst; DVector<uint8_t>::Read r = src.read(); int mmc = p_img->get_mipmaps(); for (int i = 0; i <= mmc; i++) { dst.resize(dst.size() + imgw * imgh * 3); const uint8_t *srcbr = &r[p_img->get_mipmap_offset(i)]; DVector<uint8_t>::Write w = dst.write(); uint8_t *wptr = &w[dst.size() - imgw * imgh * 3]; int bw = MAX(imgw / 4, 1); int bh = MAX(imgh / 4, 1); for (int y = 0; y < bh; y++) { for (int x = 0; x < bw; x++) { uint8_t block[4 * 4 * 4]; rg_etc1::unpack_etc1_block(srcbr, (unsigned int *)block); srcbr += 8; int maxx = MIN(imgw, 4); int maxy = MIN(imgh, 4); for (int yy = 0; yy < maxy; yy++) { for (int xx = 0; xx < maxx; xx++) { uint32_t src_ofs = (yy * 4 + xx) * 4; uint32_t dst_ofs = ((y * 4 + yy) * imgw + x * 4 + xx) * 3; wptr[dst_ofs + 0] = block[src_ofs + 0]; wptr[dst_ofs + 1] = block[src_ofs + 1]; wptr[dst_ofs + 2] = block[src_ofs + 2]; } } } } imgw = MAX(1, imgw / 2); imgh = MAX(1, imgh / 2); } r = DVector<uint8_t>::Read(); //print_line("Re Creating ETC into regular image: w "+itos(p_img->get_width())+" h "+itos(p_img->get_height())+" mm "+itos(p_img->get_mipmaps())); *p_img = Image(p_img->get_width(), p_img->get_height(), p_img->get_mipmaps(), Image::FORMAT_RGB, dst); if (p_img->get_mipmaps()) p_img->generate_mipmaps(-1, true); }
int VideoStreamTheoraplayer::get_pending_frame_count() const { if (!clip) return 0; if (!frame.empty()) return 1; TheoraVideoFrame* f = clip->getNextFrame(); if (!f) return 0; float w=clip->getWidth(),h=clip->getHeight(); int imgsize = w * h * f->mBpp; int size = f->getStride() * f->getHeight() * f->mBpp; DVector<uint8_t> data; data.resize(imgsize); DVector<uint8_t>::Write wr = data.write(); uint8_t* ptr = wr.ptr(); copymem(ptr, f->getBuffer(), imgsize); /* for (int i=0; i<h; i++) { int dstofs = i * w * f->mBpp; int srcofs = i * f->getStride() * f->mBpp; copymem(ptr + dstofs, f->getBuffer() + dstofs, w * f->mBpp); }; */ frame = Image(); frame.create(w, h, 0, f->mBpp == 3 ? Image::FORMAT_RGB : Image::FORMAT_RGBA, data); clip->popFrame(); return 1; };
Variant::Variant(const DVector<Face3>& p_face_array) { DVector<Vector3> vertices; int face_count=p_face_array.size(); vertices.resize(face_count*3); if (face_count) { DVector<Face3>::Read r = p_face_array.read(); DVector<Vector3>::Write w = vertices.write(); for(int i=0;i<face_count;i++) { for(int j=0;j<3;j++) w[i*3+j]=r[i].vertex[j]; } r=DVector<Face3>::Read(); w=DVector<Vector3>::Write(); } type = NIL; *this = vertices; }
DVector<int> TileMap::_get_tile_data() const { DVector<int> data; data.resize(tile_map.size()*2); DVector<int>::Write w = data.write(); int idx=0; for(const Map<PosKey,Cell>::Element *E=tile_map.front();E;E=E->next()) { uint8_t *ptr = (uint8_t*)&w[idx]; encode_uint16(E->key().x,&ptr[0]); encode_uint16(E->key().y,&ptr[2]); uint32_t val = E->get().id; if (E->get().flip_h) val|=(1<<29); if (E->get().flip_v) val|=(1<<30); encode_uint32(val,&ptr[4]); idx+=2; } w = DVector<int>::Write(); return data; }
Array ResourcePreloader::_get_resources() const { DVector<String> names; Array arr; arr.resize(resources.size()); names.resize(resources.size()); Set<String> sorted_names; for(Map<StringName,RES >::Element *E=resources.front();E;E=E->next()) { sorted_names.insert(E->key()); } int i=0; for(Set<String>::Element *E=sorted_names.front();E;E=E->next()) { names.set(i,E->get()); arr[i]=resources[E->get()]; i++; } Array res; res.push_back(names); res.push_back(arr); return res; }
String _Marshalls::variant_to_base64(const Variant& p_var) { int len; Error err = encode_variant(p_var,NULL,len); ERR_FAIL_COND_V( err != OK, "" ); DVector<uint8_t> buff; buff.resize(len); DVector<uint8_t>::Write w = buff.write(); err = encode_variant(p_var,&w[0],len); ERR_FAIL_COND_V( err != OK, "" ); int b64len = len / 3 * 4 + 4 + 1; DVector<uint8_t> b64buff; b64buff.resize(b64len); DVector<uint8_t>::Write w64 = b64buff.write(); int strlen = base64_encode((char*)(&w64[0]), (char*)(&w[0]), len); //OS::get_singleton()->print("len is %i, vector size is %i\n", b64len, strlen); w64[strlen] = 0; String ret = (char*)&w64[0]; return ret; };
RES ResourceFormatLoaderDynamicFont::load(const String &p_path, const String& p_original_path, Error *r_error) { if (r_error) *r_error=ERR_FILE_CANT_OPEN; FileAccess *f = FileAccess::open(p_path,FileAccess::READ); ERR_FAIL_COND_V(!f,RES()); DVector<uint8_t> data; data.resize(f->get_len()); ERR_FAIL_COND_V(data.size()==0,RES()); { DVector<uint8_t>::Write w = data.write(); f->get_buffer(w.ptr(),data.size()); } Ref<DynamicFontData> dfd; dfd.instance(); dfd->set_font_data(data); if (r_error) *r_error=OK; return dfd; }
void Particles2DEditorPlugin::_file_selected(const String& p_file) { print_line("file: "+p_file); int epc=epoints->get_val(); Image img; Error err = ImageLoader::load_image(p_file,&img); ERR_EXPLAIN("Error loading image: "+p_file); ERR_FAIL_COND(err!=OK); img.convert(Image::FORMAT_GRAYSCALE_ALPHA); ERR_FAIL_COND(img.get_format()!=Image::FORMAT_GRAYSCALE_ALPHA); Size2i s = Size2(img.get_width(),img.get_height()); ERR_FAIL_COND(s.width==0 || s.height==0); DVector<uint8_t> data = img.get_data(); DVector<uint8_t>::Read r = data.read(); Vector<Point2i> valid_positions; valid_positions.resize(s.width*s.height); int vpc=0; for(int i=0;i<s.width*s.height;i++) { uint8_t a = r[i*2+1]; if (a>128) { valid_positions[vpc++]=Point2i(i%s.width,i/s.width); } } valid_positions.resize(vpc); ERR_EXPLAIN("No pixels with transparency > 128 in image.."); ERR_FAIL_COND(valid_positions.size()==0); DVector<Point2> epoints; epoints.resize(epc); DVector<Point2>::Write w = epoints.write(); Size2 extents = Size2(img.get_width()*0.5,img.get_height()*0.5); for(int i=0;i<epc;i++) { Point2 p = valid_positions[Math::rand()%vpc]; p-=s/2; w[i]=p/extents; } w = DVector<Point2>::Write(); undo_redo->create_action("Set Emission Mask"); undo_redo->add_do_method(particles,"set_emission_points",epoints); undo_redo->add_do_method(particles,"set_emission_half_extents",extents); undo_redo->add_undo_method(particles,"set_emission_points",particles->get_emission_points()); undo_redo->add_undo_method(particles,"set_emission_half_extents",particles->get_emission_half_extents()); undo_redo->commit_action(); }
void AudioServer::sample_set_signed_data(RID p_sample, const DVector<float>& p_buffer) { int len = p_buffer.size(); ERR_FAIL_COND( len == 0 ); DVector<uint8_t> data; data.resize(len*2); DVector<uint8_t>::Write w=data.write(); int16_t *samples = (int16_t*)w.ptr(); DVector<float>::Read r = p_buffer.read(); for(int i=0;i<len;i++) { float sample = r[i]; sample = Math::floor( sample * (1<<16) ); if (sample<-32768) sample=-32768; else if (sample>32767) sample=32767; samples[i]=sample; } w = DVector<uint8_t>::Write(); sample_set_data(p_sample,data); }
Error jpeg_load_image_from_buffer(Image *p_image,const uint8_t* p_buffer, int p_buffer_len) { jpgd::jpeg_decoder_mem_stream mem_stream(p_buffer,p_buffer_len); jpgd::jpeg_decoder decoder(&mem_stream); if (decoder.get_error_code() != jpgd::JPGD_SUCCESS) { return ERR_CANT_OPEN; } const int image_width = decoder.get_width(); const int image_height = decoder.get_height(); int comps = decoder.get_num_components(); if (comps==3) comps=4; //weird if (decoder.begin_decoding() != jpgd::JPGD_SUCCESS) return ERR_FILE_CORRUPT; const int dst_bpl = image_width * comps; DVector<uint8_t> data; data.resize(dst_bpl * image_height); DVector<uint8_t>::Write dw = data.write(); jpgd::uint8 *pImage_data = (jpgd::uint8*)dw.ptr(); for (int y = 0; y < image_height; y++) { const jpgd::uint8* pScan_line; jpgd::uint scan_line_len; if (decoder.decode((const void**)&pScan_line, &scan_line_len) != jpgd::JPGD_SUCCESS) { return ERR_FILE_CORRUPT; } jpgd::uint8 *pDst = pImage_data + y * dst_bpl; memcpy(pDst, pScan_line, dst_bpl); } //all good Image::Format fmt; if (comps==1) fmt=Image::FORMAT_GRAYSCALE; else fmt=Image::FORMAT_RGBA; dw = DVector<uint8_t>::Write(); p_image->create(image_width,image_height,0,fmt,data); return OK; }
void EditorExportPlatformWindows::store_16(DVector<uint8_t>& vector, uint16_t value) { const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&value); int size = vector.size(); vector.resize( size + 2 ); DVector<uint8_t>::Write w = vector.write(); w[size]=bytes[0]; w[size+1]=bytes[1]; }
void image_compress_squish(Image *p_image) { int w=p_image->get_width(); int h=p_image->get_height(); if (p_image->get_mipmaps() == 0) { ERR_FAIL_COND( !w || w % 4 != 0); ERR_FAIL_COND( !h || h % 4 != 0); } else { ERR_FAIL_COND( !w || w !=nearest_power_of_2(w) ); ERR_FAIL_COND( !h || h !=nearest_power_of_2(h) ); }; if (p_image->get_format()>=Image::FORMAT_BC1) return; //do not compress, already compressed Image::AlphaMode alpha = p_image->detect_alpha(); Image::Format target_format; int shift=0; int squish_comp=squish::kColourRangeFit; switch(alpha) { case Image::ALPHA_NONE: target_format = Image::FORMAT_BC1; shift=1; squish_comp|=squish::kDxt1; break; case Image::ALPHA_BIT: target_format = Image::FORMAT_BC2; squish_comp|=squish::kDxt3; break; case Image::ALPHA_BLEND: target_format = Image::FORMAT_BC3; squish_comp|=squish::kDxt5; break; } p_image->convert(Image::FORMAT_RGBA); //always expects rgba int mm_count = p_image->get_mipmaps(); DVector<uint8_t> data; int target_size = Image::get_image_data_size(w,h,target_format,mm_count); data.resize(target_size); DVector<uint8_t>::Read rb = p_image->get_data().read(); DVector<uint8_t>::Write wb = data.write(); int dst_ofs=0; for(int i=0;i<=mm_count;i++) { int src_ofs = p_image->get_mipmap_offset(i); squish::CompressImage( &rb[src_ofs],w,h,&wb[dst_ofs],squish_comp); dst_ofs+=(MAX(4,w)*MAX(4,h))>>shift; w>>=1; h>>=1; } rb = DVector<uint8_t>::Read(); wb = DVector<uint8_t>::Write(); p_image->create(p_image->get_width(),p_image->get_height(),p_image->get_mipmaps(),target_format,data); }
DVector<Vector2> _Geometry::get_closest_points_between_segments_2d( const Vector2& p1,const Vector2& q1, const Vector2& p2,const Vector2& q2) { Vector2 r1, r2; Geometry::get_closest_points_between_segments(p1,q1,p2,q2,r1,r2); DVector<Vector2> r; r.resize(2); r.set(0,r1); r.set(1,r2); return r; }
Variant::Variant(const Vector<Color>& p_array) { type=NIL; DVector<Color> v; int len=p_array.size(); v.resize(len); for (int i=0;i<len;i++) v.set(i,p_array[i]); *this=v; }
DVector<String> ResourcePreloader::_get_resource_list() const { DVector<String> res; res.resize(resources.size()); int i=0; for(Map<StringName,RES >::Element *E=resources.front();E;E=E->next(),i++) { res.set(i,E->key()); } return res; }
DVector<Vector3> _Geometry::segment_intersects_sphere( const Vector3& p_from, const Vector3& p_to, const Vector3& p_sphere_pos,real_t p_sphere_radius) { DVector<Vector3> r; Vector3 res,norm; if (!Geometry::segment_intersects_sphere(p_from,p_to,p_sphere_pos,p_sphere_radius,&res,&norm)) return r; r.resize(2); r.set(0,res); r.set(1,norm); return r; }
DVector<Vector3> _Geometry::segment_intersects_convex(const Vector3& p_from, const Vector3& p_to,const Vector<Plane>& p_planes) { DVector<Vector3> r; Vector3 res,norm; if (!Geometry::segment_intersects_convex(p_from,p_to,p_planes.ptr(),p_planes.size(),&res,&norm)) return r; r.resize(2); r.set(0,res); r.set(1,norm); return r; }
Variant ConvexPolygonShape2DSW::get_data() const { DVector<Vector2> dvr; dvr.resize(point_count); for(int i=0;i<point_count;i++) { dvr.set(i,points[i].pos); } return dvr; }
void CollisionPolygon2D::_add_to_collision_object(Object *p_obj) { if (unparenting) return; CollisionObject2D *co = p_obj->cast_to<CollisionObject2D>(); ERR_FAIL_COND(!co); if (polygon.size()==0) return; bool solids=build_mode==BUILD_SOLIDS; if (solids) { //here comes the sun, lalalala //decompose concave into multiple convex polygons and add them Vector< Vector<Vector2> > decomp = Geometry::decompose_polygon(polygon); for(int i=0;i<decomp.size();i++) { Ref<ConvexPolygonShape2D> convex = memnew( ConvexPolygonShape2D ); convex->set_points(decomp[i]); co->add_shape(convex,get_transform()); if (trigger) co->set_shape_as_trigger(co->get_shape_count()-1,true); } } else { Ref<ConcavePolygonShape2D> concave = memnew( ConcavePolygonShape2D ); DVector<Vector2> segments; segments.resize(polygon.size()*2); DVector<Vector2>::Write w=segments.write(); for(int i=0;i<polygon.size();i++) { w[(i<<1)+0]=polygon[i]; w[(i<<1)+1]=polygon[(i+1)%polygon.size()]; } w=DVector<Vector2>::Write(); concave->set_segments(segments); co->add_shape(concave,get_transform()); if (trigger) co->set_shape_as_trigger(co->get_shape_count()-1,true); } //co->add_shape(shape,get_transform()); }
DVector<String> AnimationTreePlayer::_get_node_list() { List<StringName> nl; get_node_list(&nl); DVector<String> ret; ret.resize(nl.size()); int idx=0; for(List<StringName>::Element *E=nl.front();E;E=E->next()) { ret.set(idx++,E->get()); } return ret; }
DVector<uint8_t> _File::get_buffer(int p_length) const { DVector<uint8_t> data; ERR_FAIL_COND_V(!f,data); ERR_FAIL_COND_V(p_length<0,data); if (p_length==0) return data; Error err = data.resize(p_length); ERR_FAIL_COND_V(err!=OK,data); DVector<uint8_t>::Write w = data.write(); int len = f->get_buffer(&w[0],p_length); ERR_FAIL_COND_V( len < 0 , DVector<uint8_t>()); w = DVector<uint8_t>::Write(); if (len < p_length) data.resize(p_length); return data; }
DVector<Vector3> _Geometry::segment_intersects_cylinder( const Vector3& p_from, const Vector3& p_to, float p_height,float p_radius) { DVector<Vector3> r; Vector3 res,norm; if (!Geometry::segment_intersects_cylinder(p_from,p_to,p_height,p_radius,&res,&norm)) return r; r.resize(2); r.set(0,res); r.set(1,norm); return r; }
DVector<String> Translation::_get_message_list() const { DVector<String> msgs; msgs.resize(translation_map.size()); int idx=0; for (const Map<StringName, StringName>::Element *E=translation_map.front();E;E=E->next()) { msgs.set(idx,E->key()); idx+=1; } return msgs; }
void ThetaOperator::returnScaledNormalDistribution( int level , double stdFactor , int scaleIndex , DVector& output){ /* --- Matlab code --- L = 6; N = -1:(1/2^L):1; Fakt = 5.3; V = tan(((pi/2) - 1/Fakt)*N); V1 = 3*atan( (N).^5+0.1*(N) ); V = V ./ max(V); V1 = V1 ./ max(V1); */ // first generate linear distribution int nrPoints = powerTwo[level] + 1; DVector tmpPoints(nrPoints); output.resize(nrPoints); for (int ii = 0 ; ii < nrPoints; ii++) tmpPoints[ii] = (double)(2*ii - powerTwo[level]) / (double)(powerTwo[level]); // ---- use different scaling formulas ----- switch (scaleIndex){ case 0:{ double internFactor = 1.0/7.0; // calculate grading for (int ii = 0 ; ii < nrPoints; ii++) output[ii] = tan( (FITOB_HALF_PI - internFactor)*tmpPoints[ii]); // do the scaling for (int ii = 0 ; ii < nrPoints; ii++) output[ii] = stdFactor * output[ii] / output[nrPoints-1]; break; } case 1:{ // do some prework in the formula for (int ii = 0 ; ii < nrPoints; ii++) output[ii] = pow(tmpPoints[ii],5) + 0.1 * tmpPoints[ii]; // calculate grading for (int ii = 0 ; ii < nrPoints; ii++) output[ii] = 3.0 * atan( output[ii] ); // do the scaling for (int ii = 0 ; ii < nrPoints; ii++) output[ii] = stdFactor * output[ii] / output[nrPoints-1]; break; } } }
void Shape::add_vertices_to_array(DVector<Vector3> &array, const Transform& p_xform) { Vector<Vector3> toadd = _gen_debug_mesh_lines(); if (toadd.size()) { int base=array.size(); array.resize(base+toadd.size()); DVector<Vector3>::Write w = array.write(); for(int i=0;i<toadd.size();i++) { w[i+base]=p_xform.xform(toadd[i]); } } }
Variant::Variant(const Vector<Vector3>& p_array) { type=NIL; DVector<Vector3> v; int len=p_array.size(); if (len>0) { v.resize(len); DVector<Vector3>::Write w = v.write(); const Vector3 *r = p_array.ptr(); for (int i=0;i<len;i++) w[i]=r[i]; } *this=v; }
Variant::operator DVector<Plane>() const { Array va= operator Array(); DVector<Plane> planes; int va_size=va.size(); if (va_size==0) return planes; planes.resize(va_size); DVector<Plane>::Write w = planes.write(); for(int i=0;i<va_size;i++) w[i]=va[i]; return planes; }