public static void DrawSimpleQuad3D() { // We create a 3d quad, so we need a camera. BaseCamera cam = new LookAtCamera(new Vector(4, -4, 4)); // Create a geometry data instance which will hold the actual data. GeometryData geometryData = new GeometryData("<SimpleQuad3D>", 4, VertexFormat.Position3DTextured, 6, true, false); // Fill the geometry with actual data. geometryData.SetVertexData(0, new Vector(1, 0, 0), Point.One); geometryData.SetVertexData(1, new Vector(-1, 0, 0), Point.UnitY); geometryData.SetVertexData(2, new Vector(-1.25f, 0, 1), Point.Zero); geometryData.SetVertexData(3, new Vector(1.25f, 0, 1), Point.UnitX); geometryData.Indices = new ushort[] { 0, 2, 1, 0, 3, 2, }; // Now create a geometry from the data. Geometry geometry = Geometry.Create(geometryData); // We need a material to draw the geometry. Simply use the default. MaterialColored material = MaterialColored.Default; // Now start the application... Application.Start(delegate { // ...and draw the geometry. material.Draw(geometry); }); }
public static IEnumerable <GeometryData> Load(PointFile source) { var fact = new GeometryFactory(); using StreamReader reader = File.OpenText(source.Filename); var options = new CsvOptions { HeaderMode = source.HeaderMode, RowsToSkip = source.RowsToSkip, Separator = source.Separator[0] }; CoordinateSystem f = ProjectionUtils.Transforms[source.Srid]; CoordinateSystem t = ProjectionUtils.EPSG_4326(); foreach (var row in CsvReader.Read(reader, options).Take(source.MaxRecords ?? int.MaxValue)) { double.TryParse(row[source.Latitude], out double latitude); double.TryParse(row[source.Longitude], out double longitude); var geom = new Coordinate(longitude, latitude); geom = geom.Transform(f, t); var data = new GeometryData { DataType = source.DataType, Geom = fact.CreatePoint(geom), Name = row[source.Name], Reference = source.Reference != null ? row[(int)source.Reference] : null, }; yield return(data); } }
private static void AddFaceWater(BlockClass[][][] blocks, GeometryData geo, byte dir, Vector3Int center) { for (var i = 0; i < 4; i++) { var blk = center + BlockProperties.FacePts[BlockProperties.BlockFaces[dir, i]]; geo.Vertices.Add(blk + blocks[blk.x + 1][blk.y + 1][blk.z + 1].Data.ControlPoint); geo.Normals.Add(BlockProperties.DirectionVector[dir]); } var sc = geo.Vertices.Count - 4; // squareCount << 2;//Multiply by 4 geo.Triangles.Add(sc); geo.Triangles.Add(sc + 1); geo.Triangles.Add(sc + 3); geo.Triangles.Add(sc + 1); geo.Triangles.Add(sc + 2); geo.Triangles.Add(sc + 3); var v = blocks[center.x + 1][center.y + 1][center.z + 1].GetTex(); var uv = new Vector2(0, 0); geo.UV.Add(uv); geo.UV.Add(new Vector2(1, 0)); geo.UV.Add(new Vector2(1, 1)); geo.UV.Add(new Vector2(0, 1)); }
public static IEnumerable <GeometryData> Load(PolygonFile source) { var geomFact = new GeometryFactory(); using var reader = new ShapefileDataReader(source.Filename, geomFact); CoordinateSystem f = ProjectionUtils.Transforms[source.Srid]; CoordinateSystem t = ProjectionUtils.EPSG_4326(); var transformer = ProjectionUtils.GetTransformer(f, t); while (reader.Read()) { var name = reader.GetString(source.Name); string reference = null; if (source.Reference != null) { reference = reader.GetString((int)source.Reference); } if (reference == null) { reference = Guid.NewGuid().ToString(); } var geom = ProjectionUtils.Transform(reader.Geometry, transformer); var data = new GeometryData { Name = name, DataType = source.DataType, Reference = reference, Geom = geom }; yield return(data); } }
/// <summary> /// Generate the common Rectangle geometry. (Only one Rectangle) /// </summary> private void GenerateCommonGeometry() { GeometryData[] _vertices = new GeometryData[4]; #region filling vertices _vertices[0].World = new Color((byte)0, (byte)0, (byte)0, (byte)0); //float3 _vertices[0].AtlasCoordinate = new Color((byte)0, (byte)0, (byte)0, (byte)0); //flaot2 _vertices[1].World = new Color((byte)255, (byte)0, (byte)0, (byte)0); _vertices[1].AtlasCoordinate = new Color((byte)255, (byte)0, (byte)0, (byte)0); _vertices[2].World = new Color((byte)0, (byte)255, (byte)0, (byte)0); _vertices[2].AtlasCoordinate = new Color((byte)0, (byte)255, (byte)0, (byte)0); _vertices[3].World = new Color((byte)255, (byte)255, (byte)0, (byte)0); _vertices[3].AtlasCoordinate = new Color((byte)255, (byte)255, (byte)0, (byte)0); #endregion this.geometryBuffer = new VertexBuffer(this.GraphicsDevice, GeometryData.VertexDeclaration, 4, BufferUsage.WriteOnly); this.geometryBuffer.SetData(_vertices); #region filling indices short[] _indices = new short[6]; _indices[0] = 0; _indices[1] = 1; _indices[2] = 2; _indices[3] = 1; _indices[4] = 3; _indices[5] = 2; #endregion this.indexBuffer = new IndexBuffer(this.GraphicsDevice, typeof(short), _indices.Length, BufferUsage.WriteOnly); this.indexBuffer.SetData(_indices); }
private static void RegisterCircle() { GeometryData shapeData = CreateRegularPolygon(90); shapeData.Managed = true; RegisterShapeData("Relatus_Circle", shapeData); }
public static GeometryData GetGeometryData(SvgMeshData data, bool instanced) { var result = new GeometryData() { VertexCount = data.Vertices.Count, Indices = data.Indices.ToArray(), Attribs = instanced ? MeshHelper.PositionColorInstancedVertex.VertexAttribs : MeshHelper.PositionColorVertex.VertexAttribs }; using (var stream = new System.IO.MemoryStream()) using (var writer = new System.IO.BinaryWriter(stream)) { for (int i = 0; i < data.Vertices.Count; i++) { writer.Write(data.Vertices[i].PosX); writer.Write(data.Vertices[i].PosY); writer.Write(data.Vertices[i].PosZ); writer.Write(data.Vertices[i].R); writer.Write(data.Vertices[i].G); writer.Write(data.Vertices[i].B); writer.Write(data.Vertices[i].A); } result.Data = stream.ToArray(); } return(result); }
public TaskService(IFileHelper fileHelper, IJsonSerialize jsonSerialize) { _fileHelper = fileHelper; _jsonSerialize = jsonSerialize; _geometryData = App.Provider.GetRequiredService <GeometryData>(); }
private static GeometryData GenerateGeometryDataFromAssimpMesh(Assimp.Mesh mesh) { var geometryData = new GeometryData { Vertices = new VertexPositionNormalTexture[mesh.VertexCount], Indices = new ushort[mesh.FaceCount * 3] }; geometryData.Vertices = new VertexPositionNormalTexture[mesh.VertexCount]; for (var i = 0; i < mesh.VertexCount; i++) { var vertex = mesh.Vertices[i]; geometryData.Vertices[i].Position = new Vector3(vertex.X, vertex.Y, vertex.Z); var normal = mesh.HasNormals ? mesh.Normals[i] : new Vector3D(); geometryData.Vertices[i].Normal = new Vector3(normal.X, normal.Y, normal.Z); var texcoord = mesh.HasTextureCoords(0) ? mesh.TextureCoordinateChannels[0][i] : new Vector3D(); geometryData.Vertices[i].TextureCoordinate = new Vector2(texcoord.X, texcoord.Y); } for (var i = 0; i < mesh.FaceCount; i++) { geometryData.Indices[i * 3 + 0] = (ushort)mesh.Faces[i].Indices[0]; geometryData.Indices[i * 3 + 1] = (ushort)mesh.Faces[i].Indices[1]; geometryData.Indices[i * 3 + 2] = (ushort)mesh.Faces[i].Indices[2]; } return(geometryData); }
public SmokeData(int _index, string _name, type _type, bool _deletable, GeometryData _geometryData, PhysicalData _physicalData, SmokeType _smokeType, Color _color) : base(_index, _name, _type, _deletable) { geometryData = _geometryData; physicalData = _physicalData; smokeType = _smokeType; color = _color; }
/// <summary> /// Create a <see cref="HybridSystem"/> that helps process, manipulate, and draw <see cref="GeometryData"/>. /// By default, this system will handle any entity that includes the following components: <see cref="CPosition"/>, <see cref="CDimension"/>, <see cref="CTransform"/>, <see cref="CColor"/>, /// and a custom <see cref="IComponent"/> that acts as a tag specifically for this system. /// </summary> /// <param name="scene">The scene this system will exist in.</param> /// <param name="geometry">The shape data that this system will focus on and draw.</param> /// <param name="shapeTag">The type of the custom <see cref="IComponent"/> that acts as a tag specifically for this system.</param> /// <param name="tasks">The total amount of tasks to divide the update cycle into. Assigning more than one task allows entities to be updated asynchronously.</param> public SimpleShapeSystem(Scene scene, GeometryData geometry, Type shapeTag, uint tasks) : base(scene, tasks) { Require(typeof(CPosition), typeof(CDimension), typeof(CTransform), typeof(CColor), shapeTag); this.geometry = geometry; vertexBuffer = new VertexTransformColor[scene.EntityCapacity]; }
private void addUpdateArray(int index) { GeometryData geometryData = windObjectsData[index].geometryData; Vector3 position = geometryData.position; Vector3[,,] objectArray = windArrayData[index]; switch (geometryData.geometryType) { case GeometryData.GeometryType.CUBE: { CubeGeometryData cubeGeometryData = (CubeGeometryData)geometryData; int sizeX = (int)(cubeGeometryData.size.x / 0.1f); int sizeY = (int)(cubeGeometryData.size.y / 0.1f); int sizeZ = (int)(cubeGeometryData.size.z / 0.1f); int beginX = (int)((position.x + 2f) / 0.1f) - sizeX / 2; int beginY = (int)((position.y + 2f) / 0.1f) - sizeY / 2; int beginZ = (int)((position.z + 2f) / 0.1f) - sizeZ / 2; for (int i = 0; i < sizeX; i++) { for (int j = 0; j < sizeZ; j++) { for (int k = 0; k < sizeY; k++) { windArray[i + beginX, j + beginY, k + beginZ] = objectArray[i, j, k]; } } } break; } } }
} //ncrunch: no coverage public void LoadValidData() { var d = new GeometryData { Format = VertexFormat.Position3DColor, Indices = new short[6] }; LoadData(new MemoryStream(BinaryDataExtensions.ToByteArrayWithTypeInformation(d))); }
private void InitializeGeometry() { GeoData = new GeometryData { Width = (int)ActualWidth - 17, Height = (int)ActualHeight - 63 }; }
private GeometryData CreateTilemapData() { var tilesX = GetData <int>("tilesX"); var tilesY = GetData <int>("tilesY"); var tileElementSize = GetData <int>("tileElementSize"); var diffuseTexture = _drawableElement.Material.DiffuseTexture; var tilesetElementsX = diffuseTexture.Width / tileElementSize; var geometryData = new GeometryData { Vertices = new VertexPositionNormalTexture[tilesX * tilesY * 4], Indices = new ushort[tilesX * tilesY * 6] }; var tiles = GetData <string>("map") .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries) .Select(int.Parse).ToArray(); var texturePartSize = diffuseTexture.GetTexcoordsFromPixelCoords(tileElementSize, tileElementSize); var vertexBaseIndex = 0; var indexBaseIndex = 0; for (var i = 0; i < Math.Min(tiles.Length, tilesX * tilesY); i++) { var element = tiles[i]; if (element == 0) { continue; } var tilesetX = (element - 1) % tilesetElementsX; var tilesetY = (element - 1) / tilesetElementsX; var mapX = i % tilesX; var mapY = i / tilesX; var position = new Vector3(mapX, 0.0f, mapY); var texcoords = diffuseTexture.GetTexcoordsFromPixelCoords(tilesetX * tileElementSize, tilesetY * tileElementSize); var normal = Vector3.UnitY; geometryData.Vertices[vertexBaseIndex + 0] = new VertexPositionNormalTexture(position + new Vector3(0, 0, -1), normal, texcoords + new Vector2(0, texturePartSize.Y)); geometryData.Vertices[vertexBaseIndex + 1] = new VertexPositionNormalTexture(position + new Vector3(0, 0, 0), normal, texcoords + new Vector2(0, 0)); geometryData.Vertices[vertexBaseIndex + 2] = new VertexPositionNormalTexture(position + new Vector3(1, 0, -1), normal, texcoords + new Vector2(texturePartSize.X, texturePartSize.Y)); geometryData.Vertices[vertexBaseIndex + 3] = new VertexPositionNormalTexture(position + new Vector3(1, 0, 0), normal, texcoords + new Vector2(texturePartSize.X, 0)); geometryData.Indices[indexBaseIndex + 0] = (ushort)vertexBaseIndex; geometryData.Indices[indexBaseIndex + 1] = (ushort)(vertexBaseIndex + 2); geometryData.Indices[indexBaseIndex + 2] = (ushort)(vertexBaseIndex + 1); geometryData.Indices[indexBaseIndex + 3] = (ushort)(vertexBaseIndex + 1); geometryData.Indices[indexBaseIndex + 4] = (ushort)(vertexBaseIndex + 2); geometryData.Indices[indexBaseIndex + 5] = (ushort)(vertexBaseIndex + 3); vertexBaseIndex += 4; indexBaseIndex += 6; } return(geometryData); }
public InfoTaskViewModel(ITaskService taskService) { _taskService = taskService; _geometryData = App.GetRequiredService <GeometryData>(); TodoTasks = new ObservableCollection <TodoTask>(); ToDoTask = new TodoTask { CanBeFinished = true }; }
/// <summary> /// Create a <see cref="HybridSystem"/> that helps process, manipulate, and draw <see cref="GeometryData"/>. /// By default, this system will handle any entity that includes the following components: <see cref="CPosition"/>, <see cref="CDimension"/>, <see cref="CTransform"/>, <see cref="CColor"/>, /// and a custom <see cref="IComponent"/> that acts as a tag specifically for this system. /// </summary> /// <param name="factory">The scene this system will exist in.</param> /// <param name="geometry">The shape data that this system will focus on and draw.</param> /// <param name="renderOptions">The render options that should be used to draw the geometry.</param> /// <param name="shapeTag">The type of a custom <see cref="IComponent"/> that acts as a tag specifically for this system.</param> public SimpleShapeSystem(MorroFactory factory, GeometryData geometry, RenderOptions renderOptions, Type shapeTag) : base(factory) { Require(typeof(CPosition), typeof(CDimension), typeof(CTransform), typeof(CColor), shapeTag); this.geometry = geometry; this.renderOptions = renderOptions; transformData = new VertexTransform[factory.EntityCapacity]; colorData = new VertexColor[factory.EntityCapacity]; }
public async Task SaveAsync(string path, GeometryData data) { using (var fileContent = new StreamWriter(path)) { await fileContent.WriteLineAsync("# Generated by XenkoTerrain " + DateTime.Now.ToLongDateString()); await fileContent.WriteLineAsync("# Vertices: " + data.Vertices.Length); await fileContent.WriteLineAsync("# Size: " + data.Size); await fileContent.WriteLineAsync("usemtl Terrain"); for (var row = 0; row < data.TessellationY - 1; row++) { for (var col = 0; col < data.TessellationX - 1; col++) { var topLeft = col + row * (int)data.TessellationX; var topRight = topLeft + 1; var bottomLeft = topLeft + (int)data.TessellationX; var bottomRight = bottomLeft + 1; var topLeftVertex = data.Vertices[topLeft]; var topRightVertex = data.Vertices[topRight]; var bottomLeftVertex = data.Vertices[bottomLeft]; var botomRightVertex = data.Vertices[bottomRight]; await fileContent.WriteLineAsync(topRightVertex.Position.PrintObj(ObjLineType.Position)); await fileContent.WriteLineAsync(topLeftVertex.Position.PrintObj(ObjLineType.Position)); await fileContent.WriteLineAsync(bottomLeftVertex.Position.PrintObj(ObjLineType.Position)); await fileContent.WriteLineAsync(botomRightVertex.Position.PrintObj(ObjLineType.Position)); await fileContent.WriteLineAsync(topRightVertex.Normal.PrintObj(ObjLineType.Normal)); await fileContent.WriteLineAsync(topLeftVertex.Normal.PrintObj(ObjLineType.Normal)); await fileContent.WriteLineAsync(bottomLeftVertex.Normal.PrintObj(ObjLineType.Normal)); await fileContent.WriteLineAsync(botomRightVertex.Normal.PrintObj(ObjLineType.Normal)); await fileContent.WriteLineAsync((data.Size *topRightVertex.TextureCoordinate).PrintObj(ObjLineType.TextureCoordinate)); await fileContent.WriteLineAsync((data.Size *topLeftVertex.TextureCoordinate).PrintObj(ObjLineType.TextureCoordinate)); await fileContent.WriteLineAsync((data.Size *bottomLeftVertex.TextureCoordinate).PrintObj(ObjLineType.TextureCoordinate)); await fileContent.WriteLineAsync((data.Size *botomRightVertex.TextureCoordinate).PrintObj(ObjLineType.TextureCoordinate)); await fileContent.WriteLineAsync($"f -4/-4/-4 -3/-3/-3 -2/-2/-2 -1/-1/-1 "); } } } }
private void CreateSphere(GeometryData geometry, Material material, Vector3 position, Vector3 scale) { var mesh = new GeometryMesh(geometry, material, Matrix.Identity); var model = new GeometryModel(); model.Add(mesh); (var sphereGeometry, var sphereTransform, var sphereBounds) = this.Geometry.Create(model); sphereTransform.MoveTo(position); sphereTransform.SetScale(scale); }
private static void AddFace(BlockClass[][][] blocks, GeometryData geo, byte dir, Vector3Int center) { for (var i = 0; i < 4; i++) { var blk = center + BlockProperties.FacePts[BlockProperties.BlockFaces[dir, i]]; geo.Vertices.Add(blk + blocks[blk.x + 1][blk.y + 1][blk.z + 1].Data.ControlPoint); geo.Normals.Add(BlockProperties.DirectionVector[dir]); } var v1 = geo.Vertices[geo.Vertices.Count - 1] - geo.Vertices[geo.Vertices.Count - 2]; var v2 = geo.Vertices[geo.Vertices.Count - 3] - geo.Vertices[geo.Vertices.Count - 2]; var N = Vector3.Cross(v1, v2).normalized; if (N.y > .3) { dir = (byte)BlockClass.Direction.Up; //Up } var sc = geo.Vertices.Count - 4; // squareCount << 2;//Multiply by 4 if ((geo.Vertices[geo.Vertices.Count - 3] - geo.Vertices[geo.Vertices.Count - 1]).sqrMagnitude < (geo.Vertices[geo.Vertices.Count - 4] - geo.Vertices[geo.Vertices.Count - 2]).sqrMagnitude) { geo.Triangles.Add(sc); geo.Triangles.Add(sc + 1); geo.Triangles.Add(sc + 3); geo.Triangles.Add(sc + 1); geo.Triangles.Add(sc + 2); geo.Triangles.Add(sc + 3); } else { geo.Triangles.Add(sc); geo.Triangles.Add(sc + 1); geo.Triangles.Add(sc + 2); geo.Triangles.Add(sc); geo.Triangles.Add(sc + 2); geo.Triangles.Add(sc + 3); } var v = blocks[center.x + 1][center.y + 1][center.z + 1].GetTex(); var uv = new Vector2(v[dir].x / 16f, (15 - v[dir].y) / 16f); geo.UV.Add(uv); geo.UV.Add(new Vector2(uv.x + BlockProperties.TUnit, uv.y)); geo.UV.Add(new Vector2(uv.x + BlockProperties.TUnit, uv.y + BlockProperties.TUnit)); geo.UV.Add(new Vector2(uv.x, uv.y + BlockProperties.TUnit)); //squareCount++; }
public async Task SaveAsync(GeometryData data) { var saveDialog = new SaveFileDialog() { Title = "Save Terrain to File", Filter = "OBJ Files|*.obj" }; if (saveDialog.ShowDialog() == DialogResult.OK && !string.IsNullOrEmpty(saveDialog.FileName)) { await new GeometryExporerObj().SaveAsync(saveDialog.FileName, data); } }
public virtual void Update(BaseObject newObject) { Description = newObject.Description; Height = newObject.Height; Id = newObject.Id; Left = newObject.Left; Name = newObject.Name; ParentId = newObject.ParentId; Path = newObject.Path; Top = newObject.Top; Type = newObject.Type; TypeId = newObject.TypeId; Width = newObject.Width; }
//param constructor for when declared in main public RMI(IList <SeisData> src, GeometryData geoSrc) { fileNames = new List <string>(); ampData = new List <RMIAmpData>(); pickData = new List <RMIPickData>(); fileDescription = new RMIFileDescription(src); geoData = new RMIGeoData(geoSrc); foreach (var file in src) { ampData.Add(new RMIAmpData(file)); pickData.Add(new RMIPickData(file)); } }
internal static SchemaShape2D CreateShapeSchema(GeometryData shapeData, CPosition position, CDimension dimension, CTransform transform) { Matrix vertexTransform = CreateVertexTransform(); Vector2[] vertices = CreateVertices(); LineSegment[] lineSegments = CreateLineSegments(); return(new SchemaShape2D(vertices, lineSegments)); Matrix CreateVertexTransform() { return (Matrix.CreateScale(dimension.Width * transform.Scale.X, dimension.Height * transform.Scale.Y, 1 * transform.Scale.Z) * Matrix.CreateTranslation(-new Vector3(transform.RotationOffset.X, transform.RotationOffset.Y, 0)) * Matrix.CreateRotationZ(transform.Rotation) * Matrix.CreateTranslation(position.X + transform.Translation.X + transform.RotationOffset.X, position.Y + transform.Translation.Y + transform.RotationOffset.Y, transform.Translation.Z) * Matrix.Identity); } Vector2[] CreateVertices() { Vector2[] result = new Vector2[shapeData.TotalVertices]; for (int i = 0; i < shapeData.TotalVertices; i++) { result[i] = Vector2.Transform(new Vector2(shapeData.Vertices[i].X, shapeData.Vertices[i].Y), vertexTransform); } return(result); } LineSegment[] CreateLineSegments() { int totalVertices = shapeData.TotalVertices; LineSegment[] result = new LineSegment[totalVertices]; result[0] = new LineSegment(vertices[totalVertices - 1].X, vertices[totalVertices - 1].Y, vertices[0].X, vertices[0].Y); for (int i = 1; i < totalVertices; i++) { result[i] = new LineSegment(vertices[i - 1].X, vertices[i - 1].Y, vertices[i].X, vertices[i].Y); } return(result); } }
public void OnOpening() { _scene = new Scene(Game, new WindowsSceneEffect(Game.Content)) { EnableShadows = false, LightDirection = new Vector3(0, -1, 0) }; _camera = _scene.CreateCamera(); _camera.Position = new Vector3(0.0f, 12.0f, 13.0f); _camera.RotateX(-MathHelper.PiOver4); var billboardSceneNode = _scene.CreateSceneNode(); billboardSceneNode.IsBillboard = true; billboardSceneNode.Mesh = new Mesh(Game.GraphicsDevice, Primitives.GenerateQuadForYBillboard()); billboardSceneNode.Material = new Material(Game.Content.Load<Texture2D>(ResourceNames.Textures.tileset1)) { CastShadow = false, UseTransparency = true }; billboardSceneNode.Position = new Vector3(-5, 0, -5); billboardSceneNode.Scale = new Vector3(2, 4, 1); for (var x = 0; x < 5; x++) { for(var z = 0; z < 5; z++) { if (x == 0 && z == 0) continue; var cloned = _scene.CloneNode(billboardSceneNode); cloned.Position = new Vector3(x*2-5, 0, z * 2-5); } } var quads = new GeometryData[32*32]; //2,1 var tsize = 1.0f / 16.0f; for(var x = 0; x < 32; x++) { for(var z = 0; z < 32; z++) { quads[z*32+x] = Primitives.GenerateQuadXZ(new Vector3(-16.0f + x, 0.0f, -16.0f + z), texCoordStart: new Vector2(tsize * 2.0f, tsize), texCoordScale: new Vector2(tsize, tsize)); } } var sceneNode = _scene.CreateSceneNode(); sceneNode.Mesh = new Mesh(Game.GraphicsDevice, Primitives.Merge(quads)); sceneNode.Material = new Material(Game.Content.Load<Texture2D>(ResourceNames.Textures.tileset1)); }
public Path2D() { // can i get rid of draw call list and use object data instead? this.geometry = GeometryData.Create(); this.drawCallList = new StructList <SVGXDrawCall>(4); this.transforms = new StructList <Matrix4x4>(4); this.objectDataList = new StructList <ObjectData>(4); this.fillStyles = null; this.strokeStyles = null; this.currentMatrix = Matrix4x4.identity; this.currentFillStyle = SVGXFillStyle.Default; this.currentStrokeStyle = SVGXStrokeStyle.Default; this.currentFixedRenderState = new FixedRenderState(BlendState.Default, DepthState.Default); transforms.Add(currentMatrix); }
public void Preload() { var data = FileLoader.GetFiles(new[] { PrimitivesFilePath, NaturesFilePath, TypesFilePath, PokedexesFilePath }); _primitiveModels = DataModel <PrimitiveModel[]> .FromByteArray(data[0].Data); foreach (var primitiveModel in _primitiveModels) { var geometryData = new GeometryData { Vertices = primitiveModel.Vertices.Select(v => new VertexPositionNormalTexture { Position = v.Position.GetVector3(), TextureCoordinate = v.TexCoord.GetVector2(), Normal = v.Normal.GetVector3() }).ToArray(), Indices = primitiveModel.Indices.Select(i => (ushort)i).ToArray() }; Mesh mesh = null; GameContext.EnsureExecutedInMainThread(() => mesh = new Mesh(GraphicsDevice, geometryData)); _meshPrimitivesByName.Add(primitiveModel.Id, mesh); } _natureModels = DataModel <NatureModel[]> .FromByteArray(data[1].Data); _typeModels = DataModel <TypeModel[]> .FromByteArray(data[2].Data); _pokedexModels = DataModel <PokedexModel[]> .FromByteArray(data[3].Data); var movesFilePaths = FileLoader.GetFilesOfFolder(MoveFilesPath); _moveModels = movesFilePaths.Select(d => DataModel <MoveModel> .FromByteArray(d.Data)).ToArray(); var itemsFiles = FileLoader.GetFilesOfFolder(ItemFilesPath); _itemModels = itemsFiles.Select(d => DataModel <ItemModel> .FromByteArray(d.Data)).ToArray(); var abilityFiles = FileLoader.GetFilesOfFolder(AbilityFilesPath); _abilityModels = abilityFiles.Select(d => DataModel <AbilityModel> .FromByteArray(d.Data)).ToArray(); }
//this parameterized constructor takes all data from geoData and transfers it between the two or vice versa public RMIGeoData(GeometryData src) { shotElevation = src.shotElevation; shotPosition = src.shotPosition; IList <float> temp = new List <float>(); for (int i = 0; i < src.numChansGeo; i++) { temp.Add((float)src.GeophoneDatas[i].Elevation); } geoElevation = temp; numChannelsGeoData = src.numChansGeo; geoSpacing = src.geophoneSpacing; geoOffset = src.geophoneOffset; geoDistance = src.dtVal; }
// Status and states public ChunkObject() { _solidGeometry = new GeometryData(); _liquidGeometry = new GeometryData(); Blocks = new BlockClass[BlockProperties.ChunkSizeP2][][]; for (var x = 0; x < BlockProperties.ChunkSize + 2; x++) { Blocks[x] = new BlockClass[BlockProperties.ChunkSizeP2][]; for (var y = 0; y < BlockProperties.ChunkSizeP2; y++) { Blocks[x][y] = new BlockClass[BlockProperties.ChunkSizeP2]; } } }
private float[] getColorOfIndex(GeometryData paramGeometryData, int[] paramArrayOfInt, long paramLong) { foreach (ElementMaterialGeomData elementMaterialGeomData in paramGeometryData.Materials) { if (elementMaterialGeomData.MaterialVBOffset < paramArrayOfInt.Length && elementMaterialGeomData.MaterialVBOffset >= 0L) { long l1 = paramArrayOfInt[(int)elementMaterialGeomData.MaterialVBOffset]; long l2 = l1 + elementMaterialGeomData.MaterialIndexCount; if (l1 <= paramLong && l2 > paramLong) { return(getColorsFloat(elementMaterialGeomData)); } } } return((paramGeometryData.Materials.length == 0) ? new float[] { 0.1F, 0.1F, 0.1F, 0.0F } : getColorsFloat(paramGeometryData.Materials[0])); }
private static ModelMesh LoadPMesh(GameMode gameMode, string filePath) { using (var fileStream = new FileStream(filePath, FileMode.Open)) { using (var binaryReader = new BinaryReader(fileStream)) { var vertexCount = binaryReader.ReadInt32(); var indicesCount = binaryReader.ReadInt32(); var textureName = binaryReader.ReadString(); var textureFilePath = Path.Combine(Path.GetDirectoryName(filePath) ?? "", Path.GetFileName(textureName) ?? ""); Texture2D texture = null; if (File.Exists(textureFilePath)) { texture = gameMode.GetTextureFromRawFolder(textureFilePath); } var geometryData = new GeometryData { Vertices = new VertexPositionNormalTexture[vertexCount], Indices = new ushort[indicesCount] }; for (var i = 0; i < vertexCount; i++) { var position = new Vector3(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle()); var normal = new Vector3(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle()); var uv = new Vector2(binaryReader.ReadSingle(), binaryReader.ReadSingle()); geometryData.Vertices[i] = new VertexPositionNormalTexture(position, normal, uv); } for (var i = 0; i < indicesCount; i++) { geometryData.Indices[i] = (ushort)binaryReader.ReadInt32(); } return(new ModelMesh { Mesh = new Mesh(gameMode.GraphicsDevice, geometryData, PrimitiveType.TriangleList, false), Material = new Material { DiffuseTexture = texture } }); } } }
//return the shader to use: public IShader BeginGeometry(DrawState state, GeometryData geometry) { //query the draw flag, switch (state.DrawFlags.GetFlag<TutorialRenderMode>()) { case TutorialRenderMode.DrawShadow: { //return the shader that draws the shadow var shader = state.GetShader<Shader.ShadowShader>(); shader.TextureMap = geometry.MaterialData.Texture; return shader; } //return the shader that outpus depth case TutorialRenderMode.DepthOutput: return state.GetShader<Xen.Ex.Shaders.NonLinearDepthOut>(); default: //no flag is set, or it is in it's default state return null; //do not change the shader } }
//return the shader to use: public IShader BeginGeometry(DrawState state, GeometryData geometry) { //query the draw flag, switch (state.DrawFlags.GetFlag<RenderMode>()) { case RenderMode.DrawShadow: { //return the shader shader Shaders.ShadowShader shader = state.GetShader<Shaders.ShadowShader>(); shader.TextureMap = geometry.MaterialData.Texture; return shader; } case RenderMode.DepthOutput: return state.GetShader<Xen.Ex.Shaders.NonLinearDepthOut>(); default: return null; //no change } }
private static GeometryData GenerateGeometryDataFromAssimpMesh(Assimp.Mesh mesh) { var geometryData = new GeometryData { Vertices = new VertexPositionNormalTexture[mesh.VertexCount], Indices = new ushort[mesh.FaceCount * 3] }; geometryData.Vertices = new VertexPositionNormalTexture[mesh.VertexCount]; for (var i = 0; i < mesh.VertexCount; i++) { var vertex = mesh.Vertices[i]; geometryData.Vertices[i].Position = new Vector3(vertex.X, vertex.Y, vertex.Z); var normal = mesh.Normals[i]; geometryData.Vertices[i].Normal = new Vector3(normal.X, normal.Y, normal.Z); var texcoord = mesh.TextureCoordinateChannels[0][i]; geometryData.Vertices[i].TextureCoordinate = new Vector2(texcoord.X, texcoord.Y); } for (var i = 0; i < mesh.FaceCount; i++) { geometryData.Indices[i * 3 + 0] = (ushort)mesh.Faces[i].Indices[0]; geometryData.Indices[i * 3 + 1] = (ushort)mesh.Faces[i].Indices[1]; geometryData.Indices[i * 3 + 2] = (ushort)mesh.Faces[i].Indices[2]; } return geometryData; }