diff -Nur opensim-/OpenSim/Region/CoreModules/Scripting/BitmapRender/BitmapRenderModule.cs opensim/OpenSim/Region/CoreModules/Scripting/BitmapRender/BitmapRenderModule.cs
--- opensim-/OpenSim/Region/CoreModules/Scripting/BitmapRender/BitmapRenderModule.cs	1970-01-01 09:00:00.000000000 +0900
+++ opensim/OpenSim/Region/CoreModules/Scripting/BitmapRender/BitmapRenderModule.cs	2014-07-05 22:35:46.498420203 +0900
@@ -0,0 +1,309 @@
+
+/*
+	BitmapStringRenderModule v1.1
+								by Fum.Iseki '14 6/20
+
+	string data = "1 2 3 4 5 6 7 8 9 10 11 12";
+				   A R G B A R G B A  R  G  B
+ */
+
+using System;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Globalization;
+using System.IO;
+using System.Net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.Imaging;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using log4net;
+using System.Reflection;
+using Mono.Addins;
+
+
+
+namespace OpenSim.Region.CoreModules.Scripting.BitmapStringRender
+{
+	[Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "BitmapStringRenderModule")]
+	public class BitmapStringRenderModule : ISharedRegionModule, IDynamicTextureRender
+	{
+		private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+		private string m_name = "BitmapStringRenderModule";
+		private Scene m_scene;
+		private IDynamicTextureManager m_textureManager;
+
+        public BitmapStringRenderModule()
+        {
+        }
+
+		#region IDynamicTextureRender Members
+
+		public string GetContentType()
+		{
+			return ("bitmapstring");
+		}
+
+
+		public string GetName()
+		{
+			return Name;
+		}
+
+
+		public bool SupportsAsynchronous()
+		{
+			return true;
+		}
+
+
+        public IDynamicTexture ConvertUrl(string url, string extraParams)
+        {
+            return null;
+        }
+
+
+        public IDynamicTexture ConvertData(string bodyData, string extraParams)
+        {
+			return Trans(bodyData, extraParams);
+        }
+
+
+		public bool AsyncConvertUrl(UUID id, string url, string extraParams)
+		{
+			return false;
+		}
+
+
+		public bool AsyncConvertData(UUID id, string bodyData, string extraParams)
+		{
+			//m_log.Error("[BITMAP STRING RENDER MODULE]: Start AsyncConvertData");
+
+            if (m_textureManager==null)
+            {
+                m_log.Warn("[BitMapStringRenderModule]: No texture manager. Can't function");
+                return false;
+            }
+
+			IDynamicTexture texture = Trans(bodyData, extraParams);
+			if (texture==null) {
+				m_log.Error("[BITMAP STRING RENDER MODULE]: Texture is NULL");
+				return false;
+			}
+
+            m_textureManager.ReturnData(id, texture);
+            return true;
+		}
+
+
+		public void GetDrawStringSize(string text, string fontName, int fontSize, out double xSize, out double ySize)
+		{
+			xSize = 0;
+			ySize = 0;
+		}
+
+
+		#endregion
+
+
+
+		#region ISharedRegionModule Members
+
+		public void PostInitialise()
+		{
+		}
+
+
+		public string Name
+		{
+			get { return m_name; }
+		}
+
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+
+        public void Initialise(IConfigSource config)
+        {
+			return;
+        }
+
+
+		public void Close()
+		{
+		}
+
+
+        public void AddRegion(Scene scene)
+        {
+            if (m_scene==null) m_scene = scene;
+        }
+
+
+        public void RemoveRegion(Scene scene)
+        {
+        }
+
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (m_textureManager==null && m_scene==scene)
+            { 
+               	m_textureManager = m_scene.RequestModuleInterface<IDynamicTextureManager>();
+                if (m_textureManager!=null)
+                {
+                    m_textureManager.RegisterRender(GetContentType(), this);
+                }
+            }
+        }
+
+
+		#endregion
+
+
+
+		private IDynamicTexture Trans(string data, string extraParams)
+		{
+			int width  = 256;
+			int height = 256;
+			
+			char[] paramDelimiter = { ',' };
+			char[] nvpDelimiter = { ':' };
+		   
+			extraParams = extraParams.Trim();
+			extraParams = extraParams.ToLower();
+			string[] nvps = extraParams.Split(paramDelimiter);
+			
+			// for Parameter
+			foreach (string pair in nvps)
+			{
+				string[] nvp = pair.Split(nvpDelimiter);
+				string name = "";
+				string value = "";
+				
+				if (nvp[0] != null)  name  = nvp[0].Trim();
+				if (nvp.Length == 2) value = nvp[1].Trim();
+				
+				int temp;
+				switch (name) {
+				  case "width":
+					temp = parseIntParam(value);
+					if (temp!=-1) {
+						if (temp < 1) {
+							width = 1;
+						}
+						else if (temp > 2048) {
+							width = 2048;
+						}
+						else {
+							width = temp;
+						}
+					}
+					break;
+
+				  case "height":
+					temp = parseIntParam(value);
+					if (temp!=-1) {
+						if (temp < 1) {
+							height = 1;
+						}
+						else if (temp > 2048) {
+							height = 2048;
+							}
+						else {
+							height = temp;
+						}
+					}
+					break;
+
+				  default:
+					 break;
+				}
+			}
+
+
+			// for Data
+			int len = width*height;
+			string[] buf = System.Text.RegularExpressions.Regex.Split(data.Trim(), " {1,}");
+			if (buf.Length<len*4) {
+				m_log.Error("[BITMAP STRING RENDER MODULE]: Data Length is too short!");
+				return null;
+			}
+
+			byte[] al = new byte[len];
+			byte[] rc = new byte[len];
+			byte[] gc = new byte[len];
+			byte[] bc = new byte[len];
+	
+			for (int i=0; i<len; i++) {
+				al[i] = parseByteParam(buf[4*i]);
+				rc[i] = parseByteParam(buf[4*i+1]);
+				gc[i] = parseByteParam(buf[4*i+2]);
+				bc[i] = parseByteParam(buf[4*i+3]);
+			}
+
+			Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
+			for (int h=0; h<bitmap.Height; h++) {
+				int lh = h*width;
+				for (int w=0; w<bitmap.Width; w++) {
+					int k = lh + w;
+					bitmap.SetPixel(w, h, Color.FromArgb(al[k], rc[k], gc[k], bc[k]));
+				}
+			}
+
+			// Convert to JPEG2000
+			byte[] imageJ2000 = new byte[0];
+			try {
+				imageJ2000 = OpenJPEG.EncodeFromImage(bitmap, true);
+			}
+			catch (Exception) {
+				m_log.Error("[BITMAP STRING RENDER MODULE]: OpenJpeg Encode Failed.  Empty byte data returned!");
+				return null;
+			}
+
+            return new OpenSim.Region.CoreModules.Scripting.DynamicTexture.DynamicTexture(data, extraParams, imageJ2000, new Size(width, height), false);
+		}
+		
+
+
+		private int parseIntParam(string strInt)
+		{
+			int parsed;
+
+			try {	   
+				parsed = Convert.ToInt32(strInt);
+			}
+			catch (Exception) {	   
+				parsed = -1;
+			}
+		
+			return parsed;
+		}
+
+
+		private byte parseByteParam(string strInt)
+		{ 
+			byte parsed;
+
+			int temp = parseIntParam(strInt);
+			if (temp<0) {
+				parsed = 0x00;
+			}
+			else if (temp>255) {
+				parsed = 0xff;
+			}
+			else {
+				parsed = (byte)temp;
+			}
+
+			return parsed;
+		}
+
+	}
+
+}
diff -Nur opensim-/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs opensim/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
--- opensim-/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs	2014-07-05 22:38:44.506839465 +0900
+++ opensim/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs	2014-07-05 22:40:17.732011705 +0900
@@ -495,6 +495,123 @@
             if (terrainModule != null) terrainModule.TaintTerrain();
         }
 
+
+        // Fumi.Iseki
+        public void osTerrainSetByString(string str, double rate)
+        {  
+            CheckThreatLevel(ThreatLevel.VeryLow, "osTerrainSetByString");
+
+            m_host.AddScriptLPS(1);
+
+            int i, j;
+
+            int lnno = (int)(World.Heightmap.Height*rate+1);
+            double[,] hgt = new double[World.Heightmap.Width, lnno];
+            for (i=0; i<World.Heightmap.Width; i++) {
+                for (j=0; j<lnno; j++) {
+                    hgt[i, j] = 0.0;
+                }
+            }
+
+            string[]  buf = str.TrimEnd('\n').Split('\n');
+
+            j = 0;
+            foreach(string rec in buf) {
+                if (j>=lnno) break;
+                i = 0;
+                string line = rec.Trim(' ');
+                foreach(string itm in System.Text.RegularExpressions.Regex.Split(line, " {1,}")) {
+                    if (i>=World.Heightmap.Width) break;
+                    hgt[i, j] = double.Parse(itm);
+                    i++;
+                }
+                j++;
+            }
+
+            for (j=0; j<World.Heightmap.Height; j++) {
+                int jj = World.Heightmap.Height - j - 1;
+                double yy = j*rate;
+                int hh = (int)yy;
+                double al = yy - (double)hh;
+
+                for (i=0; i<World.Heightmap.Width; i++) {
+                    if (World.Permissions.CanTerraformLand(m_host.OwnerID, new Vector3(i, jj, 0))) {
+                        World.Heightmap[i, jj] = (1.0-al)*hgt[i, hh] + al*hgt[i, hh+1];
+                    }
+                }
+            }
+       }
+
+
+        // Fumi.Iseki
+        public LSL_String osTerrainGetSculpt(double x, double y, double z, double obsz, int mhsz)
+        {  
+            CheckThreatLevel(ThreatLevel.VeryLow, "osTerrainGetSculpt");
+
+            m_host.AddScriptLPS(1);
+
+            string map1 = "";
+            string map2 = "";
+            double sfc = 256.0/mhsz;
+
+            for (int i=0; i<mhsz; i++) {
+                int ii = (int)(i*sfc + 0.5);
+                double xx = obsz*(i-mhsz/2.0)/mhsz + x;
+                int mm = (int)xx;
+                int hh = mm + 1;
+                double al = xx - mm;
+
+                if (mm>=World.Heightmap.Width) mm = World.Heightmap.Width - 1;
+                if (hh>=World.Heightmap.Width) hh = World.Heightmap.Width - 1;
+                if (mm<0) mm = 0;
+                if (hh<0) hh = 0;
+
+                for (int j=0; j<mhsz; j++) {
+                    int jj = (int)(j*sfc + 0.5);
+                    double yy = obsz*(j-mhsz/2.0)/mhsz + y;
+                    int nn = (int)yy;
+                    int ll = nn + 1;
+                    double bt = yy - nn;
+
+                    if (nn>=World.Heightmap.Height) nn = World.Heightmap.Height - 1;
+                    if (ll>=World.Heightmap.Height) ll = World.Heightmap.Height - 1;
+                    if (nn<0) nn = 0;
+                    if (ll<0) ll = 0;
+
+                    double aa = World.Heightmap[mm, nn];
+                    double bb = World.Heightmap[hh, nn];
+                    double cc = World.Heightmap[mm, ll];
+                    double dd = World.Heightmap[hh, ll];
+                    double zz = (1.0-al)*(1.0-bt)*aa + al*(1.0-bt)*bb + (1.0-al)*bt*cc + al*bt*dd - z;
+
+                    int kk = (int)(mhsz*(zz/obsz+0.5)*sfc + 0.5);
+                    if (i<mhsz/2) map1 += " 255 "+ii.ToString()+" "+jj.ToString()+" "+kk.ToString();
+                    else          map2 += " 255 "+ii.ToString()+" "+jj.ToString()+" "+kk.ToString();
+                }
+            }
+
+            return map1 + map2;
+        }
+
+
+        // Fumi.Iseki
+        public void osTerrainFill(double height)
+        {
+            CheckThreatLevel(ThreatLevel.None, "osTerrainFill");
+
+            m_host.AddScriptLPS(1);
+            //int i, j;
+            for (int j=0; j<World.Heightmap.Height; j++) {
+                for (int i=0; i<World.Heightmap.Width; i++) {
+                    if (World.Permissions.CanTerraformLand(m_host.OwnerID, new Vector3(i, j, 0)))
+                    {
+                        World.Heightmap[i, j] = height;
+                    }
+                }
+            }
+        }
+
+
         public int osRegionRestart(double seconds)
         {
             // This is High here because region restart is not reliable
diff -Nur opensim-/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs opensim/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs
--- opensim-/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs	2014-07-05 22:38:23.859022990 +0900
+++ opensim/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs	2014-07-05 22:40:03.364139310 +0900
@@ -134,6 +134,11 @@
         LSL_Integer osTerrainSetHeight(int x, int y, double val); //Deprecated
         void osTerrainFlush();
 
+        // Fumi.Iseki
+        void osTerrainFill(double height);
+        void osTerrainSetByString(string str, double rate);
+        LSL_String osTerrainGetSculpt(double x, double y, double z, double obsz, int mhsz);
+
         int osRegionRestart(double seconds);
         void osRegionNotice(string msg);
         bool osConsoleCommand(string Command);
diff -Nur opensim-/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs opensim/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
--- opensim-/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs	2014-07-05 22:37:58.626247057 +0900
+++ opensim/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs	2014-07-05 22:39:41.970329343 +0900
@@ -204,6 +204,26 @@
             m_OSSL_Functions.osTerrainFlush();
         }
 
+
+        // Fumi.Iseki
+        public void osTerrainFill(double height)
+        {
+            m_OSSL_Functions.osTerrainFill(height);
+        }
+
+        // Fumi.Iseki
+        public LSL_String osTerrainGetSculpt(double x, double y, double z, double obsz, int mhsz)
+        {
+            return m_OSSL_Functions.osTerrainGetSculpt(x, y, z, obsz, mhsz);
+        }
+
+        // Fumi.Iseki
+        public void osTerrainSetByString(string str, double rate)
+        {
+            m_OSSL_Functions.osTerrainSetByString(str, rate);
+        }
+
+
         public int osRegionRestart(double seconds)
         {
             return m_OSSL_Functions.osRegionRestart(seconds);