7 files changed, 423 insertions, 13 deletions

diff --git a/scene/gui/text_edit.cpp b/scene/gui/text_edit.cpp
index d1a8c458ba..6036b3f9df 100644
--- a/scene/gui/text_edit.cpp
+++ b/scene/gui/text_edit.cpp
@@ -482,14 +482,6 @@ void TextEdit::_notification(int p_what) {
 			Color color = cache.font_color;
 			int in_region=-1;
 
-			if (line_length_guideline) {
-				int x=xmargin_beg+cache.font->get_char_size('0').width*line_length_guideline_col-cursor.x_ofs;
-				if (x>xmargin_beg && x<xmargin_end) {
-					Color guideline_color(color.r,color.g,color.b,color.a*0.25f);
-					VisualServer::get_singleton()->canvas_item_add_line(ci,Point2(x,0),Point2(x,cache.size.height),guideline_color);
-				}
-			}
-
 			if (syntax_coloring) {
 
 				if (cache.background_color.a>0.01) {
@@ -1080,6 +1072,14 @@ void TextEdit::_notification(int p_what) {
 				}
 			}
 
+			if (line_length_guideline) {
+				int x=xmargin_beg+cache.font->get_char_size('0').width*line_length_guideline_col-cursor.x_ofs;
+				if (x>xmargin_beg && x<xmargin_end) {
+					VisualServer::get_singleton()->canvas_item_add_line(ci,Point2(x,0),Point2(x,cache.size.height),cache.line_length_guideline_color);
+				}
+			}
+
+
 			bool completion_below = false;
 			if (completion_active) {
 				// code completion box
@@ -3484,6 +3484,7 @@ void TextEdit::_update_caches() {
 	cache.selection_color=get_color("selection_color");
 	cache.mark_color=get_color("mark_color");
 	cache.current_line_color=get_color("current_line_color");
+	cache.line_length_guideline_color=get_color("line_length_guideline_color");
 	cache.breakpoint_color=get_color("breakpoint_color");
 	cache.brace_mismatch_color=get_color("brace_mismatch_color");
 	cache.word_highlighted_color=get_color("word_highlighted_color");
diff --git a/scene/gui/text_edit.h b/scene/gui/text_edit.h
index 6113fd72c2..437e22ca40 100644
--- a/scene/gui/text_edit.h
+++ b/scene/gui/text_edit.h
@@ -91,6 +91,7 @@ class TextEdit : public Control  {
 		Color mark_color;
 		Color breakpoint_color;
 		Color current_line_color;
+		Color line_length_guideline_color;
 		Color brace_mismatch_color;
 		Color word_highlighted_color;
 		Color search_result_color;
diff --git a/scene/io/resource_format_image.cpp b/scene/io/resource_format_image.cpp
index 2d098d01f5..4d15ab86fd 100644
--- a/scene/io/resource_format_image.cpp
+++ b/scene/io/resource_format_image.cpp
@@ -27,6 +27,8 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "resource_format_image.h"
+
+#if 0
 #include "scene/resources/texture.h"
 #include "io/image_loader.h"
 #include "globals.h"
@@ -260,3 +262,4 @@ ResourceFormatLoaderImage::ResourceFormatLoaderImage() {
 	GLOBAL_DEF("rendering/image_loader/repeat",false);
 
 }
+#endif
diff --git a/scene/io/resource_format_image.h b/scene/io/resource_format_image.h
index 6e4ead2a0b..0638e97787 100644
--- a/scene/io/resource_format_image.h
+++ b/scene/io/resource_format_image.h
@@ -29,6 +29,8 @@
 #ifndef RESOURCE_FORMAT_IMAGE_H
 #define RESOURCE_FORMAT_IMAGE_H
 
+#if 0
+
 #include "io/resource_loader.h"
 #include "io/resource_saver.h"
 /**
@@ -49,3 +51,4 @@ public:
 };
 
 #endif
+#endif
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index 7e8a033c40..0ad140f7c3 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -230,7 +230,6 @@
 
 #include "scene/resources/scene_format_text.h"
 
-static ResourceFormatLoaderImage *resource_loader_image=NULL;
 //static ResourceFormatLoaderWAV *resource_loader_wav=NULL;
 
 
@@ -245,6 +244,8 @@ static ResourceFormatLoaderText *resource_loader_text=NULL;
 
 static ResourceFormatLoaderDynamicFont *resource_loader_dynamic_font=NULL;
 
+static ResourceFormatLoaderStreamTexture *resource_loader_stream_texture=NULL;
+
 //static SceneStringNames *string_names;
 
 void register_scene_types() {
@@ -255,14 +256,14 @@ void register_scene_types() {
 
 	Node::init_node_hrcr();
 
-	resource_loader_image = memnew( ResourceFormatLoaderImage );
-	ResourceLoader::add_resource_format_loader( resource_loader_image );
-
 	//resource_loader_wav = memnew( ResourceFormatLoaderWAV );
 	//ResourceLoader::add_resource_format_loader( resource_loader_wav );
 	resource_loader_dynamic_font = memnew( ResourceFormatLoaderDynamicFont );
 	ResourceLoader::add_resource_format_loader( resource_loader_dynamic_font );
 
+	resource_loader_stream_texture = memnew( ResourceFormatLoaderStreamTexture);
+	ResourceLoader::add_resource_format_loader( resource_loader_stream_texture );
+
 #ifdef TOOLS_ENABLED
 
 	//scene first!
@@ -570,6 +571,7 @@ void register_scene_types() {
 	ClassDB::register_virtual_class<Texture>();
 	ClassDB::register_virtual_class<SkyBox>();
 	ClassDB::register_class<ImageSkyBox>();
+	ClassDB::register_class<StreamTexture>();
 	ClassDB::register_class<ImageTexture>();
 	ClassDB::register_class<AtlasTexture>();
 	ClassDB::register_class<LargeTexture>();
@@ -643,9 +645,9 @@ void unregister_scene_types() {
 
 	clear_default_theme();
 
-	memdelete( resource_loader_image );
 //	memdelete( resource_loader_wav );
 	memdelete( resource_loader_dynamic_font );
+	memdelete( resource_loader_stream_texture );
 
 
 #ifdef TOOLS_ENABLED
diff --git a/scene/resources/texture.cpp b/scene/resources/texture.cpp
index a1ad5d8237..a853b62254 100644
--- a/scene/resources/texture.cpp
+++ b/scene/resources/texture.cpp
@@ -453,6 +453,335 @@ ImageTexture::~ImageTexture() {
 	VisualServer::get_singleton()->free( texture );
 }
 
+//////////////////////////////////////////
+
+
+
+uint32_t StreamTexture::get_flags() const {
+
+	return flags;
+}
+Image::Format StreamTexture::get_format() const {
+
+	return format;
+}
+
+
+Error StreamTexture::_load_data(const String& p_path,int &tw,int &th,int& flags,Image& image,int p_size_limit) {
+
+
+	FileAccess *f = FileAccess::open(p_path,FileAccess::READ);
+	ERR_FAIL_COND_V(!f,ERR_CANT_OPEN);
+
+	uint8_t header[4];
+	f->get_buffer(header,4);
+	if (header[0]!='G' || header[1]!='D' || header[2]!='S' || header[3]!='T') {
+		memdelete(f);
+		ERR_FAIL_COND_V(header[0]!='G' || header[1]!='D' || header[2]!='S' || header[3]!='T',ERR_FILE_CORRUPT);
+	}
+
+	tw = f->get_32();
+	th = f->get_32();
+	flags= f->get_32(); //texture flags!
+	uint32_t df = f->get_32(); //data format
+
+	print_line("width: "+itos(tw));
+	print_line("height: "+itos(th));
+	print_line("flags: "+itos(flags));
+	print_line("df: "+itos(df));
+
+	if (!(df&FORMAT_BIT_STREAM)) {
+		p_size_limit=0;
+	}
+
+
+	if (df&FORMAT_BIT_LOSSLESS || df&FORMAT_BIT_LOSSY) {
+		//look for a PNG or WEBP file inside
+
+		int sw=tw;
+		int sh=th;
+
+		uint32_t mipmaps = f->get_32();
+		uint32_t size = f->get_32();
+
+		print_line("mipmaps: "+itos(mipmaps));
+
+		while(mipmaps>1 && p_size_limit>0 && (sw>p_size_limit || sh>p_size_limit)) {
+
+			f->seek(f->get_pos()+size);
+			mipmaps = f->get_32();
+			size = f->get_32();
+
+			sw=MAX(sw>>1,1);
+			sh=MAX(sh>>1,1);
+			mipmaps--;
+		}
+
+		//mipmaps need to be read independently, they will be later combined
+		Vector<Image> mipmap_images;
+		int total_size=0;
+
+		for(int i=0;i<mipmaps;i++) {
+			PoolVector<uint8_t> pv;
+			pv.resize(size);
+			{
+				PoolVector<uint8_t>::Write w = pv.write();
+				f->get_buffer(w.ptr(),size);
+			}
+
+			Image img;
+			if (df&FORMAT_BIT_LOSSLESS) {
+				img = Image::lossless_unpacker(pv);
+			} else {
+				img = Image::lossy_unpacker(pv);
+			}
+
+			if (img.empty()) {
+				memdelete(f);
+				ERR_FAIL_COND_V(img.empty(),ERR_FILE_CORRUPT);
+			}
+			total_size+=img.get_data().size();
+
+			mipmap_images.push_back(img);
+		}
+
+		print_line("mipmap read total: "+itos(mipmap_images.size()));
+
+
+		memdelete(f); //no longer needed
+
+		if (mipmap_images.size()==1) {
+
+			image=mipmap_images[0];
+			return OK;
+
+		} else {
+			PoolVector<uint8_t> img_data;
+			img_data.resize(total_size);
+
+			{
+				PoolVector<uint8_t>::Write w=img_data.write();
+
+				int ofs=0;
+				for(int i=0;i<mipmap_images.size();i++) {
+
+					PoolVector<uint8_t> id = mipmap_images[i].get_data();
+					int len = id.size();
+					PoolVector<uint8_t>::Read r = id.read();
+					copymem(&w[ofs],r.ptr(),len);
+					ofs+=len;
+				}
+			}
+
+			image = Image(sw,sh,true,mipmap_images[0].get_format(),img_data);
+			return OK;
+		}
+
+	} else {
+
+		//look for regular format
+		Image::Format format = (Image::Format)(df&FORMAT_MASK_IMAGE_FORMAT);
+		bool mipmaps = df&FORMAT_BIT_HAS_MIPMAPS;
+
+		if (!mipmaps) {
+			int size = Image::get_image_data_size(tw,th,format,0);
+
+			PoolVector<uint8_t> img_data;
+			img_data.resize(size);
+
+			{
+				PoolVector<uint8_t>::Write w=img_data.write();
+				f->get_buffer(w.ptr(),size);
+			}
+
+			memdelete(f);
+
+			image = Image(tw,th,false,format,img_data);
+			return OK;
+		} else {
+
+			int sw=tw;
+			int sh=th;
+
+			int mipmaps = Image::get_image_required_mipmaps(tw,th,format);
+			int total_size = Image::get_image_data_size(tw,th,format,mipmaps);
+			int idx=0;
+			int ofs=0;
+
+
+			while(mipmaps>1 && p_size_limit>0 && (sw>p_size_limit || sh>p_size_limit)) {
+
+				sw=MAX(sw>>1,1);
+				sh=MAX(sh>>1,1);
+				mipmaps--;
+				idx++;
+			}
+
+			if (idx>0) {
+				ofs=Image::get_image_data_size(tw,th,format,idx-1);
+			}
+
+			if (total_size - ofs <=0) {
+				memdelete(f);
+				ERR_FAIL_V(ERR_FILE_CORRUPT);
+			}
+
+			f->seek(f->get_pos()+ofs);
+
+
+			PoolVector<uint8_t> img_data;
+			img_data.resize(total_size - ofs);
+
+			{
+				PoolVector<uint8_t>::Write w=img_data.write();
+				int bytes = f->get_buffer(w.ptr(),total_size - ofs);
+
+				memdelete(f);
+
+				if (bytes != total_size - ofs) {
+					ERR_FAIL_V(ERR_FILE_CORRUPT);
+				}
+			}
+
+			image = Image(sw,sh,true,format,img_data);
+
+			return OK;
+		}
+	}
+
+	return ERR_BUG; //unreachable
+}
+
+Error StreamTexture::load(const String& p_path) {
+
+
+	int lw,lh,lflags;
+	Image image;
+	Error err = _load_data(p_path,lw,lh,lflags,image);
+	if (err)
+		return err;
+
+	VS::get_singleton()->texture_allocate(texture,image.get_width(),image.get_height(),image.get_format(),lflags);
+	VS::get_singleton()->texture_set_data(texture,image);
+
+	w=lw;
+	h=lh;
+	flags=lflags;
+	path_to_file=p_path;
+	format=image.get_format();
+
+	return OK;
+}
+String StreamTexture::get_load_path() const {
+
+	return path_to_file;
+}
+
+int StreamTexture::get_width() const {
+
+	return w;
+}
+int StreamTexture::get_height() const {
+
+	return h;
+}
+RID StreamTexture::get_rid() const {
+
+	return texture;
+}
+
+
+void StreamTexture::draw(RID p_canvas_item, const Point2& p_pos, const Color& p_modulate, bool p_transpose) const {
+
+	if ((w|h)==0)
+		return;
+	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item,Rect2( p_pos, Size2(w,h)),texture,false,p_modulate,p_transpose);
+
+}
+void StreamTexture::draw_rect(RID p_canvas_item,const Rect2& p_rect, bool p_tile,const Color& p_modulate, bool p_transpose) const {
+
+	if ((w|h)==0)
+		return;
+	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item,p_rect,texture,p_tile,p_modulate,p_transpose);
+
+}
+void StreamTexture::draw_rect_region(RID p_canvas_item,const Rect2& p_rect, const Rect2& p_src_rect,const Color& p_modulate, bool p_transpose) const{
+
+	if ((w|h)==0)
+		return;
+	VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item,p_rect,texture,p_src_rect,p_modulate,p_transpose);
+}
+
+bool StreamTexture::has_alpha() const {
+
+	return false;
+}
+void StreamTexture::set_flags(uint32_t p_flags){
+
+}
+
+void StreamTexture::reload_from_file() {
+
+	load(path_to_file);
+}
+
+void StreamTexture::_bind_methods() {
+
+	ClassDB::bind_method(_MD("load","path"),&StreamTexture::load);
+	ClassDB::bind_method(_MD("get_load_path"),&StreamTexture::get_load_path);
+
+	ADD_PROPERTY( PropertyInfo(Variant::STRING,"load_path",PROPERTY_HINT_FILE,"*.stex"),_SCS("load"),_SCS("get_load_path"));
+}
+
+
+StreamTexture::StreamTexture() {
+
+	format=Image::FORMAT_MAX;
+	flags=0;
+	w=0;
+	h=0;
+
+	texture = VS::get_singleton()->texture_create();
+}
+
+StreamTexture::~StreamTexture() {
+
+	VS::get_singleton()->free(texture);
+}
+
+
+
+RES ResourceFormatLoaderStreamTexture::load(const String &p_path,const String& p_original_path,Error *r_error) {
+
+	Ref<StreamTexture> st;
+	st.instance();
+	Error err = st->load(p_path);
+	if (r_error)
+		*r_error=err;
+	if (err!=OK)
+		return RES();
+
+	return st;
+}
+
+void ResourceFormatLoaderStreamTexture::get_recognized_extensions(List<String> *p_extensions) const{
+
+	p_extensions->push_back("stex");
+}
+bool ResourceFormatLoaderStreamTexture::handles_type(const String& p_type) const{
+	return p_type=="StreamTexture";
+
+}
+String ResourceFormatLoaderStreamTexture::get_resource_type(const String &p_path) const{
+
+	if (p_path.get_extension().to_lower()=="stex")
+		return "StreamTexture";
+	return "";
+}
+
+
+
+
 
 //////////////////////////////////////////
 
diff --git a/scene/resources/texture.h b/scene/resources/texture.h
index aac3514af3..919c588894 100644
--- a/scene/resources/texture.h
+++ b/scene/resources/texture.h
@@ -31,6 +31,7 @@
 
 #include "resource.h"
 #include "servers/visual_server.h"
+#include "io/resource_loader.h"
 #include "math_2d.h"
 
 /**
@@ -160,6 +161,76 @@ public:
 };
 
 
+
+class StreamTexture : public Texture {
+
+	GDCLASS( StreamTexture, Texture );
+public:
+	enum DataFormat {
+		DATA_FORMAT_IMAGE,
+		DATA_FORMAT_LOSSLESS,
+		DATA_FORMAT_LOSSY
+	};
+
+	enum FormatBits {
+		FORMAT_MASK_IMAGE_FORMAT=(1<<20)-1,
+		FORMAT_BIT_LOSSLESS=1<<20,
+		FORMAT_BIT_LOSSY=1<<21,
+		FORMAT_BIT_STREAM=1<<22,
+		FORMAT_BIT_HAS_MIPMAPS=1<<23,
+	};
+
+private:
+
+	Error _load_data(const String &p_path, int &tw, int &th, int& flags, Image& image, int p_size_limit=0);
+	String path_to_file;
+	RID texture;
+	Image::Format format;
+	uint32_t flags;
+	int w,h;
+
+	virtual void reload_from_file();
+
+protected:
+
+	static void _bind_methods();
+
+public:
+
+
+	uint32_t get_flags() const;
+	Image::Format get_format() const;
+	Error load(const String& p_path);
+	String get_load_path() const;
+
+	int get_width() const;
+	int get_height() const;
+	virtual RID get_rid() const;
+
+	virtual void draw(RID p_canvas_item, const Point2& p_pos, const Color& p_modulate=Color(1,1,1), bool p_transpose=false) const;
+	virtual void draw_rect(RID p_canvas_item,const Rect2& p_rect, bool p_tile=false,const Color& p_modulate=Color(1,1,1), bool p_transpose=false) const;
+	virtual void draw_rect_region(RID p_canvas_item,const Rect2& p_rect, const Rect2& p_src_rect,const Color& p_modulate=Color(1,1,1), bool p_transpose=false) const;
+
+	virtual bool has_alpha() const;
+	virtual void set_flags(uint32_t p_flags);
+
+	StreamTexture();
+	~StreamTexture();
+
+};
+
+
+class ResourceFormatLoaderStreamTexture : public ResourceFormatLoader {
+public:
+	virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL);
+	virtual void get_recognized_extensions(List<String> *p_extensions) const;
+	virtual bool handles_type(const String& p_type) const;
+	virtual String get_resource_type(const String &p_path) const;
+
+};
+
+
+
 VARIANT_ENUM_CAST( ImageTexture::Storage );
 
 class AtlasTexture : public Texture {