void BakedLightBaker::_add_mesh(const Ref<Mesh>& p_mesh,const Ref<Material>& p_mat_override,const Transform& p_xform) { for(int i=0;i<p_mesh->get_surface_count();i++) { if (p_mesh->surface_get_primitive_type(i)!=Mesh::PRIMITIVE_TRIANGLES) continue; Ref<Material> mat = p_mat_override.is_valid()?p_mat_override:p_mesh->surface_get_material(i); int facecount=0; if (p_mesh->surface_get_format(i)&Mesh::ARRAY_FORMAT_INDEX) { facecount=p_mesh->surface_get_array_index_len(i); } else { facecount=p_mesh->surface_get_array_len(i); } ERR_CONTINUE((facecount==0 || (facecount%3)!=0)); facecount/=3; int tbase=triangles.size(); triangles.resize(facecount+tbase); Array a = p_mesh->surface_get_arrays(i); DVector<Vector3> vertices = a[Mesh::ARRAY_VERTEX]; DVector<Vector3>::Read vr=vertices.read(); if (p_mesh->surface_get_format(i)&Mesh::ARRAY_FORMAT_INDEX) { DVector<int> indices = a[Mesh::ARRAY_INDEX]; DVector<int>::Read ir = indices.read(); for(int i=0;i<facecount;i++) { Triangle &t=triangles[tbase+i]; t.vertices[0]=p_xform.xform(vr[ ir[i*3+0] ]); t.vertices[1]=p_xform.xform(vr[ ir[i*3+1] ]); t.vertices[2]=p_xform.xform(vr[ ir[i*3+2] ]); } } else { for(int i=0;i<facecount;i++) { Triangle &t=triangles[tbase+i]; t.vertices[0]=p_xform.xform(vr[ i*3+0 ]); t.vertices[1]=p_xform.xform(vr[ i*3+1 ]); t.vertices[2]=p_xform.xform(vr[ i*3+2 ]); } } } }
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); }
void TileMap::_set_tile_data(const DVector<int>& p_data) { int c=p_data.size(); DVector<int>::Read r = p_data.read(); for(int i=0;i<c;i+=2) { const uint8_t *ptr=(const uint8_t*)&r[i]; uint8_t local[8]; for(int j=0;j<8;j++) local[j]=ptr[j]; #ifdef BIG_ENDIAN_ENABLED SWAP(local[0],local[3]); SWAP(local[1],local[2]); SWAP(local[4],local[7]); SWAP(local[5],local[6]); #endif int x = decode_uint16(&local[0]); int y = decode_uint16(&local[2]); uint32_t v = decode_uint32(&local[4]); bool flip_h = v&(1<<29); bool flip_v = v&(1<<30); v&=(1<<29)-1; // if (x<-20 || y <-20 || x>4000 || y>4000) // continue; set_cell(x,y,v,flip_h,flip_v); } }
static int _get_number_from_token(DVector<uint8_t>& r_token) { int len = r_token.size(); DVector<uint8_t>::Read r = r_token.read(); return String::to_int((const char*)r.ptr(),len); }
static Image _lossless_unpack_png(const DVector<uint8_t>& p_data) { DVector<uint8_t>::Read r = p_data.read(); ERR_FAIL_COND_V(r[0]!='P' || r[1]!='N' || r[2]!='G' || r[3]!=' ',Image()); return _load_mem_png(&r[4]); }
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; }
void NavigationMesh::create_from_mesh(const Ref<Mesh>& p_mesh) { vertices=DVector<Vector3>(); clear_polygons(); for(int i=0;i<p_mesh->get_surface_count();i++) { if (p_mesh->surface_get_primitive_type(i)!=Mesh::PRIMITIVE_TRIANGLES) continue; Array arr = p_mesh->surface_get_arrays(i); DVector<Vector3> varr = arr[Mesh::ARRAY_VERTEX]; DVector<int> iarr = arr[Mesh::ARRAY_INDEX]; if (varr.size()==0 || iarr.size()==0) continue; int from = vertices.size(); vertices.append_array(varr); int rlen = iarr.size(); DVector<int>::Read r = iarr.read(); for(int j=0;j<rlen;j+=3) { Vector<int> vi; vi.resize(3); vi[0]=r[j+0]+from; vi[1]=r[j+1]+from; vi[2]=r[j+2]+from; add_polygon(vi); } } }
Ref<Texture> EditorPackedScenePreviewPlugin::_gen_from_imd(Ref<ResourceImportMetadata> p_imd) { if (p_imd.is_null()) { return Ref<Texture>(); } if (!p_imd->has_option("thumbnail")) return Ref<Texture>(); Variant tn = p_imd->get_option("thumbnail"); //print_line(Variant::get_type_name(tn.get_type())); DVector<uint8_t> thumbnail = tn; int len = thumbnail.size(); if (len==0) return Ref<Texture>(); DVector<uint8_t>::Read r = thumbnail.read(); Image img(r.ptr(),len); if (img.empty()) return Ref<Texture>(); Ref<ImageTexture> ptex = Ref<ImageTexture>( memnew( ImageTexture )); ptex->create_from_image(img,0); return ptex; }
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); }
Error StreamPeer::_put_data(const DVector<uint8_t> &p_data) { int len = p_data.size(); if (len == 0) return OK; DVector<uint8_t>::Read r = p_data.read(); return put_data(&r[0], len); }
void ConvexPolygonShape2DSW::set_data(const Variant& p_data) { ERR_FAIL_COND(p_data.get_type()!=Variant::VECTOR2_ARRAY && p_data.get_type()!=Variant::REAL_ARRAY); if (points) memdelete_arr(points); points=NULL; point_count=0; if (p_data.get_type()==Variant::VECTOR2_ARRAY) { DVector<Vector2> arr=p_data; ERR_FAIL_COND(arr.size()==0); point_count=arr.size(); points = memnew_arr(Point,point_count); DVector<Vector2>::Read r = arr.read(); for(int i=0;i<point_count;i++) { points[i].pos=r[i]; } for(int i=0;i<point_count;i++) { Vector2 p = points[i].pos; Vector2 pn = points[(i+1)%point_count].pos; points[i].normal=(pn-p).tangent().normalized(); } } else { DVector<real_t> dvr = p_data; point_count=dvr.size()/4; ERR_FAIL_COND(point_count==0); points = memnew_arr(Point,point_count); DVector<real_t>::Read r = dvr.read(); for(int i=0;i<point_count;i++) { int idx=i<<2; points[i].pos.x=r[idx+0]; points[i].pos.y=r[idx+1]; points[i].normal.x=r[idx+2]; points[i].normal.y=r[idx+3]; } } ERR_FAIL_COND(point_count==0); Rect2 aabb; aabb.pos=points[0].pos; for(int i=1;i<point_count;i++) aabb.expand_to(points[i].pos); configure(aabb); }
void TileMapEditor::_erase_points(const DVector<Vector2> p_points) { int len = p_points.size(); DVector<Vector2>::Read pr = p_points.read(); for (int i=0;i<len;i++) { _set_cell(pr[i], TileMap::INVALID_CELL); } }
Error PacketPeer::put_packet_buffer(const DVector<uint8_t> &p_buffer) { int len = p_buffer.size(); if (len==0) return OK; DVector<uint8_t>::Read r = p_buffer.read(); return put_packet(&r[0],len); }
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); }
void SampleManagerMallocSW::sample_set_data(RID p_sample, const DVector<uint8_t>& p_buffer) { Sample *s = sample_owner.get(p_sample); ERR_FAIL_COND(!s); int buff_size=p_buffer.size(); ERR_FAIL_COND(buff_size==0); ERR_EXPLAIN("Sample buffer size does not match sample size."); //print_line("len bytes: "+itos(s->length_bytes)+" bufsize: "+itos(buff_size)); ERR_FAIL_COND(s->length_bytes!=buff_size); DVector<uint8_t>::Read buffer_r=p_buffer.read(); const uint8_t *src = buffer_r.ptr(); uint8_t *dst = (uint8_t*)s->data; //print_line("set data: "+itos(s->length_bytes)); for(int i=0;i<s->length_bytes;i++) { dst[i]=src[i]; } switch(s->format) { case AS::SAMPLE_FORMAT_PCM8: { if (s->stereo) { dst[s->length]=dst[s->length-2]; dst[s->length+1]=dst[s->length-1]; } else { dst[s->length]=dst[s->length-1]; } } break; case AS::SAMPLE_FORMAT_PCM16: { if (s->stereo) { dst[s->length]=dst[s->length-4]; dst[s->length+1]=dst[s->length-3]; dst[s->length+2]=dst[s->length-2]; dst[s->length+3]=dst[s->length-1]; } else { dst[s->length]=dst[s->length-2]; dst[s->length+1]=dst[s->length-1]; } } break; } }
Error HTTPClient::request_raw( Method p_method, const String& p_url, const Vector<String>& p_headers,const DVector<uint8_t>& p_body) { ERR_FAIL_INDEX_V(p_method,METHOD_MAX,ERR_INVALID_PARAMETER); ERR_FAIL_COND_V(status!=STATUS_CONNECTED,ERR_INVALID_PARAMETER); ERR_FAIL_COND_V(connection.is_null(),ERR_INVALID_DATA); static const char* _methods[METHOD_MAX]={ "GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "TRACE", "CONNECT"}; String request=String(_methods[p_method])+" "+p_url+" HTTP/1.1\r\n"; request+="Host: "+conn_host+":"+itos(conn_port)+"\r\n"; bool add_clen=p_body.size()>0; for(int i=0;i<p_headers.size();i++) { request+=p_headers[i]+"\r\n"; if (add_clen && p_headers[i].find("Content-Length:")==0) { add_clen=false; } } if (add_clen) { request+="Content-Length: "+itos(p_body.size())+"\r\n"; //should it add utf8 encoding? not sure } request+="\r\n"; CharString cs=request.utf8(); DVector<uint8_t> data; //Maybe this goes faster somehow? for(int i=0;i<cs.length();i++) { data.append( cs[i] ); } data.append_array( p_body ); DVector<uint8_t>::Read r = data.read(); Error err = connection->put_data(&r[0], data.size()); if (err) { close(); status=STATUS_CONNECTION_ERROR; return err; } status=STATUS_REQUESTING; return OK; }
void _File::store_buffer(const DVector<uint8_t>& p_buffer) { ERR_FAIL_COND(!f); int len = p_buffer.size(); if (len==0) return; DVector<uint8_t>::Read r = p_buffer.read(); f->store_buffer(&r[0],len); }
void LightOccluder2D::_notification(int p_what) { if (p_what==NOTIFICATION_ENTER_CANVAS) { VS::get_singleton()->canvas_light_occluder_attach_to_canvas(occluder,get_canvas()); VS::get_singleton()->canvas_light_occluder_set_transform(occluder,get_global_transform()); VS::get_singleton()->canvas_light_occluder_set_enabled(occluder,is_visible()); } if (p_what==NOTIFICATION_TRANSFORM_CHANGED) { VS::get_singleton()->canvas_light_occluder_set_transform(occluder,get_global_transform()); } if (p_what==NOTIFICATION_VISIBILITY_CHANGED) { VS::get_singleton()->canvas_light_occluder_set_enabled(occluder,is_visible()); } if (p_what==NOTIFICATION_DRAW) { if (get_tree()->is_editor_hint()) { if (occluder_polygon.is_valid()) { DVector<Vector2> poly = occluder_polygon->get_polygon(); if (poly.size()) { if (occluder_polygon->is_closed()) { Vector<Color> color; color.push_back(Color(0,0,0,0.6)); draw_polygon(Variant(poly),color); } else { int ps=poly.size(); DVector<Vector2>::Read r = poly.read(); for(int i=0;i<ps-1;i++) { draw_line(r[i],r[i+1],Color(0,0,0,0.6),3); } } } } } } if (p_what==NOTIFICATION_EXIT_CANVAS) { VS::get_singleton()->canvas_light_occluder_attach_to_canvas(occluder,RID()); } }
void Translation::_set_messages(const DVector<String>& p_messages){ int msg_count=p_messages.size(); ERR_FAIL_COND(msg_count%2); DVector<String>::Read r = p_messages.read(); for(int i=0;i<msg_count;i+=2) { add_message( r[i+0], r[i+1] ); } }
void ConcavePolygonShape2D::draw(const RID& p_to_rid,const Color& p_color) { DVector<Vector2> s = get_segments(); int len=s.size(); if (len==0 || (len%2)==1) return; DVector<Vector2>::Read r = s.read(); for(int i=0;i<len;i+=2) { VisualServer::get_singleton()->canvas_item_add_line(p_to_rid,r[i],r[i+1],p_color,2); } }
void Font::_set_kernings(const DVector<int>& p_kernings) { int len=p_kernings.size(); ERR_FAIL_COND(len%3); if (!len) return; DVector<int>::Read r=p_kernings.read(); for(int i=0;i<len/3;i++) { const int* data = &r[i*3]; add_kerning_pair(data[0],data[1],data[2]); } }
BooleanType GnuplotWindow::getMouseEvent( double &mouseX, double &mouseY ) { DVector tmp; if (tmp.read( "mouse.dat" ) != SUCCESSFUL_RETURN) return BT_FALSE; mouseX = tmp( tmp.getDim()-2 ); mouseY = tmp( tmp.getDim()-1 ); if ( system("rm mouse.dat") ) return BT_FALSE; return BT_TRUE; }
void TileMapEditor::_fill_points(const DVector<Vector2> p_points, const Dictionary& p_op) { int len = p_points.size(); DVector<Vector2>::Read pr = p_points.read(); int id = p_op["id"]; bool xf = p_op["flip_h"]; bool yf = p_op["flip_v"]; bool tr = p_op["transpose"]; for (int i=0;i<len;i++) { _set_cell(pr[i], id, xf, yf, tr); } }
Variant _File::get_var() const { ERR_FAIL_COND_V(!f,Variant()); uint32_t len = get_32(); DVector<uint8_t> buff = get_buffer(len); ERR_FAIL_COND_V(buff.size() != len, Variant()); DVector<uint8_t>::Read r = buff.read(); Variant v; Error err = decode_variant(v,&r[0],len); ERR_FAIL_COND_V( err!=OK, Variant() ); return v; }
void Font::_set_chars(const DVector<int>& p_chars) { int len = p_chars.size(); //char 1 charsize 1 texture, 4 rect, 2 align, advance 1 ERR_FAIL_COND(len%9); if (!len) return; //none to do int chars = len/9; DVector<int>::Read r=p_chars.read(); for(int i=0;i<chars;i++) { const int* data = &r[i*9]; add_char(data[0],data[1],Rect2(data[2],data[3],data[4],data[5]), Size2(data[6],data[7]),data[8]); } }
void SampleManagerMallocSW::sample_set_data(RID p_sample, const DVector<uint8_t>& p_buffer) { Sample *s = sample_owner.get(p_sample); ERR_FAIL_COND(!s); int buff_size=p_buffer.size(); ERR_FAIL_COND(buff_size==0); ERR_EXPLAIN("Sample buffer size does not match sample size."); ERR_FAIL_COND(s->length_bytes!=buff_size); DVector<uint8_t>::Read buffer_r=p_buffer.read(); const uint8_t *src = buffer_r.ptr(); uint8_t *dst = (uint8_t*)s->data; for(int i=0;i<s->length_bytes;i++) { dst[i]=src[i]; } }
Rect2 ConcavePolygonShape2D::get_rect() const { DVector<Vector2> s = get_segments(); int len=s.size(); if (len==0) return Rect2(); Rect2 rect; DVector<Vector2>::Read r = s.read(); for(int i=0;i<len;i++) { if (i==0) rect.pos=r[i]; else rect.expand_to(r[i]); } return rect; }
Array StreamPeer::_put_partial_data(const DVector<uint8_t> &p_data) { Array ret; int len = p_data.size(); if (len == 0) { ret.push_back(OK); ret.push_back(0); return ret; } DVector<uint8_t>::Read r = p_data.read(); int sent; Error err = put_partial_data(&r[0], len, sent); if (err != OK) { sent = 0; } ret.push_back(err); ret.push_back(sent); return ret; }
virtual Variant call(const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error) { print_line("attempt to call "+String(p_method)); r_error.error=Variant::CallError::CALL_OK; Map<StringName,MethodData >::Element *E=method_map.find(p_method); if (!E) { print_line("no exists"); r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD; return Variant(); } int ac = E->get().argtypes.size(); if (ac<p_argcount) { print_line("fewargs"); r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS; r_error.argument=ac; return Variant(); } if (ac>p_argcount) { print_line("manyargs"); r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS; r_error.argument=ac; return Variant(); } for(int i=0;i<p_argcount;i++) { if (!Variant::can_convert(p_args[i]->get_type(),E->get().argtypes[i])) { r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; r_error.argument=i; r_error.expected=E->get().argtypes[i]; } } jvalue *v=NULL; if (p_argcount) { v=(jvalue*)alloca( sizeof(jvalue)*p_argcount ); } for(int i=0;i<p_argcount;i++) { switch(E->get().argtypes[i]) { case Variant::BOOL: { v[i].z=*p_args[i]; } break; case Variant::INT: { v[i].i=*p_args[i]; } break; case Variant::REAL: { v[i].f=*p_args[i]; } break; case Variant::STRING: { String s = *p_args[i]; jstring jStr = env->NewStringUTF(s.utf8().get_data()); v[i].l=jStr; } break; case Variant::STRING_ARRAY: { DVector<String> sarray = *p_args[i]; jobjectArray arr = env->NewObjectArray(sarray.size(),env->FindClass("java/lang/String"),env->NewStringUTF("")); for(int j=0;j<sarray.size();j++) { env->SetObjectArrayElement(arr,j,env->NewStringUTF( sarray[i].utf8().get_data() )); } v[i].l=arr; } break; case Variant::INT_ARRAY: { DVector<int> array = *p_args[i]; jintArray arr = env->NewIntArray(array.size()); DVector<int>::Read r = array.read(); env->SetIntArrayRegion(arr,0,array.size(),r.ptr()); v[i].l=arr; } break; case Variant::REAL_ARRAY: { DVector<float> array = *p_args[i]; jfloatArray arr = env->NewFloatArray(array.size()); DVector<float>::Read r = array.read(); env->SetFloatArrayRegion(arr,0,array.size(),r.ptr()); v[i].l=arr; } break; default: { ERR_FAIL_V(Variant()); } break; } } print_line("calling method!!"); Variant ret; switch(E->get().ret_type) { case Variant::NIL: { print_line("call void"); env->CallVoidMethodA(instance,E->get().method,v); } break; case Variant::BOOL: { ret = env->CallBooleanMethodA(instance,E->get().method,v); print_line("call bool"); } break; case Variant::INT: { ret = env->CallIntMethodA(instance,E->get().method,v); print_line("call int"); } break; case Variant::REAL: { ret = env->CallFloatMethodA(instance,E->get().method,v); } break; case Variant::STRING: { jobject o = env->CallObjectMethodA(instance,E->get().method,v); String singname = env->GetStringUTFChars((jstring)o, NULL ); } break; case Variant::STRING_ARRAY: { jobjectArray arr = (jobjectArray)env->CallObjectMethodA(instance,E->get().method,v); int stringCount = env->GetArrayLength(arr); DVector<String> sarr; for (int i=0; i<stringCount; i++) { jstring string = (jstring) env->GetObjectArrayElement(arr, i); const char *rawString = env->GetStringUTFChars(string, 0); sarr.push_back(String(rawString)); } ret=sarr; } break; case Variant::INT_ARRAY: { jintArray arr = (jintArray)env->CallObjectMethodA(instance,E->get().method,v); int fCount = env->GetArrayLength(arr); DVector<int> sarr; sarr.resize(fCount); DVector<int>::Write w = sarr.write(); env->GetIntArrayRegion(arr,0,fCount,w.ptr()); w = DVector<int>::Write(); ret=sarr; } break; case Variant::REAL_ARRAY: { jfloatArray arr = (jfloatArray)env->CallObjectMethodA(instance,E->get().method,v); int fCount = env->GetArrayLength(arr); DVector<float> sarr; sarr.resize(fCount); DVector<float>::Write w = sarr.write(); env->GetFloatArrayRegion(arr,0,fCount,w.ptr()); w = DVector<float>::Write(); ret=sarr; } break; default: { print_line("failure.."); ERR_FAIL_V(Variant()); } break; } print_line("success"); return ret; }