public OCFileTerrainGenerator(OpenCog.Map.OCMap map, string mapName)
{
System.Console.WriteLine(OCLogSymbol.CREATE + this.GetType().ToString ());
map.MapName = mapName;
_map = map;
UnityEngine.Object[] objects = Resources.LoadAll(mapName + "/level");
//Debug.Log("Objects Loaded: ");
foreach(UnityEngine.Object obj in objects)
{
System.Console.WriteLine(OCLogSymbol.DETAILEDINFO + obj.ToString() + "was Loaded.");
}
string dataPath;
// if(Application.isEditor)
// {
// dataPath = UnityEngine.Application.dataPath + "/OpenCog Assets/Maps/StreamingAssets/";
// }
// else
{
dataPath = Application.streamingAssetsPath;
}
System.Console.WriteLine(OCLogSymbol.DETAILEDINFO + "Data Path:" + dataPath);
_fullMapPath = System.IO.Path.Combine(dataPath, mapName);
}
public OCFileTerrainGenerator(OpenCog.Map.OCMap map, string mapName)
{
map.MapName = mapName;
_map = map;
UnityEngine.Object[] objects = Resources.LoadAll(mapName + "/level");
Debug.Log("Objects Loaded: ");
foreach(UnityEngine.Object obj in objects)
{
Debug.Log(obj.ToString());
}
string dataPath;
// if(Application.isEditor)
// {
// dataPath = UnityEngine.Application.dataPath + "/OpenCog Assets/Maps/StreamingAssets/";
// }
// else
{
dataPath = Application.streamingAssetsPath;
}
Debug.Log(dataPath);
_fullMapPath = System.IO.Path.Combine(dataPath, mapName);
}
private static Contact? GetClosestContact(OpenCog.Map.OCMap map, CharacterController controller) {
Vector3 pos = controller.transform.position;
int x1 = Mathf.FloorToInt(pos.x-controller.radius);
int y1 = Mathf.FloorToInt(pos.y);
int z1 = Mathf.FloorToInt(pos.z-controller.radius);
int x2 = Mathf.CeilToInt(pos.x+controller.radius);
int y2 = Mathf.CeilToInt(pos.y+controller.height);
int z2 = Mathf.CeilToInt(pos.z+controller.radius);
Contact? contact = null;
for(int x=x1; x<=x2; x++) {
for(int y=y1; y<=y2; y++) {
for(int z=z1; z<=z2; z++) {
OpenCog.Map.OCBlockData block = map.GetBlock(x, y, z);
if(block.IsSolid()) {
Contact? _newContact = BlockCharacterCollision.GetContactBlockCharacter(new Vector3i(x, y, z), pos, controller);
if(_newContact.HasValue && _newContact.Value.delta.magnitude > float.Epsilon) {
Contact newContact = _newContact.Value;
if(!contact.HasValue || newContact.sqrDistance > contact.Value.sqrDistance) {
contact = newContact;
}
}
}
}
}
}
return contact;
// return null;
}
public OCTerrainGenerator(OpenCog.Map.OCMap map) {
this.map = map;
Debug.Log("OCTerrainGenerator is getting the BlockSet from the Map.");
OpenCog.BlockSet.OCBlockSet blockSet = map.GetBlockSet();
Debug.Log("BlockSet retrieved...");
water = blockSet.GetBlock("Water");
grass = blockSet.GetBlock("Grass");
if (grass == null)
{
Debug.Log("We have no Grass! :(");
for (int i = 0; i < blockSet.Blocks.Length; i++)
{
Debug.Log("But we have " + blockSet.Blocks[i].GetName());
}
}
dirt = blockSet.GetBlock("Dirt");
sand = blockSet.GetBlock("Sand");
stone = blockSet.GetBlock("Stone");
snow = blockSet.GetBlock("Snow");
ice = blockSet.GetBlock("Ice");
}
//---------------------------------------------------------------------------
#region Private Member Data
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Accessors and Mutators
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Public Member Functions
//---------------------------------------------------------------------------
public static void Build(Vector3i localPos, Vector3i worldPos, OpenCog.Map.OCMap map, OpenCog.Builder.OCMeshBuilder mesh, bool onlyLight)
{
if(!onlyLight)
{
BuildCross((Vector3)localPos, worldPos, map, mesh);
}
BuildCrossLight(map, worldPos, mesh);
}
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Accessors and Mutators
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Public Member Functions
//---------------------------------------------------------------------------
public override void Init(OpenCog.BlockSet.OCBlockSet blockSet) {
base.Init(blockSet);
_texCoords = new UnityEngine.Vector2[][] {
ToTexCoords(_front), ToTexCoords(_back),
ToTexCoords(_right), ToTexCoords(_left),
ToTexCoords(_top), ToTexCoords(_bottom)
};
}
// TODO: May need to be re-enabled...hope not, since all blockdata that gets instantiated should get its coordinates too.
// public BlockData(Block block) {
// this.block = block;
// direction = BlockDirection.Z_PLUS;
// }
// public OCBlockData()
// {
// }
public OCBlockData Init(OpenCog.BlockSet.BaseBlockSet.OCBlock block, Vector3i globalPosition)
{
this.block = block;
this._globalX = globalPosition.x;
this._globalY = globalPosition.y;
this._globalZ = globalPosition.z;
direction = OCBlockDirection.Z_PLUS;
return this;
}
public static void Collision(OpenCog.Map.OCMap map, CharacterController controller) {
for(int i=0; i<3; i++) {
Contact? _contact = GetClosestContact(map, controller);
if(!_contact.HasValue) break;
Contact contact = _contact.Value;
controller.transform.position += contact.delta;
//@TODO: Figure out a better way to do map / character collisions...
//controller.collider.OnCollision(contact.b, contact.delta.normalized);
}
}
//---------------------------------------------------------------------------
#region Private Member Data
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Accessors and Mutators
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Public Member Functions
//---------------------------------------------------------------------------
public static OpenCog.Builder.OCMeshBuilder Build(OpenCog.BlockSet.BaseBlockSet.OCCactusBlock cactus) {
OpenCog.Builder.OCMeshBuilder mesh = new OpenCog.Builder.OCMeshBuilder();
for(int i=0; i<vertices.Length; i++) {
mesh.AddFaceIndices( 0 );
mesh.AddVertices( vertices[i], Vector3.zero );
mesh.AddNormals( normals[i] );
Vector2[] texCoords = cactus.GetFaceUV((OCCubeBlock.CubeFace)i);
mesh.AddTexCoords(texCoords);
mesh.AddFaceColor( new Color(0,0,0,1) );
}
return mesh;
}
public static Vector3? Intersection(OpenCog.Map.OCMap map, Ray ray, float distance) {
Vector3 start = ray.origin;
Vector3 end = ray.origin+ray.direction*distance;
int startX = Mathf.RoundToInt(start.x);
int startY = Mathf.RoundToInt(start.y);
int startZ = Mathf.RoundToInt(start.z);
int endX = Mathf.RoundToInt(end.x);
int endY = Mathf.RoundToInt(end.y);
int endZ = Mathf.RoundToInt(end.z);
if(startX>endX) {
int tmp = startX;
startX = endX;
endX = tmp;
}
if(startY>endY) {
int tmp = startY;
startY = endY;
endY = tmp;
}
if(startZ>endZ) {
int tmp = startZ;
startZ = endZ;
endZ = tmp;
}
float minDistance = distance;
for(int z=startZ; z<=endZ; z++) {
for(int y=startY; y<=endY; y++) {
for(int x=startX; x<=endX; x++) {
OpenCog.Map.OCBlockData block = map.GetBlock(x, y, z);
if(block == null || block.IsEmpty() || block.IsFluid()) continue;
float dis = BlockRayIntersection(new Vector3(x, y, z), ray);
minDistance = Mathf.Min(minDistance, dis);
}
}
}
if(minDistance != distance) return ray.origin + ray.direction * minDistance;
return null;
}
//---------------------------------------------------------------------------
#region Private Member Data
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Accessors and Mutators
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Public Member Functions
//---------------------------------------------------------------------------
public static void Build(Vector3i localPos, Vector3i worldPos, OpenCog.Map.OCMap map, OpenCog.Builder.OCMeshBuilder mesh, bool onlyLight)
{
OCFluidBlock fluid = (OCFluidBlock)map.GetBlock(worldPos).block;
for(int i=0; i<6; i++)
{
OCCubeBlock.CubeFace face = OpenCog.Builder.OCCubeBuilder.faces[i];
Vector3i dir = OpenCog.Builder.OCCubeBuilder.directions[i];
Vector3i nearPos = worldPos + dir;
if(IsFaceVisible(map, nearPos, face))
{
if(!onlyLight)
{
BuildFace(face, fluid, (UnityEngine.Vector3)localPos, mesh);
}
BuildFaceLight(face, map, worldPos, mesh);
}
}
}
//---------------------------------------------------------------------------
#region Private Member Data
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Accessors and Mutators
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Public Member Functions
//---------------------------------------------------------------------------
public static UnityEngine.Color GetSmoothVertexLight(OpenCog.Map.OCMap map, Vector3i pos, UnityEngine.Vector3 vertex, OpenCog.BlockSet.BaseBlockSet.OCCubeBlock.CubeFace face) {
// pos - позиция блока
// vertex позиция вершины относительно блока т.е. от -0.5 до 0.5
int dx = (int)Mathf.Sign( vertex.x );
int dy = (int)Mathf.Sign( vertex.y );
int dz = (int)Mathf.Sign( vertex.z );
Vector3i a, b, c, d;
if(face == OCCubeBlock.CubeFace.Left || face == OCCubeBlock.CubeFace.Right) { // X
a = pos + new Vector3i(dx, 0, 0);
b = pos + new Vector3i(dx, dy, 0);
c = pos + new Vector3i(dx, 0, dz);
d = pos + new Vector3i(dx, dy, dz);
} else
if(face == OCCubeBlock.CubeFace.Bottom || face == OCCubeBlock.CubeFace.Top) { // Y
a = pos + new Vector3i(0, dy, 0);
b = pos + new Vector3i(dx, dy, 0);
c = pos + new Vector3i(0, dy, dz);
d = pos + new Vector3i(dx, dy, dz);
} else { // Z
a = pos + new Vector3i(0, 0, dz);
b = pos + new Vector3i(dx, 0, dz);
c = pos + new Vector3i(0, dy, dz);
d = pos + new Vector3i(dx, dy, dz);
}
if(map.GetBlock(b).IsAlpha() || map.GetBlock(c).IsAlpha()) {
Color c1 = GetBlockLight(map, a);
Color c2 = GetBlockLight(map, b);
Color c3 = GetBlockLight(map, c);
Color c4 = GetBlockLight(map, d);
return (c1 + c2 + c3 + c4)/4f;
} else {
Color c1 = GetBlockLight(map, a);
Color c2 = GetBlockLight(map, b);
Color c3 = GetBlockLight(map, c);
return (c1 + c2 + c3)/3f;
}
}
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Accessors and Mutators
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Public Member Functions
//---------------------------------------------------------------------------
public override void Init(OpenCog.BlockSet.OCBlockSet blockSet) {
base.Init(blockSet);
_faceVectors = ToTexCoords(_face);
}
public static OpenCog.Builder.OCMeshBuilder Build(OpenCog.BlockSet.BaseBlockSet.OCFluidBlock fluid)
{
OpenCog.Builder.OCMeshBuilder mesh = new OpenCog.Builder.OCMeshBuilder();
for(int i=0; i<OpenCog.Builder.OCCubeBuilder.vertices.Length; i++)
{
mesh.AddFaceIndices(0);
mesh.AddVertices(OpenCog.Builder.OCCubeBuilder.vertices[i], UnityEngine.Vector3.zero);
mesh.AddNormals(OpenCog.Builder.OCCubeBuilder.normals[i]);
mesh.AddTexCoords(fluid.GetFaceUV());
mesh.AddFaceColor(new UnityEngine.Color(0, 0, 0, 1));
}
return mesh;
}
private static void BuildFaceLight(OpenCog.BlockSet.BaseBlockSet.OCCubeBlock.CubeFace face, OpenCog.Map.OCMap map, Vector3i pos, OpenCog.Builder.OCMeshBuilder mesh)
{
Vector3i dir = OpenCog.Builder.OCCubeBuilder.directions[(int)face];
UnityEngine.Color color = OpenCog.Builder.OCBuildUtils.GetBlockLight(map, pos + dir);
mesh.AddFaceColor(color);
}
private static void BuildFace(OpenCog.BlockSet.BaseBlockSet.OCCubeBlock.CubeFace face, OpenCog.BlockSet.BaseBlockSet.OCFluidBlock fluid, UnityEngine.Vector3 localPos, OpenCog.Builder.OCMeshBuilder mesh)
{
int iFace = (int)face;
mesh.AddFaceIndices(fluid.AtlasID);
mesh.AddVertices(OpenCog.Builder.OCCubeBuilder.vertices[iFace], localPos);
mesh.AddNormals(OpenCog.Builder.OCCubeBuilder.normals[iFace]);
mesh.AddTexCoords(fluid.GetFaceUV());
}
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Private Member Functions
//---------------------------------------------------------------------------
private static bool IsFaceVisible(OpenCog.Map.OCMap map, Vector3i nearPos, OpenCog.BlockSet.BaseBlockSet.OCCubeBlock.CubeFace face)
{
if(face == OCCubeBlock.CubeFace.Top)
{
OpenCog.Map.OCBlockData block = map.GetBlock(nearPos);
return block.IsEmpty() || !block.IsFluid();
}
else
{
return map.GetBlock(nearPos).IsEmpty();
}
}
public UnityEngine.Vector2[] GetFaceUV(CubeFace face, OpenCog.Map.OCBlockDirection dir) {
face = TransformFace(face, dir);
return _texCoords[ (int)face ];
}
private void BuildBlock(OpenCog.BlockSet.BaseBlockSet.OCBlock block) {
renderer.material = block.Atlas.Material;
MeshFilter filter = GetComponent<MeshFilter>();
block.Build().ToMesh(filter.mesh);
}
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Private Member Functions
//---------------------------------------------------------------------------
private static int DrawList(Rect position, int selected, OpenCog.BlockSet.OCBlockSet[] list, ref Vector2 scrollPosition) {
GUILayout.BeginArea(position, GUI.skin.box);
scrollPosition = GUILayout.BeginScrollView(scrollPosition);
for(int i=0; i<list.Length; i++) {
if( DrawItem(list[i].name, i == selected) ) {
selected = i;
Event.current.Use();
}
}
GUILayout.EndScrollView();
GUILayout.EndArea();
return selected;
}
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Private Member Functions
//---------------------------------------------------------------------------
private static UnityEngine.Color ComputeSmoothLight(OpenCog.Map.OCMap map, Vector3i a, Vector3i b, Vector3i c, Vector3i d) {
if(map.GetBlock(b).IsAlpha() || map.GetBlock(c).IsAlpha()) {
UnityEngine.Color c1 = GetBlockLight(map, a);
UnityEngine.Color c2 = GetBlockLight(map, b);
UnityEngine.Color c3 = GetBlockLight(map, c);
UnityEngine.Color c4 = GetBlockLight(map, d);
return (c1 + c2 + c3 + c4)/4f;
} else {
UnityEngine.Color c1 = GetBlockLight(map, a);
UnityEngine.Color c2 = GetBlockLight(map, b);
UnityEngine.Color c3 = GetBlockLight(map, c);
return (c1 + c2 + c3)/3f;
}
}
private static bool DrawBlock(OpenCog.BlockSet.BaseBlockSet.OCBlock block, bool selected) {
UnityEngine.Rect rect = GUILayoutUtility.GetAspectRect(1f);
if(selected) GUI.Box(rect, GUIContent.none);
UnityEngine.Vector3 center = rect.center;
rect.width -= 8;
rect.height -= 8;
rect.center = center;
if(block != null) return block.DrawPreview(rect);
return false;
}
public static OCChunkRenderer CreateChunkRenderer(Vector3i pos, OpenCog.Map.OCMap map, OCChunk chunk) {
UnityEngine.GameObject go = new UnityEngine.GameObject("("+pos.x+" "+pos.y+" "+pos.z+")", typeof(UnityEngine.MeshFilter), typeof(UnityEngine.MeshRenderer), typeof(OpenCog.Map.OCChunkRenderer));
go.transform.parent = map.transform;
go.transform.localPosition = new UnityEngine.Vector3(pos.x*OpenCog.Map.OCChunk.SIZE_X, pos.y*OpenCog.Map.OCChunk.SIZE_Y, pos.z*OpenCog.Map.OCChunk.SIZE_Z);
go.transform.localRotation = UnityEngine.Quaternion.identity;
go.transform.localScale = UnityEngine.Vector3.one;
OCChunkRenderer chunkRenderer = go.GetComponent<OCChunkRenderer>();
chunkRenderer.BlockSet = map.GetBlockSet();
chunkRenderer.Chunk = chunk;
go.GetComponent<UnityEngine.Renderer>().castShadows = false;
go.GetComponent<UnityEngine.Renderer>().receiveShadows = false;
return chunkRenderer;
}
public static CubeFace TransformFace(CubeFace face, OpenCog.Map.OCBlockDirection dir) {
if(face == CubeFace.Top || face == CubeFace.Bottom) {
return face;
}
//Front, Right, Back, Left
//0 90 180 270
int angle = 0;
if(face == CubeFace.Right) angle = 90;
if(face == CubeFace.Back) angle = 180;
if(face == CubeFace.Left) angle = 270;
if(dir == OpenCog.Map.OCBlockDirection.X_MINUS) angle += 90;
if(dir == OpenCog.Map.OCBlockDirection.Z_MINUS) angle += 180;
if(dir == OpenCog.Map.OCBlockDirection.X_PLUS) angle += 270;
angle %= 360;
if(angle == 0) return CubeFace.Front;
if(angle == 90) return CubeFace.Right;
if(angle == 180) return CubeFace.Back;
if(angle == 270) return CubeFace.Left;
return CubeFace.Front;
}
public override void Build(Vector3i localPos, Vector3i worldPos, OpenCog.Map.OCMap map, OpenCog.Builder.OCMeshBuilder mesh, bool onlyLight) {
OpenCog.Builder.OCCrossBuilder.Build(localPos, worldPos, map, mesh, onlyLight);
}
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Accessors and Mutators
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#endregion
//---------------------------------------------------------------------------
#region Public Member Functions
//---------------------------------------------------------------------------
public void SetBlockSet(OpenCog.BlockSet.OCBlockSet blockSet) {
this.blockSet = blockSet;
index = Mathf.Clamp(index, 0, blockSet.BlockCount);
BuildBlock( blockSet.GetBlock(index) );
}
private static OpenCog.BlockSet.BaseBlockSet.OCBlock DrawInventory(OpenCog.BlockSet.OCBlockSet blockSet, ref UnityEngine.Vector2 scrollPosition, OpenCog.BlockSet.BaseBlockSet.OCBlock selected) {
scrollPosition = GUILayout.BeginScrollView(scrollPosition);
for(int i=0, y=0; i<blockSet.BlockCount; y++) {
GUILayout.BeginHorizontal();
for(int x=0; x<8; x++, i++) {
OpenCog.BlockSet.BaseBlockSet.OCBlock block = blockSet.GetBlock(i);
if( DrawBlock(block, block == selected && selected != null) ) {
selected = block;
}
}
GUILayout.EndHorizontal();
}
GUILayout.EndScrollView();
return selected;
}
public OCObjectMapInfo(int chunkX, int chunkY, int chunkZ, int blockGlobalX, int blockGlobalY, int blockGlobalZ, OpenCog.Map.OCBlockData blockData)
{
string blockName = "BLOCK_" + blockData.GetHashCode();
_height = 1;
_width = 1;
_length = 1;
_type = OCEmbodimentXMLTags.STRUCTURE_OBJECT_TYPE;
_id = blockName;//blockData.ID.ToString();
_name = blockName;
//this.Velocity = UnityEngine.Vector3.zero;
this.position = new UnityEngine.Vector3(blockGlobalX, blockGlobalY, blockGlobalZ);
_rotation = new OpenCog.Utility.Rotation(0, 0, 0);
// Add block properties
// AddTag ("class", "block", System.Type.GetType("System.String"));
// AddTag ("visibility-status", "visible", System.Type.GetType("System.String"));
// AddTag ("detector", "true", System.Type.GetType("System.Boolean"));
AddProperty ("class", "block", System.Type.GetType("System.String"));
AddProperty ("visibility-status", "visible", System.Type.GetType("System.String"));
AddProperty ("detector", "true", System.Type.GetType("System.Boolean"));
if (blockGlobalX == 9 && blockGlobalY == 140 && blockGlobalZ == 10)
{
UnityEngine.Debug.Log ("Break here plz...");
}
try {
string blockType = blockData.block.GetName();
if (blockType.ToLower() != "air")
{
string balls = "lol";
string lol = balls + "lol";
}
//UnityEngine.Debug.Log ("BlockData.GetType = " + blockType);
} catch (System.Exception ex) {
}
if (blockData.block == null)
{
// Report air
// this.AddTag (OCEmbodimentXMLTags.MATERIAL_ATTRIBUTE, "0", System.Type.GetType("System.String"));
this.AddProperty (OCEmbodimentXMLTags.MATERIAL_ATTRIBUTE, "0", System.Type.GetType("System.String"));
}
else
{
this.AddProperty (OCEmbodimentXMLTags.MATERIAL_ATTRIBUTE, blockData.block.GetName().ToLower (), System.Type.GetType("System.String"));
// if (blockData.block.GetName().ToLower () == "air")
// {
//// this.AddTag (OCEmbodimentXMLTags.MATERIAL_ATTRIBUTE, "0", System.Type.GetType("System.String"));
// this.AddProperty (OCEmbodimentXMLTags.MATERIAL_ATTRIBUTE, "0", System.Type.GetType("System.String"));
// }
// else
// {
//// this.AddTag (OCEmbodimentXMLTags.MATERIAL_ATTRIBUTE, "13", System.Type.GetType("System.String"));
// this.AddProperty (OCEmbodimentXMLTags.MATERIAL_ATTRIBUTE, "13", System.Type.GetType("System.String"));
// }
}
//mapinfo.AddProperty("color_name", "green", PropertyType.STRING);
}
public void sendBlockStructure(OpenCog.Map.OCBlockData startBlock, bool isToRecognize)
{
XmlDocument doc = new XmlDocument();
XmlElement root = MakeXMLElementRoot(doc);
string timestamp = GetCurrentTimestamp();
XmlElement signal = (XmlElement)root.AppendChild(doc.CreateElement("block-structure-signal"));
if(isToRecognize)
{
signal.SetAttribute("recognize-structure", "true");
signal.SetAttribute("startblock-x", startBlock.GlobalX.ToString());
signal.SetAttribute("startblock-y", startBlock.GlobalY.ToString());
signal.SetAttribute("startblock-z", startBlock.GlobalZ.ToString());
}
signal.SetAttribute("timestamp", timestamp);
OCMessage message = OCMessage.CreateMessage(_ID, _brainID, OCMessage.MessageType.STRING, BeautifyXmlText(doc));
OCLogger.Debugging("sending block structure signal: \n" + BeautifyXmlText(doc));
lock(_messageSendingLock)
{
_messagesToSend.Add(message);
}
}
public abstract void Build(Vector3i localPos, Vector3i worldPos, OpenCog.Map.OCMap map, OpenCog.Builder.OCMeshBuilder mesh, bool onlyLight);
