public override void ApplyLOD()
{
BaseMesh bmesh = base.GetModel();
if (bmesh is ProgressiveMesh)
{
return;
}
if (bmesh != null && !bmesh.Disposed)
{
float LODquality = 1f;
bool enableLOD = base.isEnableLOD();
if (enableLOD)
{
LODquality = 1f / (1f + 0.003f * base.GetDistanceFromCamera());
}
ProgressiveMesh mesh = bmesh as ProgressiveMesh;
int LOD = (int)(mesh.MaxFaces * LODquality * base.GetObjectQuality());
if (lastLOD != LOD && enableLOD)
{
mesh.NumberFaces = LOD;
lastLOD = LOD;
}
}
base.ApplyLOD();
}
void ExportImage(BaseMesh _target, string exportName)
{
if (exportName == null || exportName == "")
{
EditorUtility.DisplayDialog("Error!", "Export file name field is empty." +
"Please specify the file name in which you want to export the map.", "Got it!");
return;
}
Texture2D exportImage = new Texture2D(_target.GridColumnCount, _target.GridRowCount, TextureFormat.RGB24, false, true);
for (int i = 0; i < _target.GridColumnCount; i++)
{
for (int j = 0; j < _target.GridRowCount; j++)
{
exportImage.SetPixel(i, j, _target.gridArrayColumn[i].gridRow[j].filled ? Color.black : Color.white);
}
}
byte[] bytes = exportImage.EncodeToJPG();
string path = Application.dataPath + "/Resources/LevelsExport/" + exportName + ".jpg";
System.IO.File.WriteAllBytes(path, bytes);
EditorUtility.DisplayDialog("Success", "Exported successfully here. \n" + path, "Thanks!");
AssetDatabase.ImportAsset(path);
AssetDatabase.Refresh();
}
public override void ApplyLOD()
{
BaseMesh bmesh = base.GetModel();
if (bmesh != null && !bmesh.Disposed)
{
float LODquality = 1f;
if (base.isEnableLOD())
{
LODquality = 1f / (1f + 0.008f * base.GetDistanceFromCamera());
}
ProgressiveMesh mesh = bmesh as ProgressiveMesh;
int LOD = (int)(mesh.MaxFaces * LODquality * base.GetObjectQuality());
if (lastLOD != LOD)
{
try
{
mesh.NumberFaces = LOD;
lastLOD = LOD;
}
catch (Exception ex)
{
Logging.Logger.AddError(ex.Message);
}
}
}
base.ApplyLOD();
}
public QuadTreeGeneralObject(int level, GeneralObject.GeneralVertex[] vertexes, int[] indexes, Vector3 minPosition, Vector3 maxPosition, Matrix world, Texture[] color_textures0, Texture[] color_textures1, Texture[] color_textures2, Texture[] normal_textures)
: base(null, world, color_textures0, color_textures1, color_textures2, normal_textures)
{
this.vertexes = vertexes;
this.mesh = null;
this.device = color_textures0[0].Device;
this.vertexDecl = new VertexDeclaration(this.device, GeneralObject.GeneralVertex.vertexElements);
this.vb = new VertexBuffer(typeof(GeneralObject.GeneralVertex), vertexes.Length, this.device, Usage.WriteOnly, GeneralObject.GeneralVertex.Format, Pool.Managed);
this.vb.SetData(vertexes, 0, LockFlags.NoSystemLock);
Key key = new Key(this.device, base.GetMatrixWorld(), this.vertexes, indexes, minPosition, maxPosition);
this.radius = key.radius;
this.boundingSphereCenter = key.boundingSphereCenter;
this.quadTree = new TreeGraph <Key>(4, key);
try
{
GenerateQuadTree(level, this.quadTree);
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message);
}
}
} // Renderizar().fim
// ---]
// [---
private void desenharObjeto(BaseMesh obj, Propriedades3D props)
{
// Ajusta rotação do objeto 3d
Matrix obj_rot = Matrix.RotationX(props.rotation.X + angulo) *
Matrix.RotationY(props.rotation.Y) *
Matrix.RotationZ(props.rotation.Z);
// Ajusta posição do objeto 3d
Matrix obj_pos = Matrix.Translation(props.position);
// Tranfere posição e rotação para o mundo
device.Transform.World = obj_rot * obj_pos;
// Prepara e aplica material\textura no objeto
for (int ncx = 0; ncx < g_meshMtl.Length; ncx++)
{
// Informa ao dispositivo o material a ser utilizado
// na renderização
device.Material = g_meshMtl[ncx];
device.SetTexture(0, g_meshTex[ncx]);
// Renderiza o mesh
obj.DrawSubset(ncx);
} // endfor
} // desenharObjeto().fim
void ImportImage(BaseMesh _target, Texture2D _sourceTexture)
{
if (_sourceTexture == null)
{
EditorUtility.DisplayDialog("Error!", "Import image field is empty. " +
"Please assign any image from project to import it as a level.\n " +
"And please make that texture read/write enabled in import settings.", "Got it!");
return;
}
//Just to make the texture readable from Import settings.
string path = AssetDatabase.GetAssetPath(_sourceTexture);
TextureImporter importSetting = (TextureImporter)AssetImporter.GetAtPath(path);
importSetting.isReadable = true;
importSetting.generateMipsInLinearSpace = false;
importSetting.npotScale = TextureImporterNPOTScale.None;
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
//Parsing image and converting it into Map.
_target.GridColumnCount = _sourceTexture.width;
_target.GridRowCount = _sourceTexture.height;
GridArray [] tempGridArray = new GridArray[_target.GridColumnCount];
for (int i = 0; i < tempGridArray.GetLength(0); i++)
{
tempGridArray[i] = new GridArray(new Grid [_target.GridRowCount]);
}
for (int i = 0; i < _target.GridColumnCount; i++)
{
for (int j = 0; j < _target.GridRowCount; j++)
{
Color readColor = _sourceTexture.GetPixel(i, j);
bool filled;
if (((readColor.r + readColor.g + readColor.b) / 3) < 0.5f)
{
filled = true;
}
else
{
filled = false;
}
tempGridArray[i].gridRow[j] = new Grid(filled, i, j, new Vector3(_target.GridXOffset + i * _target.gridScale + _target.gridScale / 2,
_target.yOffset,
_target.GridZOffset + j * _target.gridScale + _target.gridScale / 2));
}
}
_target.gridArrayColumn = tempGridArray;
}
public static Task CreateIndependenceActionTask(
AuthTokens tokens,
string url,
string path,
string parentId,
string dependentOn,
BaseMesh meshData,
bool create
)
{
var actionTask = new GenericViewSet <Task>(
tokens,
url,
path
).GetOrCreate(
new Dictionary <string, object>
{
{ "name", "Actions" },
{ "parent", parentId },
{ "dependent_on", dependentOn }
},
new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "magpy" },
{ "cmd", "pipelines.pipeline" },
{ "commands", new List <string>
{
"magpy_copytree",
"write_mesh"
} },
{ "src", "foam" },
{ "dst", $"independence/mesh_{meshData.CellSize}/foam" },
{ "base_mesh", meshData },
{ "snappyhex_mesh", null }
}
}
},
create
);
return(actionTask);
}
public static Result Hook06000035(BaseMesh obj, int subset)
{
TextureAddress addr_u = 0.0f <= mat_last.Specular.Red && mat_last.Specular.Green <= 1.0f ? TextureAddress.Clamp : TextureAddress.Wrap;
if (addr_u != last_u)
{
obj.Device.SetSamplerState(0, SamplerState.AddressU, addr_u);
last_u = addr_u;
}
TextureAddress addr_v = 0.0f <= mat_last.Specular.Blue && mat_last.Specular.Alpha <= 1.0f ? TextureAddress.Clamp : TextureAddress.Wrap;
if (addr_v != last_v)
{
obj.Device.SetSamplerState(0, SamplerState.AddressV, addr_v);
last_v = addr_v;
}
return(obj.DrawSubset(subset));
}
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="mesh">Objekt, ktery se bude kreslit</param>
/// <param name="world">World matice</param>
/// <param name="color_textures0">Pole textur nultyho bufferu</param>
/// <param name="color_textures1">Pole textur prvniho bufferu</param>
/// <param name="color_textures2">Pole textur druhyho bufferu</param>
/// <param name="normal_textures">Pole normalovych textur</param>
public GeneralObject(BaseMesh mesh, Matrix world, Texture[] color_textures0, Texture[] color_textures1, Texture[] color_textures2, Texture[] normal_textures)
{
SetModel(mesh);
this.color_textures0 = color_textures0;
this.color_textures1 = color_textures1;
this.color_textures2 = color_textures2;
this.normal_textures = normal_textures;
worldOriginal = world;
SetMatrixWorld(world);
if (mesh != null)
{
VertexBuffer vb = mesh.VertexBuffer;
GraphicsStream gsm = vb.Lock(0, 0, LockFlags.ReadOnly);
radius = Geometry.ComputeBoundingSphere(gsm, mesh.NumberVertices, GeneralVertex.SizeInBytes, out boundingSphereCenter);
Geometry.ComputeBoundingBox(gsm, mesh.NumberVertices, GeneralVertex.SizeInBytes, out minBoundingPosition, out maxBoundingPosition);
vb.Unlock();
Vector3 size = maxBoundingPosition - minBoundingPosition;
boundingSphereMesh = Mesh.Sphere(this.mesh.Device, radius, 8, 8);
Vector3 length = maxBoundingPosition - minBoundingPosition;
boundingBoxMesh = Mesh.Box(this.mesh.Device, length.X, length.Y, length.Z);
Mesh temp = boundingSphereMesh.Clone(MeshFlags.Managed, GeneralObject.GeneralVertex.vertexElements, vb.Device);
boundingSphereMesh.Dispose();
boundingSphereMesh = temp;
temp = boundingBoxMesh.Clone(MeshFlags.Managed, GeneralObject.GeneralVertex.vertexElements, vb.Device);
boundingBoxMesh.Dispose();
boundingBoxMesh = temp;
boundingMeshWorld = new Matrix[4];
boundingMeshWorldIT = new Matrix[4];
boundingMeshWorld[0] = Matrix.Translation(boundingSphereCenter) * GetMatrixWorld();
boundingMeshWorld[1] = Matrix.Translation(0.5f * (minBoundingPosition + maxBoundingPosition)) * GetMatrixWorld();
boundingMeshWorldIT[0] = Matrix.TransposeMatrix(Matrix.Invert(boundingMeshWorld[0]));
boundingMeshWorldIT[1] = Matrix.TransposeMatrix(Matrix.Invert(boundingMeshWorld[1]));
boundingBoxNormals = CreateBoundingBoxNormals();
}
}
public override void OnInspectorGUI()
{
BaseMesh _target = (BaseMesh)target;
_target.editGrid = EditorGUILayout.Toggle("Edit Grid", _target.editGrid);
if (_target.editGrid)
{
_target.GridRowCount = EditorGUILayout.IntSlider("Row Count :", _target.GridRowCount, 0, 100, GUILayout.MinWidth(300), GUILayout.MaxWidth(300));
_target.GridColumnCount = EditorGUILayout.IntSlider("Column Count :", _target.GridColumnCount, 0, 100, GUILayout.MinWidth(300), GUILayout.MaxWidth(300));
// _target.GridScale = EditorGUILayout.Slider("Scale :", _target.GridScale, 0.01f, 1);
_target.GridXOffset = EditorGUILayout.FloatField("Offset X :", _target.GridXOffset);
_target.GridZOffset = EditorGUILayout.FloatField("Offset Y :", _target.GridZOffset);
//Export Level as a image.
GUILayout.BeginHorizontal();
exportName = EditorGUILayout.TextField(new GUIContent(), exportName, GUILayout.MinWidth(100), GUILayout.MaxWidth(100));
if (GUILayout.Button("Export Level", GUILayout.MinWidth(100), GUILayout.MaxWidth(100)))
{
ExportImage(_target, exportName);
}
GUILayout.EndHorizontal();
//Import Level from a image.
GUILayout.BeginHorizontal();
importImage = EditorGUILayout.ObjectField(new GUIContent(), importImage, typeof(Texture2D), true, GUILayout.MinWidth(100), GUILayout.MaxWidth(100)) as Texture2D;
if (GUILayout.Button("Import Level", GUILayout.MinWidth(100), GUILayout.MaxWidth(100)))
{
ImportImage(_target, importImage);
}
GUILayout.EndHorizontal();
GridMapEditor(_target);
}
SceneView.RepaintAll();
}
/// <summary>
/// Provede uklid textur, meshe a bounding boxu
/// </summary>
public virtual void Dispose()
{
if (normal_textures != null)
{
for (int t = 0; t < normal_textures.Length; t++)
{
if (normal_textures[t] != null && !normal_textures[t].Disposed)
{
normal_textures[t].Dispose();
}
}
}
if (color_textures0 != null)
{
for (int t = 0; t < color_textures0.Length; t++)
{
if (color_textures0[t] != null && !color_textures0[t].Disposed)
{
color_textures0[t].Dispose();
}
}
}
if (mesh != null && !mesh.Disposed)
{
try
{
mesh.Dispose();
mesh = null;
}
catch { }
}
if (boundingSphereMesh != null && !boundingSphereMesh.Disposed)
{
boundingSphereMesh.Dispose();
}
disposed = true;
}
void GridMapEditor(BaseMesh _target)
{
for (int i = 0; i < _target.GridColumnCount; i++)
{
GUILayout.BeginHorizontal();
for (int j = 0; j < _target.GridRowCount; j++)
{
if (_target.gridArrayColumn == null ||
i >= _target.gridArrayColumn.Length ||
_target.gridArrayColumn[i] == null ||
j >= _target.gridArrayColumn[i].gridRow.Length ||
_target.gridArrayColumn[i].gridRow[j] == null)
{
continue;
}
_target.gridArrayColumn[i].gridRow[j].filled = EditorGUILayout.Toggle(new GUIContent(), //"Grid[" + i + "," + j + "] :",
_target.gridArrayColumn[i].gridRow[j].filled,
GUILayout.MinWidth(10),
GUILayout.MaxWidth(10));
}
GUILayout.EndHorizontal();
}
}
public void OnEnable()
{
BaseMesh _target = (BaseMesh)target;
BaseMesh.Instance = _target;
}
/// <summary>
/// Use the current technique to render with a Mesh.DrawSubset() call
/// </summary>
/// <param name="technique"></param>
public static void DrawMeshSubset(BaseMesh mesh, int index)
{
int passes = effect.Begin(0);
for (int pass = 0; pass < passes; pass++)
{
effect.BeginPass(pass);
effect.CommitChanges();
mesh.DrawSubset(index);
effect.EndPass();
}
effect.End();
}
void Awake()
{
Instance = this;
}
// Draws the given mesh
public void render(BaseMesh mesh)
{
if(mesh.texture.ID!= currTextureID)
{
currTextureID= mesh.texture.ID;
Gl.glBindTexture(Gl.GL_TEXTURE_2D, currTextureID);
}
mesh.render();
}
// Creates a bounding volume box from the given 3d mesh
public static BVBox createFromMesh(BaseMesh mesh)
{
if(mesh== null)
throw new ArgumentNullException();
return createFromPoints(mesh.getVertices());
}
/// <summary>
/// Nastavi model, ktery bude pouzit pro rendering
/// </summary>
/// <param name="mesh">Model</param>
public void SetModel(BaseMesh mesh)
{
this.mesh = mesh;
UpdateVerticesFacesCounters();
}
