Represnets mesh instance
Example #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="material"></param>
        /// <param name="flags"></param>
        /// <returns></returns>
        SurfaceFlags ApplyFlags(MeshInstance instance, SurfaceFlags flags)
        {
            if (instance.IsSkinned)
            {
                flags |= SurfaceFlags.SKINNED;
            }
            else
            {
                flags |= SurfaceFlags.RIGID;
            }

            return(flags);
        }
Example #2
0
        /// <summary>
        /// We assume that scene represents level.
        /// </summary>
        /// <param name="scene"></param>
        void ReadMapFromScene( ContentManager content, Scene scene, bool createRendMeshes )
        {
            //	create entity list :
            instances	=	new List<MeshInstance>();

            //	compute absolute transforms :
            var transforms	= new Matrix[ scene.Nodes.Count ];
            scene.ComputeAbsoluteTransforms( transforms );

            //	iterate through the scene's nodes :
            for ( int i=0; i<scene.Nodes.Count; i++) {

                var node	=	scene.Nodes[ i ];
                var world	=	transforms[ i ];
                var name	=	node.Name;
                var mesh	=	node.MeshIndex < 0 ? null : scene.Meshes[ node.MeshIndex ];

                if (name.StartsWith("startPoint")) {
                    Spawn("startPoint", 0, world.TranslationVector, 10 );
                    continue;
                }

                if (name.StartsWith("camera")) {
                    Spawn("camera", 0, world );
                }

                if (mesh!=null) {
                    AddStaticCollisionMesh( mesh, world );

                    if (createRendMeshes) {
                        var mi		= new MeshInstance( content.Game.RenderSystem, scene, mesh );
                        mi.World	= world;

                        instances.Add( mi );
                    }
                }
            }

            Random	r = new Random();

            for (int i=0; i<100; i++) {
                Spawn("box", 0, Vector3.Up * 400 + r.GaussRadialDistribution(20,2), 0 );
            }// */

            ///Spawn("mist", 0, Vector3.Up * 5, 0);
        }
Example #3
0
        void Reload( RenderSystem rs, ContentManager content )
        {
            if (meshInstance!=null) {
                if (!rs.RenderWorld.Instances.Remove( meshInstance )) {
                    Log.Warning("Failed to remove {0}|{1}", scenePath, nodeName );
                }
            }

            var scene = content.Load<Scene>( scenePath, (Scene)null );

            if (scene==null) {
                return;
            }

            var node  = scene.Nodes.FirstOrDefault( n => n.Name == nodeName );

            if (node==null) {
                Log.Warning("Scene '{0}' does not contain node '{1}'", scenePath, nodeName );
                return;
            }

            if (node.MeshIndex<0) {
                Log.Warning("Node '{0}|{1}' does not contain mesh", scenePath, nodeName );
                return;
            }

            var mesh		=	scene.Meshes[node.MeshIndex];

            meshInstance		= new MeshInstance( rs, scene, mesh );

            rs.RenderWorld.Instances.Add( meshInstance );
        }
Example #4
0
		/// <summary>
		/// 
		/// </summary>
		/// <param name="material"></param>
		/// <param name="flags"></param>
		/// <returns></returns>
		SurfaceFlags ApplyFlags ( MaterialInstance material, MeshInstance instance, SurfaceFlags flags )
		{
			//if (material!=null) {
			//	switch ( material.Options ) {
			//		case MaterialOptions.SingleLayer : flags |= SurfaceFlags.LAYER0; break;	
			//		case MaterialOptions.DoubleLayer : flags |= SurfaceFlags.LAYER0|SurfaceFlags.LAYER1; break;
			//		case MaterialOptions.TripleLayer : flags |= SurfaceFlags.LAYER0|SurfaceFlags.LAYER1|SurfaceFlags.LAYER2; break;
			//		case MaterialOptions.QuadLayer	 : flags |= SurfaceFlags.LAYER0|SurfaceFlags.LAYER1|SurfaceFlags.LAYER2|SurfaceFlags.LAYER3; break;

			//		case MaterialOptions.Terrain : flags |= SurfaceFlags.TERRAIN; break;

			//		case MaterialOptions.TriplanarWorldSingle : flags |= SurfaceFlags.TRIPLANAR_SINGLE; break;
			//		case MaterialOptions.TriplanarWorldDouble : flags |= SurfaceFlags.TRIPLANAR_DOUBLE; break;
			//		case MaterialOptions.TriplanarWorldTriple : flags |= SurfaceFlags.TRIPLANAR_TRIPLE; break;
			//	}
			//}

			if (instance.IsSkinned) {
				flags |= SurfaceFlags.SKINNED;
			} else {
				flags |= SurfaceFlags.RIGID;
			}

			return flags;
		}
		void LoadContent ()
		{
			masterView.Instances.Clear();

			//-------------------------------------

			masterView.ParticleSystem.Images	=	Game.Content.Load<TextureAtlas>(@"sprites\particles|srgb");

			//-------------------------------------

			scene		=	Game.Content.Load<Scene>( @"scenes\testScene" );

			var transforms = new Matrix[ scene.Nodes.Count ];
			scene.ComputeAbsoluteTransforms( transforms );

			var defMtrl		=	Game.RenderSystem.DefaultMaterial;
			var materials	=	scene.Materials.Select( m => Game.Content.Load<MaterialInstance>( m.Name, defMtrl ) ).ToArray();
			
			for ( int i=0; i<scene.Nodes.Count; i++ ) {
			
				var meshIndex  = scene.Nodes[i].MeshIndex;
			
				if (meshIndex<0) {
					continue;
				}
				
				var inst   = new MeshInstance( Game.RenderSystem, scene, scene.Meshes[meshIndex], materials );
				inst.World = transforms[ i ];
			
				masterView.Instances.Add( inst );
			}


			//-------------------------------------

			animScene =	Game.Content.Load<Scene>(@"scenes\testAnim");
			animInstances.Clear();

			transforms = new Matrix[ animScene.Nodes.Count ];
			animScene.ComputeAbsoluteTransforms( transforms );

			materials	=	animScene.Materials.Select( m => Game.Content.Load<MaterialInstance>( m.Name, defMtrl ) ).ToArray();
			
			for ( int i=0; i<animScene.Nodes.Count; i++ ) {
			
				var meshIndex  = animScene.Nodes[i].MeshIndex;
			
				if (meshIndex<0) {
					continue;
				}
				
				var inst   = new MeshInstance( Game.RenderSystem, animScene, animScene.Meshes[meshIndex], materials );
				inst.World = transforms[ i ];

				animInstances.Add( new Tuple<MeshInstance,int>( inst, i ) );
			
				masterView.Instances.Add( inst );
			}

			//-------------------------------------

			skinScene =	Game.Content.Load<Scene>(@"scenes\testSkin");
			skinInstances.Clear();

			transforms = new Matrix[ skinScene.Nodes.Count ];
			skinScene.ComputeAbsoluteTransforms( transforms );

			materials	=	skinScene.Materials.Select( m => Game.Content.Load<MaterialInstance>( m.Name, defMtrl ) ).ToArray();
			
			for ( int i=0; i<skinScene.Nodes.Count; i++ ) {
			
				var meshIndex  = skinScene.Nodes[i].MeshIndex;
			
				if (meshIndex<0) {
					continue;
				}

				for (int j = 0; j<8; j++) {
				
					var inst   = new MeshInstance( Game.RenderSystem, skinScene, skinScene.Meshes[meshIndex], materials );
					inst.World = transforms[ i ] * Matrix.Translation(0,3,10) * Matrix.RotationY(MathUtil.Pi*2/8.0f * j);
				
					skinInstances.Add( new Tuple<MeshInstance,int>( inst, i ) );

					if (inst.IsSkinned) {
						var bones = new Matrix[skinScene.Nodes.Count];
						skinScene.GetAnimSnapshot( 8, bones );
						skinScene.ComputeBoneTransforms( bones, inst.BoneTransforms );
					}

					masterView.Instances.Add( inst );
				}
			}

			//-------------------------------------

			masterView.HdrSettings.BloomAmount	=	0.05f;
			masterView.HdrSettings.DirtAmount	=	0.95f;
			masterView.HdrSettings.DirtMask1	=	Game.Content.Load<DiscTexture>("bloomMask|srgb");
			masterView.HdrSettings.DirtMask2	=	null;//GameEngine.Content.Load<DiscTexture>("bloomMask2");
		}