/// <summary>
/// Creates a New InstanceSet in the Instances Collection using the speciefied model. The Instance Set can be
/// retrieved by the Specified key.
/// </summary>
/// <param name="Key">Unique Key to use for this InstanceSet.</param>
/// <param name="model">The Model to be used in the InstanceSet.</param>
public virtual void CreateNewInstanceCollection(object Key, vxModel model)
{
InstanceSet instanceSet = new InstanceSet(vxEngine);
instanceSet.InstancedModel = model;
Instances.Add(Key, instanceSet);
}
public vxModel LoadBasicEffectModel(string PathToModel, ContentManager Content, Effect ShadowEffect, Effect UtilityEffect)
{
vxConsole.WriteVerboseLine(" Importing Basic Effect Model: " + PathToModel);
// Create the Model Object to return
vxModel newModel = new vxModel(Engine);
// Next Load in the Main Model.
newModel.ModelMain = Content.Load <Model>(PathToModel);
DoModelFileCheck(PathToModel, Content);
// Now load in the textures
newModel.LoadTextures(Content, PathToModel);
// Now load the shadow model.
newModel.ModelShadow = LoadShadowModel(PathToModel, Content, ShadowEffect);
// Now load the utility model.
newModel.ModelUtility = LoadUtilityModel(PathToModel, Content, UtilityEffect);
// Add a tag of the Path to the model for debuging
newModel.ModelMain.Tag = PathToModel;
return(newModel);
}
/// <summary>
/// SnapBox for allowing tracks to snap together
/// </summary>
/// <param name="vxEngine"></param>
public vxSnapBox(vxEngine vxEngine, vxModel SnapBoxModel, int Width, int Height, int Length)
: base(vxEngine, SnapBoxModel, Vector3.Zero)
{
EndLocalRotation = new Vector3(MathHelper.PiOver2, -MathHelper.PiOver4, MathHelper.PiOver4);
DoShadowMap = false;
HitBox = new Box(Vector3.Zero, Width, Height, Length);
Current3DScene.BEPUPhyicsSpace.Add(HitBox);
//PhysicsSkin_Main.CollisionRules.Personal = Physics.CollisionRuleManagement.CollisionRule.NoSolver;
HitBox.CollisionInformation.CollisionRules.Personal = Virtex.Lib.Vrtc.Physics.BEPU.CollisionRuleManagement.CollisionRule.NoSolver;
((vxSandboxGamePlay)Current3DScene).Items.Add(this);
}
/// <summary>
/// Base Entity Object for the vxEngine.
/// </summary>
/// <param name="vxEngine">The current instance of the vxEngine.</param>
/// <param name="EntityModel">The Entities Model to be used.</param>
/// <param name="StartPosition">The Start Position of the Entity.</param>
public vxEntity3D(vxEngine vxEngine, vxModel EntityModel, Vector3 StartPosition) : base(vxEngine)
{
World = Matrix.CreateRotationX(-MathHelper.PiOver2)
* Matrix.CreateTranslation(StartPosition);
//Set Model Data
this.vxModel = EntityModel;
//Set Position Data
this.Position = StartPosition;
InitShaders();
}
/// <summary>
/// Load Global Content
/// </summary>
/// <param name="content"></param>
public override void LoadGlobalContent(ContentManager content)
{
HasContentBeenLoaded = true;
GameVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
vxConsole.WriteLine("Loading Global Content...");
////////////////////////////////////////////////////////////////////////////////////////////
//Fonts
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//Images
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//Shaders
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//MODELS
////////////////////////////////////////////////////////////////////////////////////////////
Model_Items_ModelObjs = vxContentManager.LoadModel("Models/modelobjs/modelobjs");
Model_Items_WoodenCrate = vxContentManager.LoadModel("Models/items/wooden crate/wooden crate");
Model_Items_Concrete = vxContentManager.LoadModel("Models/concrete_cube/concrete_cube");
Model_Items_Teapot = vxContentManager.LoadModel("Models/teapot/teapot");
////////////////////////////////////////////////////////////////////////////////////////////
//Sounde Effects
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// Music
////////////////////////////////////////////////////////////////////////////////////////////
}
/// <summary>
/// Creates a New Instance of the Working Plane Class
/// </summary>
/// <param name="AssetPath"></param>
public vxWorkingPlane(vxEngine vxEngine, vxModel entityModel, Vector3 StartPosition)
: base(vxEngine, entityModel, StartPosition)
{
//Render even in debug mode
RenderEvenInDebug = true;
WrknPlane = new Plane(Vector3.Up, -Position.Y);
AlphaValue = 0.05f;
basicEffect = new BasicEffect(this.vxEngine.GraphicsDevice);
int size = 10000;
vertices = new List <VertexPositionColor>();
for (int i = -size; i < size + 1; i += 10)
{
Color color = i % 100 == 0 ? Color.White : Color.Gray * 1.5f;
vertices.Add(new VertexPositionColor(
new Vector3(i, 0, -size),
color
));
vertices.Add(new VertexPositionColor(
new Vector3(i, 0, size),
color
));
vertices.Add(new VertexPositionColor(
new Vector3(-size, 0, i),
color
));
vertices.Add(new VertexPositionColor(
new Vector3(size, 0, i),
color
));
}
}
public vxAlphaEntity3D(vxEngine Engine, vxModel model, Vector3 Pos) :
base(Engine, model, Pos)
{
Texture = Engine.Assets.Textures.Blank;
}
/// <summary>
/// Creates a New Instance of the Base Ship Class
/// </summary>
/// <param name="AssetPath"></param>
public Envrio(vxEngine vxEngine, vxModel entityModel, Vector3 StartPosition)
: base(vxEngine, entityModel, StartPosition)
{
//World = Matrix.CreateRotationX(-MathHelper.PiOver2);
}
/// <summary>
/// Initializes a new instance of the <see cref="Virtex.Lib.Vrtc.Core.Particles.vxParticle3D"/> class.
/// </summary>
/// <param name="vxEngine">Vx engine.</param>
/// <param name="model">Model.</param>
/// <param name="StartPosition">Start position.</param>
public vxParticle3D(vxEngine vxEngine, vxModel model, Vector3 StartPosition)
: base(vxEngine, model, StartPosition)
{
}
public vxAlphaEntity3D(vxEngine vxEngine, vxModel EntityModel, Vector3 StartPosition) :
base(vxEngine, EntityModel, StartPosition)
{
}
public vxSandboxEntity(vxEngine vxEngine, vxModel EntityModel, Vector3 StartPosition)
: base(vxEngine, EntityModel, StartPosition)
{
Properties = new List <vxSandboxEntityProperty>();
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
public override void LoadContent()
{
//Load Global Content First
if (vxEngine.HasContentBeenLoaded == false)
{
vxEngine.LoadGlobalContent(vxEngine.Game.Content);
}
InitialiseLevel();
d = new Envrio(vxEngine, vxEngine.vxContentManager.LoadModel("Models/courtyard/td_courtyard"), new Vector3(20, 0, 0));
//d = new Envrio(vxEngine, vxEngine.vxContentManager.LoadModel("Models/castle/mdl_castle"), new Vector3(20, 0, 0));
//d.NormalMap = vxEngine.Game.Content.Load<Texture2D>("Models/courtyard/crtyrd_bricks_nm");
//d.SpecularMap = vxEngine.Game.Content.Load<Texture2D>("Models/courtyard/crtyrd_bricks_sm");
d.SpecularIntensity = 1;
waterItems.Add(new vxWaterEntity(vxEngine, Vector3.Up, new Vector3(500, 1, 500)));
vxModel mod = vxEngine.vxContentManager.LoadModel("Models/cbe/cbe");
new Envrio(vxEngine, mod, new Vector3(-5, 5, 0));
//mod.SetTexturePackLevel(vxEnumQuality.Low);
//mod.SetTexturePackLevel(vxEnumQuality.High);
//mod.SetTexturePackLevel(vxEnumQuality.Ultra);
//mod.SetTexturePackLevel(vxEnumQuality.Medium);
//vxTexture2D newtexture = new vxTexture2D(vxEngine, "Models/cbe/Cube_dds");
int size = 100;
Box baseBox = new Box(new Vector3(0, -5, 0), size, 10, size);
BEPUPhyicsSpace.Add(baseBox);
///////////////////////////////////////////////////////////////////////
//Initialise Camera Code
///////////////////////////////////////////////////////////////////////
#region Set Up Camera
base.LoadContent();
Camera.CameraType = CameraType.Orbit;
Camera.OrbitTarget = new Vector3(0, 1.5f, 0);
//Camera.OrbitZoom = -375;
//
//Grabbers
//
grabber = new MotorizedGrabSpring();
BEPUPhyicsSpace.Add(grabber);
rayCastFilter = RayCastFilter;
IsPausable = false;
#endregion
int height = 3;
ConcreteCube cc = new ConcreteCube((GameEngine)vxEngine, new Vector3(0, 5, 0));
cc.SetMesh(Matrix.CreateTranslation(new Vector3(0, height, 0)), true, true);
cc = new ConcreteCube((GameEngine)vxEngine, new Vector3(0, 5, 4f));
cc.SetMesh(Matrix.CreateTranslation(new Vector3(0, height, 5f)), true, true);
cc = new ConcreteCube((GameEngine)vxEngine, new Vector3(0, 5, 4f));
cc.SetMesh(Matrix.CreateTranslation(new Vector3(0, height, -5f)), true, true);
}
/// <summary>
/// Load your graphics content.
/// </summary>
protected override void LoadContent()
{
#if !DEBUG
try {
#endif
#if DEBUG
BuildConfigType = vxBuildConfigType.Debug;
#else
BuildConfigType = vxBuildConfigType.Release;
#endif
vxConsole.WriteLine("");
vxConsole.WriteLine("");
vxConsole.WriteLine("");
vxConsole.WriteLine("Starting Vertices Engine");
vxEnviroment.Initialize(this);
vxConsole.WriteLine("Checking Directories");
//The Android System uses the Isolated Storage for it's GameSaves
#if VRTC_PLTFRM_DROID
IsolatedStorageFile isoStore = IsolatedStorageFile.GetStore(IsolatedStorageScope.User |
IsolatedStorageScope.Assembly, null, null);
string settings = vxEnviroment.GetVar(vxEnumEnvVarType.PATH_SETTINGS).Value.ToString();
string sandbox = vxEnviroment.GetVar(vxEnumEnvVarType.PATH_SANDBOX).Value.ToString();
//First Check, if the Profiles Directory Doesn't Exist, Create It
if (isoStore.DirectoryExists(settings) == false)
{
isoStore.CreateDirectory(settings);
}
//First Check, if the Sandbox Directory Doesn't Exist, Create It
if (isoStore.DirectoryExists(sandbox) == false)
{
isoStore.CreateDirectory(sandbox);
}
//First Check, if the Temp Directory Doesn't Exist, Create It
if (isoStore.DirectoryExists("Temp/Settings") == false)
{
isoStore.CreateDirectory("Temp/Settings");
}
#else
string settings = vxEnviroment.GetVar(vxEnumEnvVarType.PATH_SETTINGS).Value.ToString();
string sandbox = vxEnviroment.GetVar(vxEnumEnvVarType.PATH_SANDBOX).Value.ToString();
//First Check, if the Profiles Directory Doesn't Exist, Create It
if (Directory.Exists(settings) == false)
{
Directory.CreateDirectory(settings);
}
//First Check, if the Sandbox Directory Doesn't Exist, Create It
if (Directory.Exists(sandbox) == false)
{
Directory.CreateDirectory(sandbox);
}
//First Check, if the Temp Directory Doesn't Exist, Create It
if (Directory.Exists("Temp/Settings") == false)
{
Directory.CreateDirectory("Temp/Settings");
}
#endif
vxConsole.WriteLine("Starting Content Manager");
// Load content belonging to the screen manager.
ContentManager content = Game.Content;
EngineContentManager = new ContentManager(Game.Services);
// Initialise the Engine Speciality Content Manager.
vxContentManager = new vxContentManager(this);
//Set Location of Content Specific too Platform
EngineContentManager.RootDirectory = vxEnviroment.GetVar(vxEnumEnvVarType.PATH_ENGINE_CONTENT).Value.ToString();
#if VRTC_PLTFRM_DROID
Game.Activity.Window.AddFlags(WindowManagerFlags.Fullscreen);
Game.Activity.Window.ClearFlags(WindowManagerFlags.ForceNotFullscreen);
#endif
#if VIRTICES_2D
LineBatch = new vxLineBatch(GraphicsDevice);
AssetCreator = new vxAssetCreator2D(GraphicsDevice);
AssetCreator.LoadContent(_engineContentManager);
#endif
InputManager = new vxInputManager(this);
InputManager.LoadContent();
InputManager.ShowCursor = true;
SpriteBatch = new SpriteBatch(GraphicsDevice);
//Initialise vxEngine Assets
Assets = new vxInternalAssetManager(this);
vxGUITheme = new vxGUITheme(this);
vxGUITheme.Font = this.Assets.Fonts.MenuFont;
#region Initialise Debug Console
//Get the vxEngine Version through Reflection
EngineVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
// initialize the debug system with the game and the name of the font
// we want to use for the debugging
DebugSystem = vxDebugSystem.Initialize(this, "Fonts/font_debug");
DebugSystem.TimeRuler.ShowLog = true;
//Initialise the Debug Renderer
vxDebugShapeRenderer.Initialize(GraphicsDevice);
vxConsole.Initialize(this);
//Now Setup Settings Managers
GraphicsSettingsManager = new vxGraphicsSettingsManager(this);
#endregion
#if !VRTC_PLTFRM_DROID
Model_Sandbox_WorkingPlane = this.Assets.Models.UnitPlane;
#endif
#if VRTC_INCLDLIB_NET
InitialiseMasterServerConnection();
ServerManager = new vxNetworkServerManager(this, 14242);
ClientManager = new vxNetworkClientManager(this);
#endif
#region Load Base Language
Languages = new List <vxLanguagePackBase> ();
LoadLanguagePacks();
//Default is English
this.Language = Languages [0];
#endregion
#if VIRTICES_3D
//Initialise Renderer
Renderer = new vxRenderer(this);
Renderer.LoadContent();
#endif
//Load in Profile Data
Profile.LoadSettings(this);
//Once all items are Managers and Engine classes are intitalised, then apply any and all passed cmd line arguments
vxEnviroment.ApplyCommandLineArgs();
//Set Initial Graphics Settings
GraphicsSettingsManager.Apply();
// Tell each of the screens to load their content.
foreach (vxGameBaseScreen screen in screens)
{
screen.LoadContent();
}
#if !DEBUG
}
catch (Exception ex) {
vxCrashHandler.Init(this, ex);
}
#endif
}
/// <summary>
/// This Loads Models at Run time performing a number of functions. See remarks for full details.
/// </summary>
/// <remarks>
/// Model Loading
/// =============================
/// This loads a vxModel with a Specified Effect as well as applies the CascadeShadowEffect to
/// the vxModel's internal Shadow Model as well. XNA and potentially other back ends do not allow
/// multiple loading of the same asset, therefore if a Shadow Model.xnb is not found, then it is created
/// from a copy of the main model as 'mainmodelname_shdw.xnb'.
///
///
/// Texture Loading
/// =============================
/// Furthermore, Textures are loaded based off of the name of the model mesh name.
///
/// For Example
/// -------------
/// ModelMesh Name = "ship"
///
/// Then the content importer will look for textures under the following names:
///
/// Diffuse Texture: ship_dds
/// Normal Map: ship_nm
/// Specular Map: ship_sm
///
/// The path to each of these is saved in the vxModel as well too allow for reloading of
/// other resolution packs later on.
/// </remarks>
/// <returns>The model.</returns>
/// <param name="PathToModel">Path to model.</param>
/// <param name="Content">Content.</param>
/// <param name="EffectToSet">Effect to set.</param>
/// <param name="ShadowEffect">Shadow effect.</param>
/// <param name="UtilityEffect">Utility effect.</param>
public vxModel LoadModel(string PathToModel, ContentManager Content, Effect EffectToSet, Effect ShadowEffect, Effect UtilityEffect)
{
vxConsole.WriteVerboseLine(" Importing Model: " + PathToModel);
// Create the Model Object to return
vxModel newModel = new vxModel(Engine);
// Next Load in the Main Model.
newModel.ModelMain = Content.Load <Model>(PathToModel);
DoModelFileCheck(PathToModel, Content);
#region Main Model Loading
/*********************************************************************************/
// MAIN MODEL
/*********************************************************************************/
//
// Now Apply and Initialise the New Effect on the MainModel Object using the speceified Effect.
//
// Table mapping the original effects to our replacement versions.
Dictionary <Effect, Effect> effectMapping = new Dictionary <Effect, Effect>();
foreach (ModelMesh mesh in newModel.ModelMain.Meshes)
{
vxConsole.WriteVerboseLine(" Mesh Name: " + mesh.Name);
mesh.Tag = PathToModel;
// Scan over all the effects currently on the mesh.
foreach (Effect oldEffect in mesh.Effects)
{
// If we haven't already seen this effect...
if (!effectMapping.ContainsKey(oldEffect))
{
// Make a clone of our replacement effect. We can't just use
// it directly, because the same effect might need to be
// applied several times to different parts of the model using
// a different texture each time, so we need a fresh copy each
// time we want to set a different texture into it.
Effect newEffect = EffectToSet.Clone();
//First Load in the Texture packs based off of the mesh name
newModel.LoadTextures(Content, PathToModel);
if (newEffect.Parameters["TextureEnabled"] != null)
{
newEffect.Parameters["TextureEnabled"].SetValue(true);
}
if (newEffect.Parameters["IsSun"] != null)
{
newEffect.Parameters["IsSun"].SetValue(false);
}
Vector4[] ShadowSplitColors = new[] {
new Vector4(255, 0, 0, 255),
new Vector4(0, 255, 0, 255),
new Vector4(0, 0, 255, 255),
new Vector4(160, 32, 240, 255)
};
if (newEffect.Parameters["SplitColors"] != null)
{
newEffect.Parameters["SplitColors"].SetValue(ShadowSplitColors);
}
if (newEffect.Parameters["AlphaValue"] != null)
{
newEffect.Parameters["AlphaValue"].SetValue(1);
}
if (newEffect.Parameters["ShadowBrightness"] != null)
{
newEffect.Parameters["ShadowBrightness"].SetValue(0.25f);
}
if (newEffect.Parameters["LightDirection"] != null)
{
newEffect.Parameters["LightDirection"].SetValue(Vector3.Normalize(new Vector3(100, 130, 0)));
}
if (newEffect.Parameters["LightColor"] != null)
{
newEffect.Parameters["LightColor"].SetValue(new Vector4(0.8f, 0.8f, 0.8f, 1.0f));
}
if (newEffect.Parameters["AmbientLightColor"] != null)
{
newEffect.Parameters["AmbientLightColor"].SetValue(new Vector4(0.2f, 0.2f, 0.2f, 1.0f));
}
effectMapping.Add(oldEffect, newEffect);
}
}
// Now that we've found all the effects in use on this mesh,
// update it to use our new replacement versions.
foreach (ModelMeshPart meshPart in mesh.MeshParts)
{
meshPart.Effect = effectMapping[meshPart.Effect];
}
}
#endregion
// Now load the shadow model.
newModel.ModelShadow = LoadShadowModel(PathToModel, Content, ShadowEffect);
// Now load the utility model.
newModel.ModelUtility = LoadUtilityModel(PathToModel, Content, UtilityEffect);
// Add a tag of the Path to the model for debuging
newModel.ModelMain.Tag = PathToModel;
return(newModel);
}
