public CopyAbsoluteBoneTransformsTo ( Matrix destinationBoneTransforms ) : void | ||
destinationBoneTransforms | Matrix | The array receiving the transformed bones. |
return | void |
public void DrawBall(float aspectRatio, Vector3 cameraPosition, Model ball, float xrotation,float yrotation) { // assign random number to roid1modelPosition.x or y // Copy any parent transforms. Matrix[] transforms = new Matrix[ball.Bones.Count]; ball.CopyAbsoluteBoneTransformsTo(transforms); // Draw the model. A model can have multiple meshes, so loop. foreach (ModelMesh mesh in ball.Meshes) { // This is where the mesh orientation is set, as well as our camera and projection. foreach (BasicEffect effect in mesh.Effects) { effect.EnableDefaultLighting(); effect.World = transforms[mesh.ParentBone.Index] //* Matrix.CreateRotationZ(Roid1modelRotation) * Matrix.CreateRotationX(xrotation) * Matrix.CreateRotationY(yrotation) * Matrix.CreateTranslation(new Vector3(3750, -2750, 0)); effect.View = Matrix.CreateLookAt(cameraPosition, Vector3.Zero, Vector3.Up); effect.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 10000.0f); } // Draw the mesh, using the effects set above. mesh.Draw(); } }
public void Draw(float aspectRatio, Vector3 cameraPosition,Model mesh) { transforms = new Matrix[mesh.Bones.Count]; mesh.CopyAbsoluteBoneTransformsTo(transforms); foreach (var singleMesh in mesh.Meshes) { // This is where the mesh orientation is set, as well as our camera and projection. foreach (BasicEffect effect in singleMesh.Effects) { effect.EnableDefaultLighting(); effect.World = transforms[singleMesh.ParentBone.Index] * Matrix.CreateRotationY(ObjectArrangement.Rotation.Y) * Matrix.CreateTranslation(ObjectArrangement.Position) * Matrix.CreateScale(ObjectArrangement.Scale); effect.View = Matrix.CreateLookAt(cameraPosition, Vector3.Zero, Vector3.Up); effect.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 10000.0f); } singleMesh.Draw(); } }
public override void LoadContent(ContentManager Content) { Board.setModel(Content.Load<Model>("Models\\board")); Piece.setModel(Content.Load<Model>("Models\\piece")); selector = Content.Load<Model>("Models\\selector"); selectorTrans = new Matrix[selector.Bones.Count]; selector.CopyAbsoluteBoneTransformsTo(selectorTrans); ((BasicEffect)selector.Meshes[0].Effects[0]).Alpha = 0.6f; ((BasicEffect)selector.Meshes[0].Effects[0]).DiffuseColor = Vector3.UnitX; Player.LoadContent(Content); background = Content.Load<Texture2D>("Images\\background"); Viewport v = Program.game.GraphicsDevice.Viewport; destRect = new Rectangle(0, 0, v.Width, v.Height); int x, y, w, h; if (background.Width / background.Height > destRect.Width / destRect.Height) { h = background.Height; w = background.Height * destRect.Width / destRect.Height; y = 0; x = (background.Width - w) / 2; } else { h = background.Width * destRect.Height / destRect.Width; w = background.Width; y = (background.Height - h) / 2; x = 0; } srcRect = new Rectangle(x, y, w, h); }
public BillboardsSystem(ContentManager content, BillboardMode mode, Model model, Matrix[] instancedModelBones, Matrix[] instanceTransforms, Vector3 position, Vector3 rotation, Vector3 scale, Vector3 LightDirection, Vector3 LightColor, Vector3 AmbientLight, GraphicsDevice graphicsDevice) { this.model = model; modelTransforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(modelTransforms); buildBoundingSphere(); this.position = position; this.rotation = rotation; this.scale = scale; this.graphicsDevice = graphicsDevice; this.instancedModelBones = instancedModelBones; this.instanceTransforms = instanceTransforms; // this.LightDirection = LightDirection; // this.LightColor = LightColor; // this.AmbientColor = AmbientLight; this.mode = mode; effect = content.Load<Effect>("Effects//AlphaBlending"); _effect = content.Load<Effect>("shaders//LPPMainEffect"); //SetModelEffect(effect, false); }
public ShipFbx(String modelName) { model = BeatShift.contentManager.Load<Model>("Models/Ships/" + modelName); SkinningData skd = GetSkinningDataFromTag(); if (isAnimated) { clipPlayer = new ClipPlayer(skd, 24); } else { bones = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(bones); } #if !DEBUG Utils.fixNullLightDirections(model); #endif GC.Collect(); //Override the default texture //Texture2D grayTexture; //grayTexture = content.Load<Texture2D>("tex5"); //shipRenderer.Texture = grayTexture; //shipRenderer.TextureEnabled = true; }
/// <summary> /// This is called when the game should draw itself. /// </summary> /// <param name="gameTime">Provides a snapshot of timing values.</param> protected override void Draw(MXF.GameTime gameTime) { ICameraManagerService cameraManagerService = (ICameraManagerService)this.Services.GetService(typeof(ICameraManagerService)); graphics.GraphicsDevice.Clear(MXF.Color.CornflowerBlue); // Copy any parent transforms. MXF.Matrix[] transforms = new MXF.Matrix[castle.Bones.Count]; castle.CopyAbsoluteBoneTransformsTo(transforms); //// Draw the model. A model can have multiple meshes, so loop. foreach (XFG.ModelMesh mesh in castle.Meshes) { // This is where the mesh orientation is set, as well as our camera and projection. foreach (XFG.BasicEffect effect in mesh.Effects) { effect.World = MXF.Matrix.CreateRotationY(this.modelRotation) * MXF.Matrix.CreateTranslation(this.modelPosition); effect.View = cameraManagerService.Camera.View; effect.Projection = cameraManagerService.Camera.Projection; effect.EnableDefaultLighting(); } // Draw the mesh, using the effects set above. mesh.Draw(); } base.Draw(gameTime); }
public MovableModel(Model model, Matrix4 transform) : base(transform) { m_model = model; m_transforms = new Matrix[m_model.Bones.Count]; m_model.CopyAbsoluteBoneTransformsTo (m_transforms); }
public void drawMesh(Model myModel, Vector3 modelPosition, float modelRotation, Camera camera) { float aspectRatio = (float)Tools.Quick.graphics.GraphicsDevice.Viewport.Width / (float)Tools.Quick.graphics.GraphicsDevice.Viewport.Height; // Copy any parent transforms. Matrix[] transforms = new Matrix[myModel.Bones.Count]; myModel.CopyAbsoluteBoneTransformsTo(transforms); Tools.Quick.device.RasterizerState = RasterizerState.CullNone; // vertex order doesn't matter Tools.Quick.device.BlendState = BlendState.Opaque; // use alpha blending Tools.Quick.device.DepthStencilState = DepthStencilState.Default; // don't bother with the depth/stencil buffer // Draw the model. A model can have multiple meshes, so loop. foreach (ModelMesh mesh in myModel.Meshes) { // This is where the mesh orientation is set, as well as our camera and projection. foreach (BasicEffect effect in mesh.Effects) { effect.EnableDefaultLighting(); effect.World = transforms[mesh.ParentBone.Index] * Matrix.CreateRotationY(modelRotation) * Matrix.CreateTranslation(modelPosition); //modelPosition effect.View = camera.getview(); effect.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 1000000.0f); } // Draw the mesh, using the effects set above. mesh.Draw(); } }
public void DrawTheMatrix(Model DModel, Matrix ChangeMatrix, Vector3 Pos) { Matrix[] transforms = new Matrix[DModel.Bones.Count]; DModel.CopyAbsoluteBoneTransformsTo(transforms); //Draw model with all its meshes foreach (ModelMesh mesh in DModel.Meshes)//Every mesh in MyModel { //Mesh Orientation and camera and projection foreach (BasicEffect effect in mesh.Effects) { effect.EnableDefaultLighting(); //Sets up the posibillity to use transformatiion on the G.myModelObject effect.World = transforms[mesh.ParentBone.Index] * ChangeMatrix; effect.View = Matrix.CreateLookAt(G.CamPos, G.ship.Position, Vector3.Up); // Near Far Wherever you are effect.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(G.Fov), G.aspectRatio, 1.0f, 100000); } mesh.Draw(); } }
protected override void Draw(GameTime gameTime) { graphics.GraphicsDevice.Clear(Color.CornflowerBlue); // Copy any parent transforms. spriteBatch = new SpriteBatch(GraphicsDevice); myModel = Content.Load<Model>("Models\\test"); aspectRatio = graphics.GraphicsDevice.Viewport.AspectRatio; Matrix[] transforms = new Matrix[myModel.Bones.Count]; myModel.CopyAbsoluteBoneTransformsTo(transforms); // Draw the model. A model can have multiple meshes, so loop. foreach (ModelMesh mesh in myModel.Meshes) { // This is where the mesh orientation is set, as well // as our camera and projection. foreach (BasicEffect effect in mesh.Effects) { effect.EnableDefaultLighting(); effect.World = transforms[mesh.ParentBone.Index] * Matrix.CreateRotationY(modelRotation) * Matrix.CreateTranslation(modelPosition); effect.View = Matrix.CreateLookAt(cameraPosition, Vector3.Zero, Vector3.Up); effect.Projection = Matrix.CreatePerspectiveFieldOfView( MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 10000.0f); } // Draw the mesh, using the effects set above. mesh.Draw(); } base.Draw(gameTime); }
public override void Build() { model = Demo.Content.Load<Model>("staticmesh"); boneTransforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(boneTransforms); List<TriangleVertexIndices> indices = new List<TriangleVertexIndices>(); List<Vector3> vertices = new List<Vector3>(); ExtractData(vertices, indices, model); List<JVector> jvertices = new List<JVector>(vertices.Count); foreach(Vector3 vertex in vertices) jvertices.Add(Conversion.ToJitterVector(vertex)); Octree octree = new Octree(jvertices, indices); TriangleMeshShape tms = new TriangleMeshShape(octree); RigidBody body = new RigidBody(tms); body.IsStatic = true; //body.EnableDebugDraw = true; body.Tag = BodyTag.DontDrawMe; Demo.World.AddBody(body); AddCar(new JVector(-20, 20, 0)); }
public Star(GameplayScreen game, Model model, Matrix view, Matrix projection, Random random) : base(game.ScreenManager.Game) { this.random = random; this.x = random.Next(-340, 200) / 100f; this.speed = random.Next(2, 8) / 1000f; float scale = random.Next(100, 1000)/100000f; if(speed > 0.0004) this.y = random.Next(5, 10); else this.y = random.Next(2, 5); xRotation = (float) random.Next(-360, 360); yRotation = (float)random.Next(-360, 360); zRotation = (float)random.Next(-360, 360); color = new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()); this.DrawOrder = 900; this.view = view; this.projection = projection; this.model = model; this.game = game; this.world = Matrix.Identity * Matrix.CreateScale(scale) * Matrix.CreateTranslation(x, y, 13f); transforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(transforms); }
/// <summary> /// Copies the positions of the model to the target array. /// </summary> public static int CopyPositionsTo(this Microsoft.Xna.Framework.Graphics.Model model, Vector3[] positions, int startIndex) { Matrix[] bones = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(bones); int count = 0; foreach (var mesh in model.Meshes) { foreach (var part in mesh.MeshParts) { int partCount = CopyPositionsTo(model, mesh, part, positions, startIndex); if (positions != null) { for (int i = startIndex; i < startIndex + partCount; ++i) { Vector3.Transform(ref positions[i], ref bones[mesh.ParentBone.Index], out positions[i]); } } startIndex += partCount; count += partCount; } } return(count); }
} // NumOfMeshParts #endregion #region Constructor /// <summary> /// Create model /// </summary> /// <param name="setModelName">Set model name</param> public Model(string setModelName) { name = setModelName; Load(); BaseGame.RegisterGraphicContentObject(this); // Get matrix transformations of the model // Has to be done only once because we don't use animations in this game. Matrix[] transforms = new Matrix[xnaModel.Bones.Count]; xnaModel.CopyAbsoluteBoneTransformsTo(transforms); // Calculate scaling for this object, used for distance comparisons. if (xnaModel.Meshes.Count > 0) { downScaling = // scaling = xnaModel.Meshes[0].BoundingSphere.Radius * transforms[0].Right.Length(); } if (downScaling > 0) { downScaling = 1.0f / downScaling; } objectMatrix = // Use transformation of our first mesh (we support only one) transforms[xnaModel.Meshes[0].ParentBone.Index] * Matrix.CreateRotationX(MathHelper.Pi / 2.0f) * Matrix.CreateScale(downScaling); } // Model(setModelName)
public Weapon(Game1 game,Player player, Model model, Unit unit) : base(game, unit, new CModel(game, model)) { this.player = player; Matrix[] transforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(transforms); }
public void ExtractData(List<JVector> vertices, List<JOctree.TriangleVertexIndices> indices, Model model) { Matrix[] bones_ = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(bones_); foreach (ModelMesh mm in model.Meshes) { Matrix xform = bones_[mm.ParentBone.Index]; foreach (ModelMeshPart mmp in mm.MeshParts) { int offset = vertices.Count; Vector3[] a = new Vector3[mmp.NumVertices]; mm.VertexBuffer.GetData<Vector3>(mmp.StreamOffset + mmp.BaseVertex * mmp.VertexStride, a, 0, mmp.NumVertices, mmp.VertexStride); for (int i = 0; i != a.Length; ++i) Vector3.Transform(ref a[i], ref xform, out a[i]); for (int i = 0; i < a.Length; i++) vertices.Add(new JVector(a[i].X, a[i].Y, a[i].Z)); if (mm.IndexBuffer.IndexElementSize != IndexElementSize.SixteenBits) throw new Exception( String.Format("Model uses 32-bit indices, which are not supported.")); short[] s = new short[mmp.PrimitiveCount * 3]; mm.IndexBuffer.GetData<short>(mmp.StartIndex * 2, s, 0, mmp.PrimitiveCount * 3); JOctree.TriangleVertexIndices[] tvi = new JOctree.TriangleVertexIndices[mmp.PrimitiveCount]; for (int i = 0; i != tvi.Length; ++i) { tvi[i].I0 = s[i * 3 + 2] + offset; tvi[i].I1 = s[i * 3 + 1] + offset; tvi[i].I2 = s[i * 3 + 0] + offset; } indices.AddRange(tvi); } } }
public c0000da(Model p0, c0000b5 p1, c0000db p2) { this.f00008e = p1; this.f000018 = p2; this.f00007a = new Dictionary<string, c0000dc>(); foreach (string str in this.f00008e.Keys) { this.f00007a.Add(str, new c0000dc(this.f00008e[str])); } this.f0000e1 = new Matrix[p0.Bones.Count]; p0.CopyAbsoluteBoneTransformsTo(this.f0000e1); Dictionary<string, object> tag = (Dictionary<string, object>) p0.Tag; if (tag == null) { throw new Exception("Model Processor must subclass AnimatedModelProcessor."); } this.f00013c = (c00008f[]) tag["SkinInfo"]; if (this.f00013c == null) { throw new Exception("Model processor must pass skinning info through the tag."); } this.f00013d = new Matrix[p0.Meshes.Count][]; for (int i = 0; i < this.f00013c.Length; i++) { if (c0000dd.m0001a9(p0.Meshes[i])) { this.f00013d[i] = new Matrix[this.f00013c[i].Count]; } else { this.f00013d[i] = null; } } }
//Ctor used for items like key which wont nescessarily be visible in the world public EnvironmentObject(string modelPath, ContentManager content) { model = content.Load<Model>(modelPath); transformation = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(transformation); }
public void Load(ContentManager content) { this.model = content.Load<Model>(path); // Copy any parent transforms. transforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(transforms); }
private void DrawModel(Model m) { Matrix[] transforms = new Matrix[m.Bones.Count]; float aspectRatio = Context.Graphics.Device.Viewport.AspectRatio; m.CopyAbsoluteBoneTransformsTo(transforms); Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 10000.0f); Matrix view = Matrix.CreateLookAt(new Vector3(0.0f, 2.0f, 10f), Vector3.Zero, Vector3.Up); var state = new RasterizerState(); state.CullMode = CullMode.None; Context.Graphics.Device.RasterizerState = state; foreach (ModelMesh mesh in m.Meshes) { foreach (BasicEffect effect in mesh.Effects) { effect.EnableDefaultLighting(); effect.DiffuseColor = new Vector3(1, 1, 1); effect.View = view; effect.Projection = projection; effect.World = Matrix.Identity * transforms[mesh.ParentBone.Index] * Matrix.CreateTranslation(Position) * Matrix.CreateRotationY(MathHelper.ToRadians(angle)); } mesh.Draw(); } }
public Level(Game game, string levelModelFilename) : base(game) { model = game.Content.Load<Model>(levelModelFilename); boneTransforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(boneTransforms); }
private void drawModel(Model m) { Matrix[] transforms = new Matrix[m.Bones.Count]; float aspectRatio = graphics.GraphicsDevice.Viewport.AspectRatio; m.CopyAbsoluteBoneTransformsTo(transforms); Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 10000.0f); Matrix view = Matrix.CreateLookAt(new Vector3(0.0f, 50.0f, Zoom), Vector3.Zero, Vector3.Up); foreach (ModelMesh mesh in m.Meshes) { foreach (BasicEffect effect in mesh.Effects) { effect.EnableDefaultLighting(); effect.View = view; effect.Projection = projection; effect.World = gameWorldRotation * transforms[mesh.ParentBone.Index] * Matrix.CreateTranslation(Position); } mesh.Draw(); } }
public AnimatableModel(ContentManager content) { model = content.Load<Model>("SpaceShip"); boneTransforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(boneTransforms); World = new AnimatableMatrix(); }
//0 = block //1 = table //2 = floor public SolidThing(Game game, Model model, bool isColorRandom, int thingType) : base((RigidBodyModel)model.Tag) { this.game = game; this._thingType = thingType; if (thingType == 1 || thingType == 2) { this.Freeze(); } _model = model; _meshTransforms = new Matrix[_model.Bones.Count]; _model.CopyAbsoluteBoneTransformsTo(_meshTransforms); foreach (var mesh in _model.Meshes) { foreach (BasicEffect effect in mesh.Effects) { //By disabling this we get even lighting effect.EnableDefaultLighting(); effect.AmbientLightColor = Vector3.One * 0.6f; effect.SpecularColor = Vector3.One; effect.PreferPerPixelLighting = true; } } if (_isColorRandom = isColorRandom) { _diffuseColor = new Vector3((float)_colorRand.NextDouble(), (float)_colorRand.NextDouble(), (float)_colorRand.NextDouble()); _diffuseColor *= 0.75f; //By Increasing this we get a increase in vibrance of the blocks } }
public override void Draw(SpriteBatch spriteBatch, GraphicsDevice device) { if (m_basic_effect == null) { m_basic_effect = new BasicEffect(device); m_basic_effect.FogEnabled = true; m_basic_effect.FogColor = new Vector3(0.6f, 0.6f, 0.6f); m_basic_effect.FogStart = 0.0f; m_basic_effect.FogEnd = 2000.0f; m_basic_effect.SpecularPower = 10000000.0f; } device.BlendState = BlendState.Opaque; device.DepthStencilState = DepthStencilState.Default; device.SamplerStates[0] = SamplerState.LinearWrap; RasterizerState rs = new RasterizerState(); rs.CullMode = CullMode.CullClockwiseFace; device.RasterizerState = rs; Matrix[] transforms = new Matrix[m_model.Bones.Count]; m_model.CopyAbsoluteBoneTransformsTo(transforms); Matrix World = Matrix.Identity * Matrix.CreateScale(m_scale) * Matrix.CreateFromYawPitchRoll(m_rotation.Y, m_rotation.X, m_rotation.Z) * Matrix.CreateTranslation(m_position); foreach (ModelMesh mesh in m_model.Meshes) { for (int i = 0; i < mesh.Effects.Count; i++) { BasicEffect effect = (BasicEffect)mesh.Effects[i]; effect.EnableDefaultLighting(); effect.AmbientLightColor = m_basic_effect.AmbientLightColor; effect.DiffuseColor = m_basic_effect.DiffuseColor; effect.EmissiveColor = m_basic_effect.EmissiveColor; effect.FogColor = m_basic_effect.FogColor; effect.FogEnabled = m_basic_effect.FogEnabled; effect.FogEnd = m_basic_effect.FogEnd; effect.FogStart = m_basic_effect.FogStart; effect.PreferPerPixelLighting = m_basic_effect.PreferPerPixelLighting; effect.SpecularColor = m_basic_effect.SpecularColor; effect.SpecularPower = m_basic_effect.SpecularPower; effect.Projection = m_projection_xform; effect.View = m_view_xform; effect.World = transforms[mesh.ParentBone.Index] * World; } mesh.Draw(); } if (m_boundingbox_enabled) { m_boundingbox = CalculateBoundingBox(transforms, World); DebugHelp.Draw_BoundingBox.Draw(m_boundingbox, Matrix.Identity * m_view_xform * m_projection_xform); } }
// Teken een model op een zekere positie // Hier wordt het een klein beetje ingewikkeld om de 3D effecten uit te voeren. // Misschien hoef je deze functie helemaal niet aan te passen, maar het kan natuurlijk wel. public void drawModel(Model model, float x, float y, float z) { // Maak een vector met de gewenste coordinaten. Vector3 modelPosition = new Vector3(x, y, z); // Zoals bij de introductie uitgelegd, worden modeltransformaties gerepresenteerd met matrices. // Een model kan bestaan uit onderdelen 'bones', met elk hun eigen, relatieve transformatie. // Die vragen we eerst op uit het model // Maake eerst een array van matrices aan Matrix[] transforms = new Matrix[model.Bones.Count]; // Vul deze array met de matrices van de transformaties van elk van de onderdelen van het model. model.CopyAbsoluteBoneTransformsTo(transforms); // 'view' is een 3D-naar-3D transformatie matrix die bepaalt hoe 3D voorwerpen georienteerd zijn tov een camera in de ruimte. // Maak een standaard view matrix op basis van een camera perspectief van een camera op locatie 'cameraPosition' die kijkt naar positie // 'aimPosition' en die horizontaal hangt wanneer de vector 'Vector3.Up' (0,1,) naar boven wijst. Matrix view = Matrix.CreateLookAt(cameraPosition, aimPosition, Vector3.Up); // 'projection' is een 3D-naar-2D transformatie matrix die bepaalt hoe de 3D voorwerpen in een assenstelsel relatief tov de camera afgebeeld worden // op een 2D vlak zoals het scherm. // Maak de projectie op basis van een camera met een field-of-view van 45 graden een lengte-breedte verhouding van 'aspectRatio' die alle voorwerpen ziet met een afstand // tussen 1 en 10000 eenheden. Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 10000.0f); // Teken het model. Een model kan bestaan uit meerder 'Meshes', die één voor één getekend moeten worden. Vandaar de volgende lus. foreach (ModelMesh mesh in model.Meshes) { // bepaal de transformatie matrix. Deze begint met de transformatie uit het model zelf, uit de transforms array // Daaraan wordt nog een translatie toegevoegd (vermenigvuldiging van de matrices), naar de gewenste model locatie (modelPosition) // Rotatie transformaties zijn ook mogelijk, bijv. een rotatie om de Z-as met de functie: Matrix.CreateRotationZ() Matrix world = transforms[mesh.ParentBone.Index] * Matrix.CreateTranslation(modelPosition); // Het afbeelden ('renderen') van het model gebeurt met één of meerdere 'effecten', gedefinieerd in de mesh. // Die moeten één voor één ingesteld worden met de gewenste parameters foreach (BasicEffect effect in mesh.Effects) { // Hier worden de uiteindelijke rendering parameters bepaald. // belichtingseffect effect.EnableDefaultLighting(); // voeg licht uit een bepaalde richting toe effect.DirectionalLight1.Enabled = true; effect.DirectionalLight1.Direction = new Vector3(0.0f, 300.0f, 0.0f); // zet de gewenste transformatie voor het object, 'world' effect.World = world; // zet de transformatie die het voorwerp in absolute 'wereld' coordinaten omzet in camera coordinaten effect.View = view; // zet de transformatie die de projectie naar een 2D afbeelding uitvoert. effect.Projection = projection; if (model == projectionModel) { GraphicsDevice.BlendState = BlendState.AlphaBlend; effect.Alpha = 0.5f; } } // Teken uiteindelijk mesh daadwerkelijk op het scherm met de effecten hierboven gedefinieerd. mesh.Draw(); } }
public Table(Model table3d) { // now that we've loaded in the models that will sit on the table, go // through the same procedure for the table itself. table = table3d; tableAbsoluteBoneTransforms = new Matrix[table.Bones.Count]; table.CopyAbsoluteBoneTransformsTo(tableAbsoluteBoneTransforms); }
public static void setModel(Model m) { model = m; ((BasicEffect)m.Meshes[0].Effects[0]).EnableDefaultLighting(); aTrans = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(aTrans); }
public void Setup(Model model) { originalModel = model; modelBones = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(modelBones); SetupInstancedVertexData(); }
public Actor(Model m, Texture2D t, Matrix lo) { model = m; texture = t; BoneTransforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(BoneTransforms); localTransforms = lo; }
protected override void LoadContent() { spriteBatch = new SpriteBatch(GraphicsDevice); terrain = Content.Load<Model>(@"houses"); terrain_boneTransforms = new Matrix[terrain.Bones.Count]; terrain.CopyAbsoluteBoneTransformsTo(terrain_boneTransforms); terrain_transform = terrain.Root.Transform * Matrix.CreateScale(0.01f); // 0.05 Campus }
public static GameObject ToMeshRenderers(this Model model, Scene scene) { var boneTransforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(boneTransforms); var gameObject = new GameObject("Model"); scene.Add(gameObject); foreach (ModelMesh mesh in model.Meshes) { var meshPartIndex = 0; var parent = new GameObject(mesh.Name); scene.Add(parent); parent.Transform.Parent = gameObject.Transform; var matrix = boneTransforms[mesh.ParentBone.Index]; Vector3 position; Quaternion rotation; Vector3 scale; matrix.Decompose(out scale, out rotation, out position); parent.Transform.LocalPosition = position; parent.Transform.LocalRotation = rotation.ToEuler(); parent.Transform.LocalScale = scale; foreach (var part in mesh.MeshParts) { var effect = (BasicEffect)part.Effect; var material = new StandardMaterial(scene); material.MainTexture = effect.Texture; material.DiffuseColor = new Color(effect.DiffuseColor.X, effect.DiffuseColor.Y, effect.DiffuseColor.Z); material.SpecularColor = new Color(effect.SpecularColor.X, effect.SpecularColor.Y, effect.SpecularColor.Z); material.Shininess = effect.SpecularPower; material.EmissiveColor = new Color(effect.EmissiveColor.X, effect.EmissiveColor.Y, effect.EmissiveColor.Z); var child = new GameObject($"{mesh.Name}_{meshPartIndex}"); scene.Add(child); var renderer = child.AddComponent <MeshRenderer>(); renderer.material = material; renderer.CastShadow = true; renderer.ReceiveShadow = true; var geometry = new Mesh(); geometry.VertexBuffer = part.VertexBuffer; geometry.IndexBuffer = part.IndexBuffer; renderer.Geometry = geometry; child.Transform.Parent = parent.Transform; } } return(gameObject); }
public ImportModel(Model model, GraphicsDevice gd, ContentManager cm) { GraphicDevice = gd; Content = cm; Model = model; modeltransforms = new Matrix[Model.Bones.Count]; Model.CopyAbsoluteBoneTransformsTo(modeltransforms); generateTags(); }
public void LoadSkyBox() { ContentManager contentLoader = new ContentManager(game1Service); effect = new BasicEffect(this.graphics.GraphicsDevice, null); effect.TextureEnabled = true; skybox = contentLoader.Load<Model>(@"Content\Models\SkyBox\skybox2"); boneTransforms_sky = new Matrix[skybox.Bones.Count]; skybox.CopyAbsoluteBoneTransformsTo(boneTransforms_sky); }
public void LoadWorld() { ContentManager contentLoader = new ContentManager(game1Service); // Load model from run-time directory (debug/release) world = contentLoader.Load<Model>(@"Content\Models\World\houses"); world_boneTransforms = new Matrix[world.Bones.Count]; world.CopyAbsoluteBoneTransformsTo(world_boneTransforms); world_transform = world.Root.Transform * Matrix.CreateScale(0.01f); // 0.05 Campus }
/// <summary> /// Computes the bounding box for the specified xna model. /// </summary> private static bool ComputeBoundingBoxFromVertices(this Microsoft.Xna.Framework.Graphics.Model model, out BoundingBox boundingBox) { if (null == model || model.Meshes.Count <= 0) { boundingBox = new BoundingBox(); return(false); } bool first = true; BoundingBox temp = new BoundingBox(); Matrix[] bones = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(bones); foreach (var mesh in model.Meshes) { foreach (var part in mesh.MeshParts) { if (part.VertexBuffer.BufferUsage == BufferUsage.WriteOnly) { boundingBox = new BoundingBox(); return(false); } if (!ComputeBoundingBoxFromVertices(model, mesh, part, bones[mesh.ParentBone.Index], out boundingBox)) { boundingBox = new BoundingBox(); return(false); } if (first) { temp = boundingBox; } else { BoundingBox.CreateMerged(ref temp, ref boundingBox, out temp); } first = false; } } boundingBox = temp; return(true); }
public void CreateMeshInfo(XnaModel model) { _modelBoundingParts = new BoundingPartList(); //Matrix[] modelBoneTransforms = new Matrix[model.Bones.Count]; modelBoneTransforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(modelBoneTransforms); BoundingSphere[] pieces = new BoundingSphere[1]; foreach (ModelMesh mesh in model.Meshes) { BoundingPart boundingPart = new BoundingPart(mesh.BoundingSphere, pieces, modelBoneTransforms[mesh.ParentBone.Index], mesh.Name, Color.White); _modelBoundingParts.Add(boundingPart); } }
public IModel Load(String path, String modelAssetName) { path = (path.Equals("")) ? State.GetSettingVariable("ModelDirectory") : path; String filePath = Path.Combine(path, modelAssetName); XNAModel xnaModel = State.Content.Load <XNAModel>(@"" + filePath); // Get matrix transformations of the model if (xnaModel != null) { Matrix[] transforms = new Matrix[xnaModel.Bones.Count]; xnaModel.CopyAbsoluteBoneTransformsTo(transforms); IModel model = new Model(transforms, xnaModel.Meshes); return(model); } else { Log.Write("Model " + filePath + " does not exist "); return(null); } }
public static void AddCollision(this DynamicPrimitive dynamicPrimitive, Microsoft.Xna.Framework.Graphics.Model model, Matrix?world, Color color) { if (bones == null || bones.Length < model.Bones.Count) { bones = new Matrix[model.Bones.Count]; } model.CopyAbsoluteBoneTransformsTo(bones); Matrix transform = world.HasValue ? world.Value : Matrix.Identity; ModelTag tag = model.Tag as ModelTag; // Add collision tree if (tag != null && tag.Collision != null) { transform = bones[model.Meshes[0].ParentBone.Index] * transform; Octree <bool> tree = tag.Collision.CollisionTree; tree.Traverse(node => { if (!node.hasChildren && node.value) { dynamicPrimitive.AddSolidBox(node.bounds, transform, color); } return(TraverseOptions.Continue); }); } // Add collision sphere else { for (int i = 0; i < model.Meshes.Count; ++i) { var mesh = model.Meshes[i]; dynamicPrimitive.AddSolidSphere(mesh.BoundingSphere, 18, bones[mesh.ParentBone.Index] * transform, color); } } }
private void Load(XnaModel model, string contentName) { _modelBoundingParts = new BoundingPartList(); Matrix[] modelBoneTransforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(modelBoneTransforms); XmlDocument meshInfo = new XmlDocument(); if (File.Exists(string.Format(@".\MeshInfo\{0}.xml", contentName))) { meshInfo.Load(string.Format(@".\MeshInfo\{0}.xml", contentName)); } if ((!meshInfo.DocumentElement.HasAttributes) || (meshInfo.DocumentElement.Attributes["scaleModifier"] == null)) { _scaleModifier = 1f; } else { _scaleModifier = float.Parse(meshInfo.DocumentElement.Attributes["scaleModifier"].Value); } int meshIndex = 0; foreach (ModelMesh mesh in model.Meshes) { string xpath = string.Format("/MeshInfo/MeshPart[@id='{0}']", mesh.Name); XmlNode meshInfoPart = meshInfo.SelectSingleNode(xpath); XmlNodeList meshInfoBoundingParts = null; if (meshInfoPart != null) { xpath = "BoundingParts/BoundingPart"; meshInfoBoundingParts = meshInfoPart.SelectNodes(xpath); } if ((meshInfoBoundingParts != null) && (meshInfoBoundingParts.Count > 0)) { BoundingSphere[] pieces = new BoundingSphere[meshInfoBoundingParts.Count]; int pieceIndex = 0; Color boundingPartColour = new Color(byte.Parse(meshInfoPart.Attributes["color.bounds.r"].Value), byte.Parse(meshInfoPart.Attributes["color.bounds.g"].Value), byte.Parse(meshInfoPart.Attributes["color.bounds.b"].Value)); foreach (XmlNode subdivisionNode in meshInfoBoundingParts) { float x0 = float.Parse(subdivisionNode.Attributes["x"].Value); float y0 = float.Parse(subdivisionNode.Attributes["y"].Value); float z0 = float.Parse(subdivisionNode.Attributes["z"].Value); float w0 = float.Parse(subdivisionNode.Attributes["w"].Value); Vector4 subdivision = new Vector4(x0, y0, z0, w0); //Determine the new BoundingSphere's Radius float radius = subdivision.W * mesh.BoundingSphere.Radius; //Determine the new BoundingSphere's Center by interpolating. //The subdivision's X, Y, Z represent percentages in each axis. //They will used across the full diameter of XNA's "default" BoundingSphere. float x = MathHelper.Lerp(mesh.BoundingSphere.Center.X - mesh.BoundingSphere.Radius, mesh.BoundingSphere.Center.X + mesh.BoundingSphere.Radius, subdivision.X); float y = MathHelper.Lerp(mesh.BoundingSphere.Center.Y - mesh.BoundingSphere.Radius, mesh.BoundingSphere.Center.Y + mesh.BoundingSphere.Radius, subdivision.Y); float z = MathHelper.Lerp(mesh.BoundingSphere.Center.Z - mesh.BoundingSphere.Radius, mesh.BoundingSphere.Center.Z + mesh.BoundingSphere.Radius, subdivision.Z); Vector3 center = new Vector3(x, y, z); pieces[pieceIndex] = new BoundingSphere(center, radius); pieceIndex++; } BoundingPart boundingPart = new BoundingPart(mesh.BoundingSphere, pieces, modelBoneTransforms[mesh.ParentBone.Index], mesh.Name, boundingPartColour); _modelBoundingParts.Add(boundingPart); } meshIndex++; } }
public override void Draw(GameTime gameTime) { if (Content != null && Camera != null && Enabled && Visible) { // Copy any parent transforms. Matrix[] transforms = new Matrix[Content.Bones.Count]; Content.CopyAbsoluteBoneTransformsTo(transforms); foreach (ModelMesh mesh in Content.Meshes) { // Update our World Matrix for this Model World = transforms[mesh.ParentBone.Index] * Matrix.CreateRotationX(Rotation.X) * Matrix.CreateRotationY(Rotation.Y) * Matrix.CreateRotationZ(Rotation.Z) * Matrix.CreateScale(Scale) * Matrix.CreateTranslation(Position); if (CustomEffect != null) { #region Custom HLSL Effect Rendering /********************************************************************************************************* * -- Please do not f**k with this to much haha unless ya ask me (AR-50 LOCKED AND LOADED!) -- *********************************************************************************************************/ // Pass our meshes Index buffer to our graphics device //GraphicsDevice.Indices = mesh.IndexBuffer; // Loop thru the Custom Effect's passes foreach (EffectPass pass in CustomEffect.CurrentTechnique.Passes) { // Begin our First pass pass.Apply(); // Render this pass over the parts inside the mesh foreach (ModelMeshPart part in mesh.MeshParts) { // Pass our mesh part's Vertex declaration to our graphics device //GraphicsDevice.VertexDeclaration = part.VertexDeclaration; // Manually pass our vertices to our graphics device //GraphicsDevice.Vertices[0].SetSource(mesh.VertexBuffer, part.StreamOffset, part.VertexStride); // TODO: Need to rework this .. the double casts will kill performance! *Refactor OUT* // Check and see if the part has an attached texture if (((BasicEffect)part.Effect).Texture != null) { // If it does pass the texture our graphics device instead of manually in our shader GraphicsDevice.Textures[0] = ((BasicEffect)part.Effect).Texture; } // Finally Draw our Index Primitives (Triangles) for this part of our mesh GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, part.NumVertices, 0, part.NumVertices, part.StartIndex, part.PrimitiveCount); } } #endregion } else { #region Basic Effect Rendering Loop // Setup culling / fill RasterizerState rasterizerState1 = new RasterizerState(); rasterizerState1.CullMode = CullMode; rasterizerState1.FillMode = FillMode; GraphicsDevice.RasterizerState = rasterizerState1; // Set our alpha blending states if enabled if (EnableAlphaBlending) { GraphicsDevice.BlendState = BlendState.AlphaBlend; //GraphicsDevice.RenderState.AlphaBlendEnable = true; //GraphicsDevice.RenderState.AlphaTestEnable = true; //GraphicsDevice.RenderState.AlphaFunction = CompareFunction.Greater; //GraphicsDevice.RenderState.SourceBlend = Blend.SourceAlpha; //GraphicsDevice.RenderState.DestinationBlend = Blend.InverseSourceAlpha; //GraphicsDevice.RenderState.BlendFunction = BlendFunction.Load; } foreach (BasicEffect effect in mesh.Effects) { effect.EnableDefaultLighting(); effect.AmbientLightColor = AmbientColor.ToVector3(); effect.DiffuseColor = DiffuseColor.ToVector3(); effect.EmissiveColor = EmissiveColor.ToVector3(); effect.SpecularColor = SpecularColor.ToVector3(); effect.World = World; effect.View = Camera.View; effect.Projection = Camera.Projection; } mesh.Draw(); // Reset our alpha blending states if (EnableAlphaBlending) { //GraphicsDevice.RenderState.AlphaBlendEnable = false; //GraphicsDevice.RenderState.AlphaTestEnable = false; //GraphicsDevice.RenderState.SourceBlend = Blend.Zero; //GraphicsDevice.RenderState.DestinationBlend = Blend.Zero; } #endregion } base.Draw(gameTime); } } }
/// <summary> /// Create model /// </summary> /// <param name="setModelName">Set model name</param> public Model(string setModelName) { name = setModelName; xnaModel = BaseGame.Content.Load <XnaModel>( @"Content\Models\" + name); // Get matrix transformations of the model // Has to be done only once because we don't use animations in our game. if (xnaModel != null) { transforms = new Matrix[xnaModel.Bones.Count]; xnaModel.CopyAbsoluteBoneTransformsTo(transforms); // Calculate scaling for this object, used for distance comparisons. if (xnaModel.Meshes.Count > 0) { realScaling = scaling = xnaModel.Meshes[0].BoundingSphere.Radius * transforms[0].Right.Length(); } // For palms, laterns, holders and column holders reduce scaling // to reduce the number of objects we have to render. if (name.ToLower() == "alphapalm" || name.ToLower() == "alphapalm2" || name.ToLower() == "alphapalm3" || name.ToLower() == "roadcolumnsegment") { scaling *= 0.75f; } // Hotels and windmills should always be visible (they are big) if (name.ToLower() == "hotel01" || name.ToLower() == "hotel02" || name.ToLower() == "casino01" || name.ToLower() == "windmill") { scaling *= 5.0f; } else // Don't use more than 3m for scaling and checking smaller objects if (scaling > 3) { scaling = 3; } } hasAlpha = name.ToLower().StartsWith("alpha"); // Is this a sign or banner? Then make sure ambient is pretty high! bool isSign = name.ToLower().StartsWith("sign") || name.ToLower().StartsWith("banner") || // Also include windmills, they are too dark name.ToLower().StartsWith("windmill"); //name.StartsWith("StartLight"); isCar = (name.ToLower() == "car"); // Go through all meshes in the model for (int meshNum = 0; meshNum < xnaModel.Meshes.Count; meshNum++) { ModelMesh mesh = xnaModel.Meshes[meshNum]; int meshPartNum = 0; string meshName = mesh.Name; // Remember this mesh for animations done in Render! if (name.ToLower() == "windmill" && meshName.ToLower().StartsWith("windmill_wings")) { animatedMesh = mesh; } // And for each effect this mesh uses (usually just 1, multimaterials // are nice in 3ds max, but not efficiently for rendering stuff). for (int effectNum = 0; effectNum < mesh.Effects.Count; effectNum++) { Effect effect = mesh.Effects[effectNum]; // Store our 4 effect parameters cachedEffectParameters.Add(effect.Parameters["diffuseTexture"]); cachedEffectParameters.Add(effect.Parameters["ambientColor"]); cachedEffectParameters.Add(effect.Parameters["diffuseColor"]); cachedEffectParameters.Add(effect.Parameters["world"]); cachedEffectParameters.Add(effect.Parameters["viewProj"]); cachedEffectParameters.Add(effect.Parameters["viewInverse"]); cachedEffectParameters.Add(effect.Parameters["lightDir"]); // Store if this is a "ReflectionSpecular" technique cachedIsReflectionSpecularTechnique.Add( effect.CurrentTechnique.Name.Contains("ReflectionSpecular")); // Increase ambient value to 0.5, 0.5, 0.5 for signs and banners! if (isSign) { effect.Parameters["ambientColor"].SetValue( new Color(128, 128, 128).ToVector4()); } // Car only uses alpha on the glass if (isCar && !mesh.Name.StartsWith("glass")) { effect.Parameters["UseAlpha"].SetValue(false); } // Get technique from meshName int techniqueIndex = -1; if (meshName.Length > meshPartNum) { string techniqueNumberString = meshName.Substring( meshName.Length - (1 + meshPartNum), 1); #if !XBOX360 // Faster and does not throw an exception! int.TryParse(techniqueNumberString, out techniqueIndex); #else try { techniqueIndex = Convert.ToInt32(techniqueNumberString); } catch { } #endif } // No technique found or invalid? if (techniqueIndex < 0 || techniqueIndex >= effect.Techniques.Count) { // Try to use last technique techniqueIndex = effect.Techniques.Count - 1; // If this is NormalMapping, use DiffuseSpecular20 instead // of the last technique (which is SpecularWithReflection20) if (effect.Techniques[techniqueIndex].Name.Contains( "SpecularWithReflection")) { techniqueIndex -= 2; } // Update: We have now 2 more techniques (ReflectionSpecular) if (effect.Techniques[techniqueIndex].Name.Contains( "ReflectionSpecular")) { techniqueIndex -= 4; } } // Set current technique for rendering below effect.CurrentTechnique = effect.Techniques[techniqueIndex]; // Next mesh part meshPartNum++; } // Add all mesh parts! for (int partNum = 0; partNum < mesh.MeshParts.Count; partNum++) { ModelMeshPart part = mesh.MeshParts[partNum]; // The model mesh part is not really used, we just extract the // index and vertex buffers and all the render data. // Material settings are build from the effect settings. // Also add this to our own dictionary for rendering. renderableMeshes.Add(part, BaseGame.MeshRenderManager.Add( part.VertexBuffer, part.IndexBuffer, part, part.Effect)); } } #if DEBUG // Check if there are no meshes to render if (xnaModel.Meshes.Count == 0) { throw new ArgumentException("Invalid model " + name + ". It does not contain any meshes"); } #endif }