void RegisterMeshWithoutLightmap(MeshContainer n)
{
AbstractGeometryElem geo = null;
if (n.Mesh.name == "Sphere")
{
geo = new SphereBufferGeometryElem(n);
}
else if (n.Mesh.name == "Cylinder")
{
geo = new CylinderBufferGeometryElem(n);
}
else if (n.Mesh.name == "Quad")
{
geo = new QuadBufferGeometry(n);
//} else if(n.Mesh.name == "Cube") {
// geo = new BoxBufferGeometryElem(n);
}
else
{
geo = new BufferGeometryElem(n, false, Vector4.zero);
}
geo.Uuid = "geo-" + n.InstanceId;
root.SharedNodeTable.Add(geo, n.InstanceId);
}
private void CreateGeomManager()
{
List <double[]> n = new List <double[]>();
foreach (var line in nodeline)
{
double[] x = line.Coordinate;
if (x == null)
{
continue;
}
n.Add(x);
}
List <int[]> e = new List <int[]>();
foreach (var line in elementline)
{
int[] x = line.Triangle;
if (x == null)
{
continue;
}
e.Add(x);
}
double[,] point = ListToArray <double>(n);
int[,] element = ListToArray <int>(e);
geomManager = new MeshContainer(point, element);
}
public MeshContainer BuildTriTreeNodeMesh(int triTreeNode, float scale = 1f)
{
MutableGeoMesh mutablemesh = new MutableGeoMesh();
CollectVertexes(mutablemesh, triTreeNode);
mutablemesh.IndexTriangles();
List <Vector3> vertices = new List <Vector3>();
List <Vector2> uv = new List <Vector2>();
List <Vector3> normals = new List <Vector3>();
int[] triTreeNodesPair = GetTriTreeNodePair(triTreeNode);
foreach (int nodeIndex in mutablemesh.indexes)
{
vertices.Add(nodes[nodeIndex].position * scale);
normals.Add(nodes[nodeIndex].normal);
uv.Add(GetVertexUV(nodes[nodeIndex].position, triangleToPairsMap[triTreeNode]));
}
MeshContainer meshContainer = new MeshContainer();
meshContainer.vertices = vertices.ToArray();
meshContainer.normals = normals.ToArray();
meshContainer.triangles = mutablemesh.triangles.ToArray();
meshContainer.uv = uv.ToArray();
return(meshContainer);
}
public void Visit(MeshContainer n)
{
report.Info("## InstanceId: " + n.InstanceId);
report.Info("Name: " + n.Name);
report.Info("VertexCount: " + n.VertexCount);
report.Info("TriangleCount: " + n.TriangleCount);
}
public bool MoveNext()
{
if (End)
{
return(false);
}
if (MeshTracker != null)
{
MeshTracker = MeshTracker.NextContainer;
if (MeshTracker != null)
{
return(true);
}
}
while (FrameTracker.MoveNext())
{
Frame frame = FrameTracker.Current as Frame;
MeshTracker = frame.MeshContainer;
if (MeshTracker != null)
{
return(true);
}
}
End = true;
return(false);
}
public void Split(Transform splitTransform)
{
if (!_isSplitting)
{
_isSplitting = _splitMesh = true;
_splitPlane = new Plane(splitTransform);
MeshFilter[] meshFilters = GetComponentsInChildren <MeshFilter>();
_meshContainerStatic = new MeshContainer[meshFilters.Length];
_meshSplitterStatic = new IMeshSplitter[meshFilters.Length];
for (int i = 0; i < meshFilters.Length; i++)
{
_meshContainerStatic[i] = new MeshContainer(meshFilters[i]);
_meshSplitterStatic[i] = (IMeshSplitter) new MeshSplitterConvex(_meshContainerStatic[i], _splitPlane, splitTransform.rotation);
if (UseCapUV)
{
_meshSplitterStatic[i].SetCapUV(UseCapUV, CustomUV, CapUVMin, CapUVMax);
}
#if UNITY_EDITOR
_meshSplitterStatic[i].DebugDraw(ShowDebug);
#endif
}
}
}
public MeshIterator(MeshContainer container) //, float iterationTime, float iterationSpeed
{
meshContainer = container;
//IterationTime = iterationTime;
//IterationSpeed = iterationSpeed;
Iterations = new List <MeshIteration>();
}
public void Split(Transform splitTransform)
{
if (!_isSplitting)
{
_isSplitting = _splitMesh = true;
_splitPlane = new Plane(splitTransform);
MeshFilter[] meshFilters = GetComponentsInChildren<MeshFilter>();
_meshContainerStatic = new MeshContainer[meshFilters.Length];
_meshSplitterStatic = new IMeshSplitter[meshFilters.Length];
for (int i = 0; i < meshFilters.Length; i++)
{
_meshContainerStatic[i] = new MeshContainer(meshFilters[i]);
_meshSplitterStatic[i] = (IMeshSplitter)new MeshSplitterConvex(_meshContainerStatic[i], _splitPlane, splitTransform.rotation);
if (UseCapUV) _meshSplitterStatic[i].SetCapUV(UseCapUV, CustomUV, CapUVMin, CapUVMax);
#if UNITY_EDITOR
_meshSplitterStatic[i].DebugDraw(ShowDebug);
#endif
}
}
}
public void Split(Transform splitTransform)
{
if (!_isSplitting)
{
//If a cut is made then get the cut plane
_isSplitting = _splitMesh = true;
_splitPlane = new PlaneMath(splitTransform);
MeshFilter[] meshFilters = GetComponentsInChildren <MeshFilter>();
SkinnedMeshRenderer[] skinnedRenderes = GetComponentsInChildren <SkinnedMeshRenderer>();
_meshContainerStatic = new MeshContainer[meshFilters.Length];
_meshSplitterStatic = new IMeshSplitter[meshFilters.Length];
//Loop through each mesh filter and intitialze a capped mesh and save it in container
for (int i = 0; i < meshFilters.Length; i++)
{
_meshContainerStatic[i] = new MeshContainer(meshFilters[i]);
_meshSplitterStatic[i] = (IMeshSplitter) new MeshSplitterConcave(_meshContainerStatic[i], _splitPlane, splitTransform.rotation);
}
_meshSplitterSkinned = new IMeshSplitter[skinnedRenderes.Length];
_meshContainerSkinned = new MeshContainer[skinnedRenderes.Length];
//Although this function is rendundant here but it is important - it gets the bones and joints of the object incase the object is bendable
for (int i = 0; i < skinnedRenderes.Length; i++)
{
_meshContainerSkinned[i] = new MeshContainer(skinnedRenderes[i]);
_meshSplitterSkinned[i] = (IMeshSplitter) new MeshSplitterConcave(_meshContainerSkinned[i], _splitPlane, splitTransform.rotation);
}
}
}
public ModellingTreeNodeGrid(string name, ModellingTreeController treeController)
{
base.Name = name;
this.treeController = treeController;
geomManager = null;
this.treeController.RemoveNode += RemoveCurrentNode;
}
// Can't be [SetUp] because these Functions can't have a parameter.
private void SetUp(string prefabName)
{
// create a mock gameobject with a mesh
GameObject docMeshPref = Resources.Load <GameObject>(prefabName);
meshObj = GameObject.Instantiate(docMeshPref);
container = new MeshContainer(meshObj.transform);
}
public void MeshContainerIsNotNull_Test()
{
SetUp();
MeshContainer mc = GetPrivateField <MeshContainer>("meshContainer");
Assert.IsNotNull(mc);
}
public MeshSplitterConvex(MeshContainer meshContainer, Plane splitPlane, Quaternion splitRotation)
{
_mesh = meshContainer;
_splitPlane = splitPlane;
_splitRotation = splitRotation;
_ownRotation = meshContainer.transform.rotation;
capInds = new List<int>(meshContainer.vertexCount / 10);
}
public MeshSplitterConcave(MeshContainer meshContainer, Plane splitPlane, Quaternion splitRotation)
{
_mesh = meshContainer;
_splitPlane = splitPlane;
_splitRotation = splitRotation;
_ownRotation = meshContainer.transform.rotation;
_edges = new List <Edge>(meshContainer.vertexCount / 10);
}
public MeshSplitterConvex(MeshContainer meshContainer, Plane splitPlane, Quaternion splitRotation)
{
_mesh = meshContainer;
_splitPlane = splitPlane;
_splitRotation = splitRotation;
_ownRotation = meshContainer.transform.rotation;
capInds = new List <int>(meshContainer.vertexCount / 10);
}
private void Start()
{
isActive = false;
container = new MeshContainer(this.transform);
controller = new MeshController(container);
container.ApplyColor(ColorCalculator.BASE_COLOR);
}
public MeshController(MeshContainer container)
{
this.meshContainer = container;
this.VerticeData = SetVerticeData();
this.RelevantVertices = new List <int>();
LinkVerticesWithSamePosition();
}
public static ModelResourceNode Convert(LmMsgPck msg)
{
var aabb = LmAABB.Unpack(msg);
var boneTable = LmBoneTable.Unpack(msg);
var i = 0u;
var modelResourceNode = new ModelResourceNode();
foreach (var boneInfo in boneTable.BoneInfos)
{
modelResourceNode.MeshBoneInformation.Bones.Add(new MeshBoneInformation.Bone(boneInfo.BoneName, boneInfo.LodBoneIdx, boneInfo.UniqueBoneIdx));
// FIXME modelResourceNode.MeshBoneInformation.BoneLut.Add(boneInfo.UniqueBoneIdx, i);
i++;
}
modelResourceNode.NodeTable = LmNodeTable.Unpack(msg);
if (msg.Version >= 20141113)
{
var assetHash = (ulong)msg.Read();
// TODO msg.UserData.GpuBuffer = msg.UserData.DependencyTable.Get(assetHash);
}
var meshContainerCount = (int)msg.Read();
for (var _ = 0; _ < meshContainerCount; _++)
{
var meshContainer = MeshContainer.Convert(msg);
modelResourceNode.MeshContainers.Add(meshContainer);
}
if (msg.Version >= 20140623)
{
var unknown = msg.ReadBool();
modelResourceNode.Name = msg.ReadString();
}
if (msg.Version >= 20140722 && msg.Version < 20140929)
{
var hasPsdData = msg.ReadBool();
var psdDataHash = msg.ReadUint64();
}
if (msg.Version < 20140815)
{
return(modelResourceNode);
}
var gmdlPartsDatasCount = msg.ReadUint();
for (var _ = 0; _ < gmdlPartsDatasCount; _++)
{
var gmdlPartsData = GmdlPartsData.Unpack(msg);
modelResourceNode.GmdlPartsDatas.Add(gmdlPartsData);
}
return(modelResourceNode);
}
/// <summary>
/// This is the function that generates the correct scad code for our Mesh
/// </summary>
/// <param name="objectToProcess"></param>
/// <param name="level"></param>
/// <returns></returns>
public string GetScadOutputRecursive(MeshContainer objectToProcess, int level = 0)
{
string info = AddRenderInfoIfReqired(objectToProcess);
string mesh_string = "import(\"{0}\");".FormatWith(objectToProcess.FilePath);
info += mesh_string + AddNameAsComment(objectToProcess);
return(ApplyIndent(info, level));
}
// Can't use normal [SetUp], because one test use different mocks.
// The default SetUp-Method can't have parameters.
public void SetUp(string mockName = "Mock_simple")
{
GameObject docMeshPref = Resources.Load <GameObject>("Prefabs/" + mockName);
docMeshObj = GameObject.Instantiate(docMeshPref);
MeshContainer container = new MeshContainer(docMeshPref.transform);
controller = new MeshController(container);
}
///-----------------------------------------------------------------
public LineData(int capacity, GameObject gameObject, MeshRenderer renderer, Material material, int borderThickness)
{
this.gameObject = gameObject;
this.material = material;
forceDirtyPass = false;
index = 0;
mesh = new MeshContainer(capacity, renderer, borderThickness);
positions = new BufferContainer(capacity);
colors = new BufferContainer(capacity);
}
public void SendMesh(MeshContainer newMesh)
{
Mesh mesh = new Mesh
{
vertices = newMesh.vertecies.ToArray(),
triangles = newMesh.triangles.ToArray()
};
newMesh.gameObject.GetComponent <MeshFilter>().mesh = mesh;
newMesh.gameObject.GetComponent <MeshRenderer>().material = baseMaterial;
newMesh.gameObject.GetComponent <MeshRenderer>().material.color = Random.ColorHSV(0f, 1f, .5f, .5f, .25f, .75f, 1f, 1f);
}
void CreateObject(Object obj, MyObjectType t)
{
GameObject go = Instantiate(slotTemplate) as GameObject;
go.SetActive(true);
go.transform.SetParent(gridParent);
go.transform.localScale = Vector3.one;
createdObjs.Add(go);
UI.UI_Slot slot = go.GetComponent <UI_Slot>();
string targetText = null;
bool isEquiped = false;
isEquiped = gameSettings.isEquiped(obj, t);
switch (t)
{
case MyObjectType.mw:
Weapon mw = (Weapon)obj;
targetText = mw.id.value;
break;
case MyObjectType.sw:
Weapon sw = (Weapon)obj;
targetText = sw.id.value;
break;
case MyObjectType.mask:
Mask m = (Mask)obj;
targetText = m.obj.id.value;
break;
case MyObjectType.skill:
break;
case MyObjectType.outfit:
MeshContainer mc = (MeshContainer)obj;
targetText = mc.id.value;
break;
default:
break;
}
slot.type = type;
slot.obj = obj;
slot.item.text = targetText;
slot.tick.SetActive(isEquiped);
bool isBought = gameSettings.playerProfile.IsBought(targetText);
slot.item.color = (isBought) ? Color.white : Color.gray;
}
private void RemoveCurrentNode(object sender, EventArgs args)
{
if (args is EventArgsModellingTreeNode)
{
MshToMatWPF.ModellingTree.ModellingTreeNode node = (args as EventArgsModellingTreeNode).nodeCurrent;
if ((node != this) & (treeController.DetermParentFromPair(node, this) != node))
{
return;
}
geomManager = null;
}
}
public Actor(MeshContainer Mesh, string Name) : base()
{
this.ID = Guid.NewGuid().ToString();
this.Name = Name;
this._Modified = false;
this.Type = DrawObjectType.Actor;
this._GeometryMaterialIndices = new List <int>();
this._Geometries = Mesh.Geometries;
this._Materials = new List <Material>();
this._Materials.Add(new Material(ID + "_01", Material.Default));
for (int i = 0; i < this._Geometries.Count; i++)
{
this.GeometryMaterialIndices.Add(0);
}
}
MeshContainer CompileSnapBuffer()
{
CreateSnap = true;
RenderKind Save = Device.RenderKind;
StoredSnapItems.Clear();
StoredSnapItems.Add(null);
RegisterLocked = false;
Device.RenderKind = RenderKind.SnapBuffer;
MeshContainer Result = MeshCreator.CreateMeshes(Device, CompileDraw);
Device.RenderKind = Save;
RegisterLocked = true;
CreateSnap = false;
return(Result);
}
BoundingBox GetMinMaxValues(MeshContainer mc)
{
DataStream ds = mc.MeshData.Mesh.LockVertexBuffer(LockFlags.ReadOnly);
List <Vector3> vertices = new List <Vector3>();
do
{
vertices.Add(ds.Read <Vector3>());
ds.Seek(mc.MeshData.Mesh.BytesPerVertex - Vector3.SizeInBytes, System.IO.SeekOrigin.Current);
} while (ds.Position < ds.Length);
var bb = BoundingBox.FromPoints(vertices.ToArray());
mc.MeshData.Mesh.UnlockVertexBuffer();
return(bb);
}
void VisitToCreateMesh_r(GameObject go)
{
if (go.GetComponent <Renderer>())
{
var mesh = ComponentHelper.GetMesh(go);
if (!containerTable.Contains <MeshContainer>(mesh.GetInstanceID()))
{
var c = new MeshContainer(mesh);
containerTable.Add(c.InstanceId, c);
}
}
for (int i = 0; i < go.transform.childCount; i++)
{
VisitToCreateMesh_r(go.transform.GetChild(i).gameObject);
}
}
public void ContextMenuImport(object sender, EventArgs args)
{
if (importDialog != null)
{
ModellingTreeNodeDialogDataImport data = new ModellingTreeNodeDialogDataImport();
data.node = this;
importDialog(data);
if (data.filename != string.Empty)
{
ImportMesh imp = new ImportMeshMsh(data.filename);
imp.Build();
this.geomManager = imp.geomManager;
}
}
}
/// <summary>
/// Nacteni animovaneho modelu
/// </summary>
/// <param name="loaded">>Entita do ktere bude pridan parametr s animaci</param>
/// <param name="objectUrl">Adresa k souboru .X s animaci</param>
/// <param name="name">Jmeno modelu</param>
/// <returns>Entitu s animaci</returns>
private Entity LoadAnimatedObject(Entity loaded, string objectUrl, string name)
{
AllocateHierarchy alloc;
alloc = new WiccanRede.Graphics.Scene.SpecialObjects.AnimatedObject.AnimationAllocation();
try
{
rootFrame = Mesh.LoadHierarchyFromFile(objectUrl, MeshFlags.Managed, dev, alloc, null);
}
catch (Exception)
{
Console.WriteLine("Chyba pri nacitani ze souboru");
}
SetupBoneMatrices(rootFrame.FrameHierarchy as anim.AnimationFrame);
List <MeshContainer> meshes = new List <MeshContainer>();
Frame rf = rootFrame.FrameHierarchy;
getAnimationMesh(rf, meshes);
MeshContainer mc = meshes[0];
ExtendedMaterial[] materials = mc.GetMaterials();
Texture[] textures = new Texture[materials.Length];
string pathname = Path.GetDirectoryName(objectUrl) + @"\";
// load textures
for (int i = 0; i < materials.Length; i++)
{
if (materials[i].TextureFilename != null)
{
if (File.Exists((pathname + materials[i].TextureFilename)))
{
textures[i] = TextureLoader.FromFile(dev, (pathname + materials[i].TextureFilename),
0, 0, 0, Usage.None, Format.R8G8B8, Pool.Managed, Filter.Linear, Filter.Linear, 0);
}
}
}
loaded.AddParametr(new Parametr("Objekt[]", "textures", textures));
loaded.AddParametr(new Parametr("Microsoft.DirectX.Direct3D.AnimationRootFrame", name, rootFrame));
loaded.AddParametr(new Parametr("Microsoft.DirectX.Direct3D.ProgressiveMesh", "pMesh", GetMesh(rootFrame)));
return(loaded);
}
public void Buy()
{
GameSettings s = Resources.Load("Game Settings") as GameSettings;
if (curCost > s.playerProfile.money.value)
{
return;
}
s.playerProfile.money.value -= curCost;
switch (storeType)
{
case MyObjectType.mw:
Weapon mw = s.r_manager.GetWeapon(storeId);
s.playerProfile.bought_items.Add(mw.id.value);
break;
case MyObjectType.sw:
Weapon sw = s.r_manager.GetWeapon(storeId);
s.playerProfile.bought_items.Add(sw.id.value);
break;
case MyObjectType.mask:
Mask m = s.r_manager.GetMask(storeId);
s.playerProfile.bought_items.Add(m.obj.id.value);
break;
case MyObjectType.skill:
break;
case MyObjectType.outfit:
MeshContainer mc = s.r_manager.GetMesh(storeId);
s.playerProfile.bought_items.Add(mc.id.value);
break;
default:
break;
}
EquipItem(s, storeType);
onProfileUpdate.Raise();
isTrue.Invoke();
}
public override void SetUserDataInMeshContainer(MeshContainer meshcontainer)
{
G3DMesh g3dmesh = new G3DMesh();
ExtendedMaterial[] materials = meshcontainer.GetMaterials();
if (materials != null)
{
g3dmesh.Materials = new Material[materials.Length];
g3dmesh.Textures = new Texture[materials.Length];
for (int i = 0; i < materials.Length; i++)
{
// Load texture from file or resource
if (materials[i].TextureFilename != null)
{
Texture texture;
try
{
texture = TextureLoader.FromFile(meshcontainer.MeshData.Mesh.Device, materials[i].TextureFilename);
}
catch
{
try
{
texture = TextureLoader.FromStream(meshcontainer.MeshData.Mesh.Device, System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(materials[i].TextureFilename));
}
catch
{
texture = null;
}
}
g3dmesh.Textures[i] = texture;
}
// Load material
g3dmesh.Materials[i] = materials[i].Material3D;
g3dmesh.Materials[i].Ambient = g3dmesh.Materials[i].Diffuse;
}
}
g3dmesh.Mesh = meshcontainer.MeshData.Mesh;
meshcontainer.UserData = g3dmesh;
}
BoundingBox GetMinMaxValues(MeshContainer mc)
{
DataStream ds = mc.MeshData.Mesh.LockVertexBuffer(LockFlags.ReadOnly);
List<Vector3> vertices = new List<Vector3>();
do
{
vertices.Add(ds.Read<Vector3>());
ds.Seek(mc.MeshData.Mesh.BytesPerVertex - Vector3.SizeInBytes, System.IO.SeekOrigin.Current);
} while (ds.Position < ds.Length);
var bb = BoundingBox.FromPoints(vertices.ToArray());
mc.MeshData.Mesh.UnlockVertexBuffer();
return bb;
}
public bool MoveNext()
{
if(End)
return false;
if( MeshTracker != null)
{
MeshTracker = MeshTracker.NextContainer;
if(MeshTracker != null)
return true;
}
while(FrameTracker.MoveNext())
{
Frame frame = FrameTracker.Current as Frame;
MeshTracker = frame.MeshContainer;
if(MeshTracker != null)
return true;
}
End = true;
return false;
}
public void Reset()
{
FrameTracker.Reset();
MeshTracker = null;
End = false;
}
