Засоби технології Microsoft XNA як основа розробки тривимірних ігрових додатків

Panel_Active_Tex = Game.Content.Load<Texture2D>(@"Sprites\Panel_A");

Panel_Passive_Tex = Game.Content.Load<Texture2D>(@"Sprites\Panel_P");

Menu_Song = Game.Content.Load<Song>(@"Audio\M_Menu");

}

public override void Update(GameTime gameTime)

{

ButtonStart.Update();

ButtonExit.Update();

ButtonOptions.Update();

ButtonTest.Update();

ButtonPanel.Update();

if (ButtonExit.Cliked == true)

{

((Main)Game).Exit();

}

if (ButtonTest.Cliked == true)

{

((Main)Game).GameState = "Test";

// запуск компонентов

((Main)Game).modelManager.Enabled = true;

((Main)Game).modelManager.Visible = true;

((Main)Game).camera.Enabled = true;

((Main)Game).camera.Initialize();

((Main)Game).ui.Enabled = true;

((Main)Game).ui.Visible = true;

// настройка курсора

((Main)Game).IsMouseVisible = false;

((Main)Game).sightPos = new Vector2(((Main)Game).Window.ClientBounds.Width / 2 - 50,

((Main)Game).Window.ClientBounds.Height / 2 - 50);

MenuMusik(false);

this.Enabled = false;

this.Visible = false;

}

if (ButtonStart.Cliked == true)

{

((Main)Game).GameState = "Game";

// запуск компонентов

((Main)Game).modelManager.Enabled = true;

((Main)Game).modelManager.Visible = true;

((Main)Game).camera.Enabled = true;

((Main)Game).ui.Enabled = true;

((Main)Game).ui.Visible = true;

// настройка курсора

((Main)Game).IsMouseVisible = false;

((Main)Game).sightPos = new Vector2(((Main)Game).Window.ClientBounds.Width / 2 ,

((Main)Game).Window.ClientBounds.Height / 2 );

MenuMusik(false);

((Main)Game).loader.LevelLoad();

this.Enabled = false;

this.Visible = false;

}

base.Update(gameTime);

}

public void MenuMusik(bool status)

{

if (status == true)

{

MediaPlayer.Play(Menu_Song);

MediaPlayer.IsRepeating = true;

}

if (status == false)

{

MediaPlayer.Stop();

MediaPlayer.IsRepeating = false;

}

}

public override void Draw(GameTime gameTime)

{

// отрисовка кнопок

ButtonStart.Draw();

ButtonExit.Draw();

ButtonOptions.Draw();

ButtonTest.Draw();

ButtonPanel.Draw();

base.Draw(gameTime);

}

}

}

Вихідний код модуля Camera.cs

using System;

using System.Collections.Generic;

using System.Linq;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Audio;

using Microsoft.Xna.Framework.Content;

using Microsoft.Xna.Framework.GamerServices;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Input;

using Microsoft.Xna.Framework.Media;

namespace _3D

{

public class Camera : Microsoft.Xna.Framework.GameComponent

{

public static Vector3 Position;

public static Matrix Projection;

public static Matrix View;

MouseState prevMouseState;

public float speed = 3;

public Vector3 cameraPosition { get; protected set; }

public Vector3 cameraDirection;

public Vector3 cameraUp;

float totalPitch = MathHelper.PiOver2 - (float)0.017453;

float currentPitch = 0;

// углы для для движения камеры по орбите мировой сферы

float c_b = 0.000005f;

float c_a = 0.000005f;

// Для сохранения

Vector3 Save_Target;

Vector3 Save_cameraUp;

Vector3 Save_Position;

Matrix Save_projection;

Matrix Save_view;

private void CreateLookAt()

{

view = Matrix.CreateLookAt(cameraPosition,

cameraPosition + cameraDirection, cameraUp);

View = view;

Position = cameraPosition;

}

public Matrix view { get; protected set; }

public Matrix projection { get; protected set; }

public Camera(Game game, Vector3 pos, Vector3 target, Vector3 up)

: base(game)

{

cameraPosition = pos;

cameraDirection = target - pos;

cameraDirection.Normalize();

cameraUp = up;

CreateLookAt();

projection = Matrix.CreatePerspectiveFieldOfView(

MathHelper.PiOver4,

(float)Game.Window.ClientBounds.Width /

(float)Game.Window.ClientBounds.Height,

1, 10000);

View = view;

Position = cameraPosition;

Projection = projection;

// Для сохранения

Save_Target = target;

Save_cameraUp=cameraUp;

Save_Position=cameraPosition;

Save_projection=projection;

Save_view = view;

}

public void Restart()

{

c_b = 0.000005f;

c_a = 0.000005f;

// Save_cameraDirection;

cameraUp = Save_cameraUp ;

cameraPosition = Save_Position;

projection = Save_projection;

view = Save_view;

}

public override void Initialize()

{ // установка курсора

Mouse.SetPosition(Game.Window.ClientBounds.Width / 2,

Game.Window.ClientBounds.Height / 2);

prevMouseState = Mouse.GetState();

base.Initialize();

}

public override void Update(GameTime gameTime)

{

// космос

if (((Main)Game).GameState == "Space")

{

//Движение

if (Keyboard.GetState().IsKeyDown(Keys.W))

cameraPosition += cameraDirection * speed;

if (Keyboard.GetState().IsKeyDown(Keys.S))

cameraPosition -= cameraDirection * speed;

if (Keyboard.GetState().IsKeyDown(Keys.A))

cameraPosition += Vector3.Cross(cameraUp, cameraDirection) * speed;

if (Keyboard.GetState().IsKeyDown(Keys.D))

cameraPosition -= Vector3.Cross(cameraUp, cameraDirection) * speed;

// вращение

// право лево

cameraDirection = Vector3.Transform(cameraDirection,

Matrix.CreateFromAxisAngle(cameraUp, (-MathHelper.PiOver4 / 150) *

(Mouse.GetState().X - prevMouseState.X)));

// Вверх вниз

float pitchAngle = (MathHelper.PiOver4 / 150) *

(Mouse.GetState().Y - prevMouseState.Y);

if (Math.Abs(currentPitch + pitchAngle) < totalPitch)

{

cameraDirection = Vector3.Transform(cameraDirection,

Matrix.CreateFromAxisAngle(

Vector3.Normalize(Vector3.Cross(cameraUp, cameraDirection)),

pitchAngle));

currentPitch += pitchAngle;

}

// возвращение в центр

Mouse.SetPosition(Game.Window.ClientBounds.Width / 2,

Game.Window.ClientBounds.Height / 2);

// активировать предвидущее состояние мыши

prevMouseState = Mouse.GetState();

// Q E

if (Keyboard.GetState().IsKeyDown(Keys.E))

{

cameraUp = Vector3.Transform(cameraUp,

Matrix.CreateFromAxisAngle(cameraDirection,

MathHelper.PiOver4 / 45));

}

if (Keyboard.GetState().IsKeyDown(Keys.Q))

{

cameraUp = Vector3.Transform(cameraUp,

Matrix.CreateFromAxisAngle(cameraDirection,

-MathHelper.PiOver4 / 45));

}

}

//===============================================================

// Тестовая сцена

if (((Main)Game).GameState == "Test")

{

//Движение

if (Keyboard.GetState().IsKeyDown(Keys.W))

cameraPosition += cameraDirection * speed;

if (Keyboard.GetState().IsKeyDown(Keys.S))

cameraPosition -= cameraDirection * speed;

if (Keyboard.GetState().IsKeyDown(Keys.A))

cameraPosition += Vector3.Cross(cameraUp, cameraDirection) * speed;

if (Keyboard.GetState().IsKeyDown(Keys.D))

cameraPosition -= Vector3.Cross(cameraUp, cameraDirection) * speed;

// вращение

// право лево

cameraDirection = Vector3.Transform(cameraDirection,

Matrix.CreateFromAxisAngle(cameraUp, (-MathHelper.PiOver4 / 150) *

(Mouse.GetState().X - prevMouseState.X)));

// Вверх вниз

float pitchAngle = (MathHelper.PiOver4 / 150) *

(Mouse.GetState().Y - prevMouseState.Y);

if (Math.Abs(currentPitch + pitchAngle) < totalPitch)

{

cameraDirection = Vector3.Transform(cameraDirection,

Matrix.CreateFromAxisAngle(

Vector3.Normalize(Vector3.Cross(cameraUp, cameraDirection)),

pitchAngle));

currentPitch += pitchAngle;

}

// возвращение курсора в центр в центр

Mouse.SetPosition(Game.Window.ClientBounds.Width / 2,

Game.Window.ClientBounds.Height / 2);

prevMouseState = Mouse.GetState();

// Q E

if (Keyboard.GetState().IsKeyDown(Keys.E))

{

cameraUp = Vector3.Transform(cameraUp,

Matrix.CreateFromAxisAngle(cameraDirection,

MathHelper.PiOver4 / 45));

}

if (Keyboard.GetState().IsKeyDown(Keys.Q))

{

cameraUp = Vector3.Transform(cameraUp,

Matrix.CreateFromAxisAngle(cameraDirection,

-MathHelper.PiOver4 / 45));

}

}



//==================================================================

// Игра

if (((Main)Game).GameState == "Game")

{

//Движение

cameraPosition = new Vector3((float)(700 * Math.Cos(c_b) * Math.Cos(c_a)),

(float)(700 * Math.Sin(c_b)),

(float)(700 * Math.Cos(c_b) * Math.Sin(c_a)));

if (Keyboard.GetState().IsKeyDown(Keys.W))

{

if(c_b<Math.PI/2)

c_b += 0.01f;

}

if (Keyboard.GetState().IsKeyDown(Keys.S))

{

if (c_b > -Math.PI / 2)

c_b -= 0.01f;

}

if (Keyboard.GetState().IsKeyDown(Keys.A))

c_a += 0.01f;

if (Keyboard.GetState().IsKeyDown(Keys.D))

c_a -= 0.01f;

// вращение

// право лево

cameraDirection = Vector3.Transform(cameraDirection,

Matrix.CreateFromAxisAngle(cameraUp, (-MathHelper.PiOver4 / 150) *

(Mouse.GetState().X - prevMouseState.X)));

// Вверх вниз

float pitchAngle = (MathHelper.PiOver4 / 150) *

(Mouse.GetState().Y - prevMouseState.Y);

if (Math.Abs(currentPitch + pitchAngle) < totalPitch)

{

cameraDirection = Vector3.Transform(cameraDirection,

Matrix.CreateFromAxisAngle(

Vector3.Normalize(Vector3.Cross(cameraUp, cameraDirection)),

pitchAngle));

currentPitch += pitchAngle;

}

// возвращение курсора в центр в центр

Mouse.SetPosition(Game.Window.ClientBounds.Width / 2,

Game.Window.ClientBounds.Height / 2);

prevMouseState = Mouse.GetState();

// Q E

if (Keyboard.GetState().IsKeyDown(Keys.E))

{

cameraUp = Vector3.Transform(cameraUp,

Matrix.CreateFromAxisAngle(cameraDirection,

MathHelper.PiOver4 / 45));

}

if (Keyboard.GetState().IsKeyDown(Keys.Q))

{

cameraUp = Vector3.Transform(cameraUp,

Matrix.CreateFromAxisAngle(cameraDirection,

-MathHelper.PiOver4 / 45));

}

}

CreateLookAt();

base.Update(gameTime);

}

}

}

Вихідний код модуля RenderCapture.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Audio;

using Microsoft.Xna.Framework.Content;

using Microsoft.Xna.Framework.GamerServices;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Input;

using Microsoft.Xna.Framework.Media;

namespace _3D

{

public class RenderCapture

{

RenderTarget2D renderTarget;

GraphicsDevice graphicsDevice;

public RenderCapture(GraphicsDevice GraphicsDevice)

{

this.graphicsDevice = GraphicsDevice;

renderTarget = new RenderTarget2D(GraphicsDevice,

GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height,

false, SurfaceFormat.Color, DepthFormat.Depth24);

}

public void Begin()

{

graphicsDevice.SetRenderTarget(renderTarget);

}

public void End()

{

graphicsDevice.SetRenderTarget(null);

}

public Texture2D GetTexture()

{

return renderTarget;

}

}

}

Вихідний код модуля GaussianBlur.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Audio;

using Microsoft.Xna.Framework.Content;

using Microsoft.Xna.Framework.GamerServices;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Input;

using Microsoft.Xna.Framework.Media;

namespace _3D

{

public class GaussianBlur : PostProcessor

{

float blurAmount;

float[] weightsH, weightsV;

Vector2[] offsetsH, offsetsV;

RenderCapture capture;

public RenderCapture ResultCapture = null;

public GaussianBlur(GraphicsDevice graphicsDevice, ContentManager Content, float BlurAmount): base(Content.Load<Effect>(@"Shaders\GaussianBlur"), graphicsDevice)

{

this.blurAmount = BlurAmount;

calcSettings(3.0f / (float)graphicsDevice.Viewport.Width, 0,

out weightsH, out offsetsH);

calcSettings(0, 3.0f / (float)graphicsDevice.Viewport.Height,

out weightsV, out offsetsV);

capture = new RenderCapture(graphicsDevice);

}

float gaussianFunc(float x)

{

return (float)((1.0f / Math.Sqrt(2 * Math.PI * Math.Pow(blurAmount,2))) *

Math.Exp(-(Math.Pow(x,2)) / (2 * Math.Pow(blurAmount,2))));

}

void calcSettings(float w, float h, out float[] weights, out Vector2[]offsets)

{

weights = new float[15];

offsets = new Vector2[15];

weights[0] = gaussianFunc(0);

offsets[0] = new Vector2(0, 0);

float total = weights[0];

for (int i = 0; i < 7; i++)

{

float weight = gaussianFunc(i + 1);

weights[i * 2 + 1] = weight;

weights[i * 2 + 2] = weight;

total += weight * 2;

float offset = i * 2 + 1.5f;

Vector2 offsetVec = new Vector2(w, h) * offset;

offsets[i * 2 + 1] = offsetVec;

offsets[i * 2 + 2] = -offsetVec;

}

for (int i = 0; i < weights.Length; i++)

weights[i] /= total;

}

public override void Draw()

{

Effect.Parameters["Offsets"].SetValue(offsetsH);

Effect.Parameters["Weights"].SetValue(weightsH);

capture.Begin();

base.Draw();

capture.End();

Input = capture.GetTexture();

if (ResultCapture != null)

ResultCapture.Begin();

Effect.Parameters["Offsets"].SetValue(offsetsV);

Effect.Parameters["Weights"].SetValue(weightsV);

base.Draw();

if (ResultCapture != null)

ResultCapture.End();

}

}

}



Вихідний код модуля BasicModel.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Graphics;

namespace _3D

{

public class BasicModel

{

public bool Lighting=true;

public float Size;

public Model model { get; protected set; }

public Matrix world = Matrix.Identity;

public Matrix PrevWorld = Matrix.Identity;

public BasicModel(Model m,Vector3 position,float size)

{

Size = size;

model = m;

world = Matrix.CreateTranslation(position);

PrevWorld = world;

}

public virtual void Update()

{

}

public bool CheckRayIntersection(Ray ray)

{

Ray pRay = ray;

BoundingSphere boundingSphere;

foreach (ModelMesh mesh in model.Meshes)

{

boundingSphere = mesh.BoundingSphere.Transform(GetWorld() );

boundingSphere.Radius = boundingSphere.Radius * Size;

if (pRay.Intersects(boundingSphere) != null)

return true;

}

return false;

}

public void Prev()

{

world = PrevWorld;

}

public void Draw(Camera camera)

{

Matrix[] transforms = new Matrix[model.Bones.Count];

model.CopyAbsoluteBoneTransformsTo(transforms);

foreach (ModelMesh mesh in model.Meshes)

{

foreach (BasicEffect be in mesh.Effects)

{

if (Lighting == true)

{

be.LightingEnabled = true; //включить систему освещения

be.DirectionalLight0.DiffuseColor = new Vector3(1f, 1f, 1f);

be.DirectionalLight0.Direction = new Vector3(1, 0, 0);

be.DirectionalLight0.SpecularColor = new Vector3(1, 0, 0);

be.AmbientLightColor = new Vector3(0.2f, 0.2f, 0.2f);

be.EmissiveColor = new Vector3(0, 0, 0);

}

else

{ be.LightingEnabled = false; }

be.Projection = camera.projection;

be.View = camera.view;

be.World = mesh.ParentBone.Transform * Matrix.CreateScale(Size) * GetWorld();

}

mesh.Draw();

}

}

public virtual Matrix GetWorld()

{

return world;

}

}

}

Вихідний код модуля TexturedModel.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Content;

namespace _3D

{

public class TexturedModel : BasicModel

{

Effect TexturedEffect;

public TexturedModel(Model model, Vector3 Position, float size )

: base(model, Position, size)

{ }

public void Draw(Camera camera, Texture2D mTexture, Effect TexEffect)

{

TexturedEffect = TexEffect;

Matrix[] transforms = new Matrix[model.Bones.Count];

model.CopyAbsoluteBoneTransformsTo(transforms);

foreach (ModelMesh mesh in model.Meshes)

{

foreach (ModelMeshPart part in mesh.MeshParts)

{

part.Effect = TexturedEffect;

TexturedEffect.Parameters["World"].SetValue(mesh.ParentBone.Transform * Matrix.CreateScale(Size) * GetWorld());

TexturedEffect.Parameters["View"].SetValue(camera.view);

TexturedEffect.Parameters["Projection"].SetValue(camera.projection);

TexturedEffect.Parameters["Tex"].SetValue(mTexture);

}

mesh.Draw();

}

}

}

}

Вихідний код модуля SpaceObject.cs

using System;

using System.Collections.Generic;

using System.Linq;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Audio;

using Microsoft.Xna.Framework.Content;

using Microsoft.Xna.Framework.GamerServices;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Input;

using Microsoft.Xna.Framework.Media;

namespace _3D

{

public class Space_Object : BasicModel

{

public Vector3 position;

int Rotate = 1;

public float Personal_RotationX;

public float Personal_RotationY;

public float Personal_RotationZ;

Matrix Personal_Rotation = Matrix.Identity;

Matrix Object_Rotation = Matrix.Identity;

Matrix Test = Matrix.Identity;

public Matrix Object_Rotation_Pos = Matrix.Identity;

public float Object_RotationX;

public float Object_RotationY;

public float Object_RotationZ;

public int Index_Object;

public string Name;

public int Speed=5;

public Space_Object(string name, Model m, Vector3 Position, float size, float personal_RotationX, float personal_RotationY,

float personal_RotationZ, int Index, float object_RotationX, float object_RotationY, float object_RotationZ)

: base(m,Position, size)

{

Name = name;

world = Matrix.CreateTranslation(Position);

position = Position;

Personal_RotationX = personal_RotationX;

Personal_RotationY = personal_RotationY;

Personal_RotationZ = personal_RotationZ;

Object_RotationX = object_RotationX;

Object_RotationY = object_RotationY;

Object_RotationZ = object_RotationZ;

Index_Object = Index;

}

public virtual void Update(Matrix object_rotation_pos)

{

Object_Rotation_Pos = object_rotation_pos;

if ((Keyboard.GetState().IsKeyDown(Keys.R)) && (Rotate == 0))

{

Rotate = 1;

}

//остановить вращение

if ((Keyboard.GetState().IsKeyDown(Keys.T)) && (Rotate == 1))

{

Rotate = 0;

}

if (Rotate == 1)

{

//вращение вокруг другого обьекта

Object_Rotation *= Matrix.CreateFromYawPitchRoll(Object_RotationX * Speed, Object_RotationY * Speed, Object_RotationZ * Speed);

//вращение вокруг себя

Personal_Rotation *= Matrix.CreateFromYawPitchRoll(Personal_RotationX * Speed, Personal_RotationY * Speed, Personal_RotationZ * Speed);

}

}

public override Matrix GetWorld()

{ // если обьект вращается только вокруг себя

if (Object_Rotation_Pos == world)

{ return Personal_Rotation * world; }

else

{// если обьект вращается вокруг себя и другого обьекта

return Personal_Rotation * world *

Object_Rotation * Object_Rotation_Pos;

}

}

}

}

Вихідний код модуля Game_objects.cs

sing System;

using System.Collections.Generic;

using System.Linq;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Audio;

using Microsoft.Xna.Framework.Content;

using Microsoft.Xna.Framework.GamerServices;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Input;

using Microsoft.Xna.Framework.Media;

namespace _3D

{

public class Player_Sphere : TexturedModel

{

public String Name;

public String State;

public int Health;

public int Armor;

public float Power = 0;

public bool Step = false;

public Vector3 Position;

public float Personal_RotationX;

public float Personal_RotationY;

public float Personal_RotationZ;

public int Speed_Rotation = 1;

public Vector3 Mov_Direction;

Matrix Personal_Rotation = Matrix.Identity;

public Player_Sphere(string name, string state,int health,int armor, Model model, Vector3 position,

float size, float personal_RotationX, float personal_RotationY, float personal_RotationZ): base(model, position, size)

{

Name = name;

State = state;

Health = health;

Armor = armor;

Position = position;

world = Matrix.CreateTranslation(Position);

Personal_RotationX = personal_RotationX;

Personal_RotationY = personal_RotationY;

Personal_RotationZ = personal_RotationZ;

Mov_Direction = new Vector3(0, 0, 0);

}

public override void Update()

{

if (Health > 100)

Health = 100;

Size = Health / 200f;

PrevWorld = world;

if (Power != 0)

{

world = world * Matrix.CreateTranslation(Mov_Direction * Power / 5);

Power = Power - 0.5f;

if (Power < 0)

{

Power = 0;

}

}

//вращение вокруг себя

Personal_Rotation *= Matrix.CreateFromYawPitchRoll(Personal_RotationX * Speed_Rotation,

Personal_RotationY * Speed_Rotation, Personal_RotationZ * Speed_Rotation);

}

public override Matrix GetWorld()

{ return Personal_Rotation * world; }

}

public class World_Sphere : TexturedModel

{

public String State;

public float Personal_RotationX;

public float Personal_RotationY;

public float Personal_RotationZ;

public Vector3 Position;

public int Speed_Rotation = 1;

Matrix Personal_Rotation = Matrix.Identity;

public World_Sphere(string state, Model model, Vector3 position,

float size, float personal_RotationX, float personal_RotationY, float personal_RotationZ): base(model, position, size)

{

State = state;

Position = position;

world = Matrix.CreateTranslation(Position);

Personal_RotationX = personal_RotationX;

Personal_RotationY = personal_RotationY;

Personal_RotationZ = personal_RotationZ;

}

public override void Update()

{

Personal_Rotation *= Matrix.CreateFromYawPitchRoll(Personal_RotationX * Speed_Rotation,

Personal_RotationY * Speed_Rotation, Personal_RotationZ * Speed_Rotation);

}

public override Matrix GetWorld()

{ return Personal_Rotation * world; }

}

public class Enemy_Sphere : TexturedModel

{

public String Name;

public String State;

public int Health;

public int Armor;

public bool Step=false;

public int StartHealth;

public Vector3 Position;

public float Personal_RotationX;

public float Personal_RotationY;

public float Personal_RotationZ;

public int Speed_Rotation = 1;

public float Power = 0;

public Vector3 Mov_Direction;

Matrix Personal_Rotation = Matrix.Identity;

public Enemy_Sphere(string name, string state, int health, int armor, Model model, Vector3 position,

float size, float personal_RotationX, float personal_RotationY,float personal_RotationZ): base(model, position, size)

{ Name = name;

State = state;

Health = health;

Armor = armor;

StartHealth = Health;

Position = position;

world = Matrix.CreateTranslation(Position);

Personal_RotationX = personal_RotationX;

Personal_RotationY = personal_RotationY;

Personal_RotationZ = personal_RotationZ;

}

public override void Update()

{

PrevWorld = world;

if (Power != 0)

{

world = world * Matrix.CreateTranslation(Mov_Direction * Power / 5);

Power = Power - 0.5f;

if (Power < 0)

{

Power = 0;

}

}

Personal_Rotation *= Matrix.CreateFromYawPitchRoll(Personal_RotationX * Speed_Rotation,

Personal_RotationY * Speed_Rotation, Personal_RotationZ * Speed_Rotation);

}

public override Matrix GetWorld()

{ return Personal_Rotation * world; }

}

}

Вихідний код модуля Button.cs

using System;

using System.Collections.Generic;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Input;

namespace _3D

{

class Button

{

SpriteBatch spriteBatch;

MouseState currentMouseState;

MouseState previousMouseState;

Rectangle B_rectangle;

Texture2D PassiveTex;

Texture2D ActiveTex;

public bool Cliked=false;

public bool Active=false;

public Button(Vector2 position, int width, int height,Texture2D Active_texture,Texture2D Passive_texture,SpriteBatch SB )

{

B_rectangle = new Rectangle((int)position.X, (int)position.Y, width, height);

ActiveTex = Active_texture;

PassiveTex = Passive_texture;

spriteBatch = SB;

}

public void Update()

{

previousMouseState = currentMouseState;

currentMouseState = Mouse.GetState();

Active = false;

Cliked = false;

if (B_rectangle.Contains(currentMouseState.X, currentMouseState.Y))

{

Active = true;

if ((currentMouseState.LeftButton == ButtonState.Released) && (previousMouseState.LeftButton == ButtonState.Pressed))

Cliked = true;

}

}

public void Draw()

{

spriteBatch.Begin();

if(Active==true)

spriteBatch.Draw(ActiveTex, B_rectangle, Color.White);

if (Active == false)

spriteBatch.Draw(PassiveTex, B_rectangle, Color.White);

spriteBatch.End();

}

}

}

Вихідний код модуля CloudsParticle.cs

#region Using Statements

using System;

using System.Collections.Generic;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Content;

#endregion

namespace DPSF.ParticleSystems

{

#if (WINDOWS)

[Serializable]

#endif

class CloudsParticle : DefaultTexturedQuadParticleSystem

{

public CloudsParticle(Game cGame) : base(cGame) { }

{

InitializeTexturedQuadParticleSystem(cGraphicsDevice, cContentManager, 100, 500,

UpdateVertexProperties, @"Textures\Particle\PlayerParticle");

Name = "Default Textured Quad Particle System Template";

LoadParticleSystem();

}

public void LoadParticleSystem()

{

ParticleInitializationFunction = InitializeParticleUsingInitialProperties;

InitialProperties.LifetimeMin = 3.0f;

InitialProperties.LifetimeMax = 3.0f;

InitialProperties.PositionMin = new Vector3(250, 250, 250);

InitialProperties.PositionMax = new Vector3(-250, -250, -250);

InitialProperties.VelocityMin = new Vector3(300, 300, 300);

InitialProperties.VelocityMax = new Vector3(-300, -300, -300);

InitialProperties.RotationMin = new Vector3(0, 0, 0);

InitialProperties.RotationMax = new Vector3(0, 0, MathHelper.Pi);

InitialProperties.RotationalVelocityMin = new Vector3(0, 0, 0);

InitialProperties.RotationalVelocityMax = new Vector3(0, 0, 0);

InitialProperties.StartWidthMin = 1;

InitialProperties.StartWidthMax = 1;

InitialProperties.StartHeightMin = 1;

InitialProperties.StartHeightMax = 1;

InitialProperties.EndWidthMin = 5;

InitialProperties.EndWidthMax = 5;

InitialProperties.EndHeightMin = 5;

InitialProperties.EndHeightMax = 5;

InitialProperties.StartColorMin = Color.Yellow;

InitialProperties.StartColorMax = Color.Yellow;

InitialProperties.EndColorMin = Color.Yellow;

InitialProperties.EndColorMax = Color.Yellow;

ParticleEvents.RemoveAllEvents();

ParticleSystemEvents.RemoveAllEvents();

ParticleEvents.AddEveryTimeEvent(UpdateParticlePositionUsingVelocity);

ParticleEvents.AddEveryTimeEvent(UpdateParticleRotationUsingRotationalVelocity);

ParticleEvents.AddEveryTimeEvent(UpdateParticleWidthAndHeightUsingLerp);

ParticleEvents.AddEveryTimeEvent(UpdateParticleColorUsingLerp);

ParticleEvents.AddEveryTimeEvent(UpdateParticleTransparencyToFadeOutUsingLerp, 100);

ParticleEvents.AddEveryTimeEvent(UpdateParticleToFaceTheCamera, 200);

ParticleSystemEvents.LifetimeData.EndOfLifeOption = CParticleSystemEvents.EParticleSystemEndOfLifeOptions.Repeat;

ParticleSystemEvents.LifetimeData.Lifetime = 1.0f;

ParticleSystemEvents.AddTimedEvent(0.0f, UpdateParticleSystemEmitParticlesAutomaticallyOn);

ParticleSystemEvents.AddTimedEvent(1.0f, UpdateParticleSystemEmitParticlesAutomaticallyOff);

Emitter.ParticlesPerSecond = 100;

Emitter.PositionData.Position = new Vector3(0, 0, 0);

SimulationSpeed = 0.2f;

}

public void InitializeParticleProperties(DefaultTexturedQuadParticle cParticle)

{

cParticle.Lifetime = 3.0f;

Vector3 sVelocityMin = new Vector3(-50, 50, -50);

Vector3 sVelocityMax = new Vector3(50, 100, 50);

cParticle.Velocity = DPSFHelper.RandomVectorBetweenTwoVectors(sVelocityMin, sVelocityMax);

cParticle.Velocity = Vector3.Transform(cParticle.Velocity, Emitter.OrientationData.Orientation);

cParticle.Width = cParticle.StartWidth = cParticle.EndWidth =

cParticle.Height = cParticle.StartHeight = cParticle.EndHeight = RandomNumber.Next(10, 50);

cParticle.Color = cParticle.StartColor = cParticle.EndColor = DPSFHelper.RandomColor();

}

protected void UpdateParticleFunctionExample(DefaultTexturedQuadParticle cParticle, float fElapsedTimeInSeconds)

{

}

protected void UpdateParticleSystemFunctionExample(float fElapsedTimeInSeconds)

{

}

}

}

Вихідний код модуля PlayerParticle.cs

#region Using Statements

using System;

using System.Collections.Generic;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Content;

#endregion

namespace DPSF.ParticleSystems

{

#if (WINDOWS)

[Serializable]

#endif

class CloudsParticle : DefaultTexturedQuadParticleSystem

{

public CloudsParticle(Game cGame) : base(cGame) { }

public override void AutoInitialize(GraphicsDevice cGraphicsDevice, ContentManager cContentManager, SpriteBatch cSpriteBatch)

{

InitializeTexturedQuadParticleSystem(cGraphicsDevice, cContentManager, 100, 500,

UpdateVertexProperties, @"Textures\Particle\PlayerParticle");

Name = "Default Textured Quad Particle System Template";

LoadParticleSystem();

}

public void LoadParticleSystem()

{

ParticleInitializationFunction = InitializeParticleUsingInitialProperties;

InitialProperties.LifetimeMin = 3.0f;

InitialProperties.LifetimeMax = 3.0f;

InitialProperties.PositionMin = new Vector3(250, 250, 250);

InitialProperties.PositionMax = new Vector3(-250, -250, -250);

InitialProperties.VelocityMin = new Vector3(300, 300, 300);

InitialProperties.VelocityMax = new Vector3(-300, -300, -300);

InitialProperties.RotationMin = new Vector3(0, 0, 0);

InitialProperties.RotationMax = new Vector3(0, 0, MathHelper.Pi);

InitialProperties.RotationalVelocityMin = new Vector3(0, 0, 0);

InitialProperties.RotationalVelocityMax = new Vector3(0, 0, 0);

InitialProperties.StartWidthMin = 1;

InitialProperties.StartWidthMax = 1;

InitialProperties.StartHeightMin = 1;

InitialProperties.StartHeightMax = 1;

InitialProperties.EndWidthMin = 5;

InitialProperties.EndWidthMax = 5;

InitialProperties.EndHeightMin = 5;

InitialProperties.EndHeightMax = 5;

InitialProperties.StartColorMin = Color.Yellow;

InitialProperties.StartColorMax = Color.Yellow;

InitialProperties.EndColorMin = Color.Yellow;

InitialProperties.EndColorMax = Color.Yellow;

ParticleEvents.RemoveAllEvents();

ParticleSystemEvents.RemoveAllEvents();

ParticleEvents.AddEveryTimeEvent(UpdateParticlePositionUsingVelocity);

ParticleEvents.AddEveryTimeEvent(UpdateParticleRotationUsingRotationalVelocity);

ParticleEvents.AddEveryTimeEvent(UpdateParticleWidthAndHeightUsingLerp);

ParticleEvents.AddEveryTimeEvent(UpdateParticleColorUsingLerp);

ParticleEvents.AddEveryTimeEvent(UpdateParticleTransparencyToFadeOutUsingLerp, 100);

ParticleEvents.AddEveryTimeEvent(UpdateParticleToFaceTheCamera, 200);

ParticleSystemEvents.LifetimeData.EndOfLifeOption = CParticleSystemEvents.EParticleSystemEndOfLifeOptions.Repeat;

ParticleSystemEvents.LifetimeData.Lifetime = 1.0f;

ParticleSystemEvents.AddTimedEvent(0.0f, UpdateParticleSystemEmitParticlesAutomaticallyOn);

ParticleSystemEvents.AddTimedEvent(1.0f, UpdateParticleSystemEmitParticlesAutomaticallyOff);

Emitter.ParticlesPerSecond = 100;

Emitter.PositionData.Position = new Vector3(0, 0, 0);

SimulationSpeed = 0.2f;}

public void InitializeParticleProperties(DefaultTexturedQuadParticle cParticle)

{

cParticle.Lifetime = 3.0f;

cParticle.Position = Emitter.PositionData.Position;

Vector3 sVelocityMin = new Vector3(-50, 50, -50);

Vector3 sVelocityMax = new Vector3(50, 100, 50);

cParticle.Velocity = DPSFHelper.RandomVectorBetweenTwoVectors(sVelocityMin, sVelocityMax);

cParticle.Velocity = Vector3.Transform(cParticle.Velocity, Emitter.OrientationData.Orientation);

cParticle.Width = cParticle.StartWidth = cParticle.EndWidth =

cParticle.Height = cParticle.StartHeight = cParticle.EndHeight = RandomNumber.Next(10, 50);

cParticle.Color = cParticle.StartColor = cParticle.EndColor = DPSFHelper.RandomColor();

}

protected void UpdateParticleFunctionExample(DefaultTexturedQuadParticle cParticle, float fElapsedTimeInSeconds)

{}

protected void UpdateParticleSystemFunctionExample(float fElapsedTimeInSeconds)

{}

}

}

Додаток А.18 Вихідний код модуля ExplosionParticle.cs

#region Using Statements

using System;

using System.Collections.Generic;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Content;

#endregion

namespace DPSF.ParticleSystems

{

#if (WINDOWS)

[Serializable]

#endif

public class ExplosionParticle : DefaultTexturedQuadParticleSystem

{

public ExplosionParticle(Game cGame) : base(cGame) { }

public override void AutoInitialize(GraphicsDevice cGraphicsDevice, ContentManager cContentManager, SpriteBatch cSpriteBatch)

{

InitializeTexturedQuadParticleSystem(cGraphicsDevice, cContentManager, 3000, 7000,

UpdateVertexProperties, @"Textures\Particle\PlayerParticle");

Name = "Default Textured Quad Particle System Template";

LoadParticleSystem();

}

public void LoadParticleSystem()

{

ParticleInitializationFunction = InitializeParticleUsingInitialProperties;

InitialProperties.LifetimeMin = 1.0f;

InitialProperties.LifetimeMax = 1.0f;

InitialProperties.PositionMin = new Vector3(1, 1, 1);

InitialProperties.PositionMax = new Vector3(-1, -1, -1);

InitialProperties.VelocityMin = new Vector3(50, 50, 50);

InitialProperties.VelocityMax = new Vector3(-50, -50, -50);

InitialProperties.RotationMin = new Vector3(0, 0, 0);

InitialProperties.RotationMax = new Vector3(0, 0, 0);

InitialProperties.RotationalVelocityMin = new Vector3(0, 0, 0);

InitialProperties.RotationalVelocityMax = new Vector3(0, 0, 0);

InitialProperties.StartWidthMin = 10;

InitialProperties.StartWidthMax = 15;

InitialProperties.StartHeightMin = 10;

InitialProperties.StartHeightMax = 15;

InitialProperties.EndWidthMin = 15;

InitialProperties.EndWidthMax = 15;

InitialProperties.EndHeightMin = 15;

InitialProperties.EndHeightMax = 15;

InitialProperties.StartColorMin = Color.Orange;

InitialProperties.StartColorMax = Color.Red;

InitialProperties.EndColorMin = Color.Orange;

InitialProperties.EndColorMax = Color.Red;

ParticleEvents.RemoveAllEvents();

ParticleSystemEvents.RemoveAllEvents();

ParticleEvents.AddEveryTimeEvent(UpdateParticlePositionUsingVelocity);

ParticleEvents.AddEveryTimeEvent(UpdateParticleRotationUsingRotationalVelocity);

ParticleEvents.AddEveryTimeEvent(UpdateParticleWidthAndHeightUsingLerp);

ParticleEvents.AddEveryTimeEvent(UpdateParticleColorUsingLerp);

ParticleEvents.AddEveryTimeEvent(UpdateParticleTransparencyToFadeOutUsingLerp, 100);

ParticleEvents.AddEveryTimeEvent(UpdateParticleToFaceTheCamera, 200);

ParticleSystemEvents.LifetimeData.EndOfLifeOption = CParticleSystemEvents.EParticleSystemEndOfLifeOptions.Repeat;

ParticleSystemEvents.LifetimeData.Lifetime = 1.0f;

ParticleSystemEvents.AddTimedEvent(0.0f, UpdateParticleSystemEmitParticlesAutomaticallyOn);

ParticleSystemEvents.AddTimedEvent(1.0f, UpdateParticleSystemEmitParticlesAutomaticallyOff);

SimulationSpeed = 0.4f;

Emitter.ParticlesPerSecond = 1000;

Emitter.PositionData.Position = new Vector3(0, 0, 0);

}

public void InitializeParticleProperties(DefaultTexturedQuadParticle cParticle)

{

cParticle.Velocity = Vector3.Transform(cParticle.Velocity, Emitter.OrientationData.Orientation);

cParticle.Width = cParticle.StartWidth = cParticle.EndWidth =

cParticle.Height = cParticle.StartHeight = cParticle.EndHeight = RandomNumber.Next(10, 50);

cParticle.Color = cParticle.StartColor = cParticle.EndColor = DPSFHelper.RandomColor();

}

protected void UpdateParticleFunctionExample(DefaultTexturedQuadParticle cParticle, float fElapsedTimeInSeconds)

{}

protected void UpdateParticleSystemFunctionExample(float fElapsedTimeInSeconds)

{}

}

}

Вихідний код модуля GaussianBlur.fx

sampler2D tex[1];

float2 Offsets[15];

float Weights[15];

float4 PixelShaderFunction(float4 Position : POSITION0,

float2 UV : TEXCOORD0) : COLOR0

{

float4 output = float4(0, 0, 0, 1);

for (int i = 0; i < 15; i++)

output += tex2D(tex[0], UV + Offsets[i]) * Weights[i];

return output;

}

technique Technique1

{

pass p0

{

PixelShader = compile ps_2_0 PixelShaderFunction();

}

}

Вихідний код модуля GlowEffect.fx

sampler2D tex[1];

float4 PixelShaderFunction(float4 Position : POSITION0,

float2 UV : TEXCOORD0) : COLOR0

{ float3 luminance = float3(0.299, 0.587, 0.114);

float4 color = tex2D(tex[0], UV);

float intensity = dot(color, luminance);

if (intensity < 0.1)

return float4(0,0,0,1);

else

return color;

}

technique Technique1

{

pass Pass1

{

PixelShader = compile ps_2_0 PixelShaderFunction();

}

}

Вихідний код модуля Texture.fx

float4x4 World;

float4x4 View;

float4x4 Projection;

Texture Tex;

sampler mySampler = sampler_state

{

Texture = <Tex>;

};

struct VertexShaderInput

{

float4 Position : POSITION0;

float4 TexCoords : TEXCOORD0;

};

struct VertexShaderOutput

{

float4 Position : POSITION0;

float4 TexCoords : TEXCOORD0;

};

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)

{

VertexShaderOutput output;

float4 worldPosition = mul(input.Position, World);

float4 viewPosition = mul(worldPosition, View);

output.Position = mul(viewPosition, Projection);

output.TexCoords = input.TexCoords;

return output;

}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0

{

return

tex2D(mySampler, input.TexCoords);

}

technique Technique1

{

pass Pass1

{

VertexShader = compile

vs_2_0 VertexShaderFunction();

PixelShader = compile

ps_2_0 PixelShaderFunction();

}

Вихідний код модуля TextureGreen.fx

float4x4 World;

float4x4 View;

float4x4 Projection;

Texture Tex;

sampler mySampler = sampler_state

{

Texture = <Tex>;

};

struct VertexShaderInput

{

float4 Position : POSITION0;

float4 TexCoords : TEXCOORD0;

};

struct VertexShaderOutput

{

float4 Position : POSITION0;

float4 TexCoords : TEXCOORD0;

};

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)

{

VertexShaderOutput output;

float4 worldPosition = mul(input.Position, World);

float4 viewPosition = mul(worldPosition, View);

output.Position = mul(viewPosition, Projection);

output.TexCoords = input.TexCoords;

return output;

}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0

{

float4 color = tex2D(mySampler, input.TexCoords);

if((color.b<1)&&(color.r<0.6)&&(color.g<0.6))

{color=color+float4(-0.5,1,-0.5,0);}

return color;

}

technique Technique1

{

pass Pass1

{

VertexShader = compile

vs_2_0 VertexShaderFunction();

PixelShader = compile

ps_2_0 PixelShaderFunction();

}

Вихідний код модуля TextureOrange.fx

float4x4 World;

float4x4 View;

float4x4 Projection;

Texture Tex;

sampler mySampler = sampler_state

{

Texture = <Tex>;

};

struct VertexShaderInput

{

float4 Position : POSITION0;

float4 TexCoords : TEXCOORD0;

};

struct VertexShaderOutput

{

float4 Position : POSITION0;

float4 TexCoords : TEXCOORD0;

};

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)

{

VertexShaderOutput output;

float4 worldPosition = mul(input.Position, World);

float4 viewPosition = mul(worldPosition, View);

output.Position = mul(viewPosition, Projection);

output.TexCoords = input.TexCoords;

return output;

}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0

{

float4 color = tex2D(mySampler, input.TexCoords);

if((color.b<1)&&(color.r<0.6)&&(color.g<0.6))

{color=color+float4(0.5,0,-1,0);}

return color;

}

technique Technique1

{

pass Pass1

{

VertexShader = compile

vs_2_0 VertexShaderFunction();

PixelShader = compile

ps_2_0 PixelShaderFunction();

}

Додаток А.24 Вихідний код модуля TextureRed.fx

float4x4 World;

float4x4 View;

float4x4 Projection;

Texture Tex;

sampler mySampler = sampler_state

{

Texture = <Tex>;

};

struct VertexShaderInput

{

float4 Position : POSITION0;

float4 TexCoords : TEXCOORD0;

};

struct VertexShaderOutput

{

float4 Position : POSITION0;

float4 TexCoords : TEXCOORD0;

};

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)

{

VertexShaderOutput output;

float4 worldPosition = mul(input.Position, World);

float4 viewPosition = mul(worldPosition, View);

output.Position = mul(viewPosition, Projection);

output.TexCoords = input.TexCoords;

return output;

}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0

{

float4 color = tex2D(mySampler, input.TexCoords);

if((color.b<1)&&(color.r<0.6)&&(color.g<0.6))

{color=color+float4(1,-0.5,-0.5,0);}

return color;

}

technique Technique1

{

pass Pass1

{

VertexShader = compile

vs_2_0 VertexShaderFunction();

PixelShader = compile

ps_2_0 PixelShaderFunction();

}

ДОДАТОК Б

Матеріли VIII Всеукраїнської студентської наукової конференції «Сучасні проблеми фізико-математичних наук та методики їх викладання»



Размещено на Allbest.ru