asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Variant INT and REAL are now 64 bits (other types remain at 32)

Browse source
This commit is contained in:
Juan Linietsky 2017-01-08 20:58:39 -03:00
parent 94ee7798ce
commit 13cdccf23b
9 changed files with 202 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

100
core/io/marshalls.cpp
View file

@ -31,6 +31,10 @@
#include "os/keyboard.h" #include "os/keyboard.h"
#include <stdio.h> #include <stdio.h>
#define ENCODE_MASK 0xFF
#define ENCODE_FLAG_64 1<<16
Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int *r_len) { Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int *r_len) {
const uint8_t * buf=p_buffer; const uint8_t * buf=p_buffer;
@ -44,14 +48,14 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int *
uint32_t type=decode_uint32(buf); uint32_t type=decode_uint32(buf);
ERR_FAIL_COND_V(type>=Variant::VARIANT_MAX,ERR_INVALID_DATA); ERR_FAIL_COND_V((type&ENCODE_MASK)>=Variant::VARIANT_MAX,ERR_INVALID_DATA);
buf+=4; buf+=4;
len-=4; len-=4;
if (r_len) if (r_len)
*r_len=4; *r_len=4;
switch(type) { switch(type&ENCODE_MASK) {
case Variant::NIL: { case Variant::NIL: {
@ -68,19 +72,35 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int *
case Variant::INT: { case Variant::INT: {
ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA);
int val = decode_uint32(buf); if (type&ENCODE_FLAG_64) {
r_variant=val; int64_t val = decode_uint64(buf);
if (r_len) r_variant=val;
(*r_len)+=4; if (r_len)
(*r_len)+=8;
} else {
int32_t val = decode_uint32(buf);
r_variant=val;
if (r_len)
(*r_len)+=4;
}
} break; } break;
case Variant::REAL: { case Variant::REAL: {
ERR_FAIL_COND_V(len<(int)4,ERR_INVALID_DATA); ERR_FAIL_COND_V(len<(int)4,ERR_INVALID_DATA);
float val = decode_float(buf);
r_variant=val; if (type&ENCODE_FLAG_64) {
if (r_len) double val = decode_double(buf);
(*r_len)+=4; r_variant=val;
if (r_len)
(*r_len)+=8;
} else {
float val = decode_float(buf);
r_variant=val;
if (r_len)
(*r_len)+=4;
}
} break; } break;
case Variant::STRING: { case Variant::STRING: {
@ -796,8 +816,28 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) {
r_len=0; r_len=0;
uint32_t flags=0;
switch(p_variant.get_type()) {
case Variant::INT: {
int64_t val = p_variant;
if (val>0x7FFFFFFF || val < -0x80000000) {
flags|=ENCODE_FLAG_64;
}
} break;
case Variant::REAL: {
double d = p_variant;
float f = d;
if (double(f)!=d) {
flags|=ENCODE_FLAG_64; //always encode real as double
}
} break;
}
if (buf) { if (buf) {
encode_uint32(p_variant.get_type(),buf); encode_uint32(p_variant.get_type()|flags,buf);
buf+=4; buf+=4;
} }
r_len+=4; r_len+=4;
@ -819,20 +859,42 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) {
} break; } break;
case Variant::INT: { case Variant::INT: {
if (buf) { int64_t val = p_variant;
encode_uint32(p_variant.operator int(),buf); if (val>0x7FFFFFFF || val < -0x80000000) {
//64 bits
if (buf) {
encode_uint64(val,buf);
}
r_len+=8;
} else {
if (buf) {
encode_uint32(int32_t(val),buf);
}
r_len+=4;
} }
r_len+=4;
} break; } break;
case Variant::REAL: { case Variant::REAL: {
if (buf) { double d = p_variant;
encode_float(p_variant.operator float(),buf); float f = d;
if (double(f)!=d) {
if (buf) {
encode_double(p_variant.operator double(),buf);
}
r_len+=8;
} else {
if (buf) {
encode_double(p_variant.operator float(),buf);
}
r_len+=4;
} }
r_len+=4;
} break; } break;
case Variant::NODE_PATH: { case Variant::NODE_PATH: {

40
core/io/resource_format_binary.cpp
View file

@ -68,6 +68,8 @@ enum {
VARIANT_VECTOR3_ARRAY=35, VARIANT_VECTOR3_ARRAY=35,
VARIANT_COLOR_ARRAY=36, VARIANT_COLOR_ARRAY=36,
VARIANT_VECTOR2_ARRAY=37, VARIANT_VECTOR2_ARRAY=37,
VARIANT_INT64=40,
VARIANT_DOUBLE=41,
IMAGE_ENCODING_EMPTY=0, IMAGE_ENCODING_EMPTY=0,
IMAGE_ENCODING_RAW=1, IMAGE_ENCODING_RAW=1,
@ -116,10 +118,18 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v) {
r_v=int(f->get_32()); r_v=int(f->get_32());
} break; } break;
case VARIANT_INT64: {
r_v=int64_t(f->get_64());
} break;
case VARIANT_REAL: { case VARIANT_REAL: {
r_v=f->get_real(); r_v=f->get_real();
} break; } break;
case VARIANT_DOUBLE: {
r_v=f->get_double();
} break;
case VARIANT_STRING: { case VARIANT_STRING: {
r_v=get_unicode_string(); r_v=get_unicode_string();
@ -1416,15 +1426,33 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property,
} break; } break;
case Variant::INT: { case Variant::INT: {
f->store_32(VARIANT_INT); int64_t val = p_property;
int val=p_property; if (val>0x7FFFFFFF || val < -0x80000000) {
f->store_32(val); f->store_32(VARIANT_INT64);
f->store_64(val);
} else {
f->store_32(VARIANT_INT);
int val=p_property;
f->store_32(int32_t(val));
}
} break; } break;
case Variant::REAL: { case Variant::REAL: {
f->store_32(VARIANT_REAL);
real_t val=p_property; double d = p_property;
f->store_real(val); float fl = d;
if (double(fl)!=d) {
f->store_32(VARIANT_DOUBLE);
f->store_double(d);
} else {
f->store_32(VARIANT_REAL);
f->store_real(fl);
}
} break; } break;
case Variant::STRING: { case Variant::STRING: {

96
core/ustring.cpp
View file

@ -1547,20 +1547,20 @@ String::String(const StrRange& p_range) {
int String::hex_to_int(bool p_with_prefix) const { int String::hex_to_int(bool p_with_prefix) const {
int l = length(); int l = length();
if (p_with_prefix && l<3) if (p_with_prefix && l<3)
return 0; return 0;
const CharType *s=ptr(); const CharType *s=ptr();
int sign = s[0]=='-' ? -1 : 1; int sign = s[0]=='-' ? -1 : 1;
if (sign<0) { if (sign<0) {
s++; s++;
l--; l--;
if (p_with_prefix && l<2) if (p_with_prefix && l<2)
return 0; return 0;
} }
if (p_with_prefix) { if (p_with_prefix) {
if (s[0]!='0' || s[1]!='x') if (s[0]!='0' || s[1]!='x')
@ -1569,26 +1569,74 @@ int String::hex_to_int(bool p_with_prefix) const {
l-=2; l-=2;
}; };
int hex=0; int hex=0;
while(*s) { while(*s) {
CharType c = LOWERCASE(*s); CharType c = LOWERCASE(*s);
int n; int n;
if (c>='0' && c<='9') { if (c>='0' && c<='9') {
n=c-'0'; n=c-'0';
} else if (c>='a' && c<='f') { } else if (c>='a' && c<='f') {
n=(c-'a')+10; n=(c-'a')+10;
} else { } else {
return 0; return 0;
} }
hex*=16; hex*=16;
hex+=n; hex+=n;
s++; s++;
} }
return hex*sign; return hex*sign;
}
int64_t String::hex_to_int64(bool p_with_prefix) const {
int l = length();
if (p_with_prefix && l<3)
return 0;
const CharType *s=ptr();
int64_t sign = s[0]=='-' ? -1 : 1;
if (sign<0) {
s++;
l--;
if (p_with_prefix && l<2)
return 0;
}
if (p_with_prefix) {
if (s[0]!='0' || s[1]!='x')
return 0;
s+=2;
l-=2;
};
int64_t hex=0;
while(*s) {
CharType c = LOWERCASE(*s);
int64_t n;
if (c>='0' && c<='9') {
n=c-'0';
} else if (c>='a' && c<='f') {
n=(c-'a')+10;
} else {
return 0;
}
hex*=16;
hex+=n;
s++;
}
return hex*sign;
} }

1
core/ustring.h
View file

@ -147,6 +147,7 @@ public:
int hex_to_int(bool p_with_prefix = true) const; int hex_to_int(bool p_with_prefix = true) const;
int to_int() const; int to_int() const;
int64_t hex_to_int64(bool p_with_prefix = true) const;
int64_t to_int64() const; int64_t to_int64() const;
static int to_int(const char* p_str, int p_len=-1); static int to_int(const char* p_str, int p_len=-1);
static double to_double(const char* p_str); static double to_double(const char* p_str);

6
core/variant.cpp
View file

@ -1467,7 +1467,7 @@ Variant::operator double() const {
case NIL: return 0; case NIL: return 0;
case BOOL: return _data._bool ? 1.0 : 0.0; case BOOL: return _data._bool ? 1.0 : 0.0;
case INT: return (float)_data._int; case INT: return (double)_data._int;
case REAL: return _data._real; case REAL: return _data._real;
case STRING: return operator String().to_double(); case STRING: return operator String().to_double();
default: { default: {
@ -1504,8 +1504,8 @@ Variant::operator String() const {
case NIL: return "Null"; case NIL: return "Null";
case BOOL: return _data._bool ? "True" : "False"; case BOOL: return _data._bool ? "True" : "False";
case INT: return String::num(_data._int); case INT: return itos(_data._int);
case REAL: return String::num(_data._real); case REAL: return rtos(_data._real);
case STRING: return *reinterpret_cast<const String*>(_data._mem); case STRING: return *reinterpret_cast<const String*>(_data._mem);
case VECTOR2: return "("+operator Vector2()+")"; case VECTOR2: return "("+operator Vector2()+")";
case RECT2: return "("+operator Rect2()+")"; case RECT2: return "("+operator Rect2()+")";

2
core/variant.h
View file

@ -141,7 +141,7 @@ private:
union { union {
bool _bool; bool _bool;
int _int; int64_t _int;
double _real; double _real;
Matrix32 *_matrix32; Matrix32 *_matrix32;
AABB* _aabb; AABB* _aabb;

12
core/variant_op.cpp
View file

@ -683,7 +683,7 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant&
case INT: { case INT: {
switch(p_b.type) { switch(p_b.type) {
case BOOL: { case BOOL: {
int b = p_b._data._bool; int64_t b = p_b._data._bool;
if (b==0) { if (b==0) {
r_valid=false; r_valid=false;
@ -693,7 +693,7 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant&
} break; } break;
case INT: { case INT: {
int b = p_b._data._int; int64_t b = p_b._data._int;
if (b==0) { if (b==0) {
r_valid=false; r_valid=false;
@ -3358,8 +3358,8 @@ void Variant::blend(const Variant& a, const Variant& b, float c, Variant &r_dst)
switch(a.type) { switch(a.type) {
case NIL: { r_dst=Variant(); } return; case NIL: { r_dst=Variant(); } return;
case INT:{ case INT:{
int va=a._data._int; int64_t va=a._data._int;
int vb=b._data._int; int64_t vb=b._data._int;
r_dst=int(va + vb * c + 0.5); r_dst=int(va + vb * c + 0.5);
} return; } return;
case REAL:{ case REAL:{
@ -3423,8 +3423,8 @@ void Variant::interpolate(const Variant& a, const Variant& b, float c,Variant &r
case NIL:{ r_dst=Variant(); } return; case NIL:{ r_dst=Variant(); } return;
case BOOL:{ r_dst=a; } return; case BOOL:{ r_dst=a; } return;
case INT:{ case INT:{
int va=a._data._int; int64_t va=a._data._int;
int vb=b._data._int; int64_t vb=b._data._int;
r_dst=int((1.0-c) * va + vb * c); r_dst=int((1.0-c) * va + vb * c);
} return; } return;
case REAL:{ case REAL:{

6
modules/gdscript/gd_tokenizer.cpp
View file

@ -731,14 +731,14 @@ void GDTokenizerText::_advance() {
INCPOS(str.length()); INCPOS(str.length());
if (hexa_found) { if (hexa_found) {
int val = str.hex_to_int(); int64_t val = str.hex_to_int64();
_make_constant(val); _make_constant(val);
} else if (period_found || exponent_found) { } else if (period_found || exponent_found) {
real_t val = str.to_double(); double val = str.to_double();
//print_line("*%*%*%*% to convert: "+str+" result: "+rtos(val)); //print_line("*%*%*%*% to convert: "+str+" result: "+rtos(val));
_make_constant(val); _make_constant(val);
} else { } else {
int val = str.to_int(); int64_t val = str.to_int64();
_make_constant(val); _make_constant(val);
} }

2
scene/gui/box_container.cpp
View file

@ -280,7 +280,7 @@ BoxContainer::AlignMode BoxContainer::get_alignment() const {
void BoxContainer::add_spacer(bool p_begin) { void BoxContainer::add_spacer(bool p_begin) {
Control *c = memnew( Control ); Control *c = memnew( Control );
c->set_mouse_filter(MOUSE_FILTER_PASS); c->set_mouse_filter(MOUSE_FILTER_PASS); //allow spacer to pass mouse events
if (vertical) if (vertical)
c->set_v_size_flags(SIZE_EXPAND_FILL); c->set_v_size_flags(SIZE_EXPAND_FILL);