void CreateBases()
{
for (int i = 0; i < GameManager.NumTeams; i++)
{
// Load the texture and create a copy for the colored base
Texture2D baseTexture = File.Load <Texture2D>("Images/textures/base");
Color teamColor = (i == 0) ? ScenesCommunicationManager.TeamAColor : ScenesCommunicationManager.TeamBColor;
Texture2D coloredBase = Graphics.TextureTint(baseTexture, teamColor);
GameObject playerBase = new GameObject("base_" + i.ToString(), File.Load <Model>("Models/primitives/plane"));
playerBase.tag = ObjectTag.Base;
playerBase.transform.Scale(0.5f);
playerBase.transform.position = _basePositions[i] + 0.001f * Vector3.Up;
playerBase.material = new Material(coloredBase, true);
playerBase.AddComponent(new Base(i));
playerBase.AddComponent(new BaseParticles());
playerBase.AddComponent(new StaticRigidBody(shapeType: ShapeType.BoxUniform, pureCollider: true));
playerBase.AddComponent(new BaseParticles());
ElementManager.Instance.Add(playerBase.GetComponent <Base>());
// Model instanciation
ModelType modelType = (ModelType)Enum.Parse(typeof(ModelType), "base" + i, true);
playerBase.UseHardwareInstanciation = true;
playerBase.ModelType = modelType;
HardwareRendering.InitializeModel(modelType, playerBase.Model, playerBase.material);
HardwareRendering.AddInstance(modelType, playerBase);
}
}
void LoadBlenderBakedScene()
{
string level = "level" + GameManager.LvlScene;
Material insideMat = new Material(File.Load <Texture2D>("Images/textures/polygonHeist"), File.Load <Texture2D>("Images/lightmaps/" + level + "_inside"));
Material outsideMat = new Material(File.Load <Texture2D>("Images/textures/polygonCity"), File.Load <Texture2D>("Images/lightmaps/" + level + "_outside"));
Material groundMat = new Material(File.Load <Texture2D>("Images/textures/polygonHeist"));
HardwareRendering.InitializeModel(ModelType.InsideScene, File.Load <Model>("Models/scenes/" + level + "_inside"), insideMat);
HardwareRendering.InitializeModel(ModelType.OutsideScene, File.Load <Model>("Models/scenes/" + level + "_outside"), outsideMat);
HardwareRendering.InitializeModel(ModelType.Ground, File.Load <Model>("Models/elements/ground"), groundMat);
GameObject insideScene = new GameObject("insideScene", ModelType.InsideScene, true);
insideScene.tag = ObjectTag.Ground;
GameObject outsideScene = new GameObject("outside", ModelType.OutsideScene, true);
outsideScene.tag = ObjectTag.Ground;
GameObject infinitePlane = new GameObject("infinitePlane", ModelType.Ground, true);
infinitePlane.tag = ObjectTag.Ground;
infinitePlane.transform.Scale(1000);
infinitePlane.transform.position = new Vector3(0, -.1f, 0);
}
protected override void Update(GameTime gameTime)
{
if (/*GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed ||*/ Keyboard.GetState().IsKeyDown(Keys.Escape))
{
Exit();
}
base.Update(gameTime);
Time.Update(gameTime);
Input.Update();
Audio.Update();
SceneManager.Update(); // check for scene change (can remove later)
GameManager.Update();
foreach (GameObject go in GameObject.All)
{
go.Update();
}
foreach (GameObject go in GameObject.All)
{
go.LateUpdate();
}
PhysicsDrawer.Instance.Update(gameTime);
PhysicsManager.Instance.Update(gameTime);
// Instanciating
HardwareRendering.Update();
ParticleRendering.Update();
}
protected override void LoadContent()
{
_spriteBatch = new SpriteBatch(GraphicsDevice);
UserInterface.sB = _spriteBatch;
Graphics.Start();
HardwareRendering.Start();
ParticleRendering.Start();
//start other big components
Input.Start();
//load prefabs and scene
Prefabs.Start();
UserInterface.Start();
GameMode.Start();
SceneManager.Start();
SceneManager.LoadScene(loadMenu ? "LevelMenu" : "LevelGame");
Audio.Start();
PostProcessingManager.Instance.Start(_spriteBatch);
if (ShowFps)
{
_font = File.Load <SpriteFont>("Other/font/debug");
}
// add skybox
//Skybox.Start();
}
/// <summary>
/// Load the menu scene
/// </summary>
void MenuScene()
{
Material insideMat = new Material(File.Load <Texture2D>("Images/textures/polygonHeist"), File.Load <Texture2D>("Images/lightmaps/menu_inside"));
Material outsideMat = new Material(File.Load <Texture2D>("Images/textures/polygonCity"), File.Load <Texture2D>("Images/lightmaps/menu_outside"));
Material groundMat = new Material(File.Load <Texture2D>("Images/textures/polygonHeist"));
// Model instanciation -> not wokring with these models, but not to bad since we have not many models in the menu-level
HardwareRendering.InitializeModel(ModelType.InsideScene, File.Load <Model>("Models/scenes/menu_inside"), insideMat);
HardwareRendering.InitializeModel(ModelType.OutsideScene, File.Load <Model>("Models/scenes/menu_outside"), outsideMat);
HardwareRendering.InitializeModel(ModelType.Ground, File.Load <Model>("Models/elements/ground"), groundMat);
GameObject insideScene = new GameObject("menu_inside", ModelType.InsideScene, true);
insideScene.tag = ObjectTag.Ground;
GameObject outsideScene = new GameObject("menu_outside", ModelType.OutsideScene, true);
outsideScene.tag = ObjectTag.Ground;
GameObject infinitePlane = new GameObject("infinitePlane", ModelType.Ground, true);
infinitePlane.tag = ObjectTag.Ground;
infinitePlane.transform.Scale(1000);
infinitePlane.transform.position = new Vector3(0, -5.0f, 0);
}
private static void InitializeHardwareInstancing()
{
//-------------------MATERIALS-------------------
Material powerupMat = new Material(File.Load <Texture2D>("Images/textures/powerups"));
Material shadowMat = new Material(File.Load <Texture2D>("Images/textures/shadow"), true);
Material lightPlayerMat = new Material(File.Load <Texture2D>("Images/textures/player_light"), true, true);
Material lightBlueMat = new Material(File.Load <Texture2D>("Images/textures/police_blue"), true, true);
Material lightRedMat = new Material(File.Load <Texture2D>("Images/textures/police_red"), true, true);
Material carTrackOilMat = new Material(File.Load <Texture2D>("Images/particles3d/tracks_oil"), true, true)
{
RenderingType = RenderingType.TextureAlpha
};
Material carTrackSpeedMat = new Material(File.Load <Texture2D>("Images/particles3d/tracks_speed"), true, true)
{
RenderingType = RenderingType.TextureAlpha
};
Material elementsMat = new Material(File.Load <Texture2D>("Images/textures/polygonHeist"), File.Load <Texture2D>("Images/lightmaps/elements"));
Material policeMat = new Material(File.Load <Texture2D>("Images/textures/Vehicle_Police"), File.Load <Texture2D>("Images/lightmaps/elements"));
Material playerMat = new Material(File.Load <Texture2D>("Images/textures/player_colors_p1"), File.Load <Texture2D>("Images/lightmaps/elements"));
// Initialize the models for hardware instanciating
HardwareRendering.InitializeModel(ModelType.Cash, File.Load <Model>("Models/elements/cash"), elementsMat);
HardwareRendering.InitializeModel(ModelType.Gold, File.Load <Model>("Models/elements/gold"), powerupMat);
HardwareRendering.InitializeModel(ModelType.Diamond, File.Load <Model>("Models/elements/diamond"), powerupMat);
HardwareRendering.InitializeModel(ModelType.Police, File.Load <Model>("Models/vehicles/police_chassis"), policeMat);
HardwareRendering.InitializeModel(ModelType.Crate, File.Load <Model>("Models/elements/crate"), powerupMat);
HardwareRendering.InitializeModel(ModelType.Oil, File.Load <Model>("Models/elements/oil"), elementsMat);
HardwareRendering.InitializeModel(ModelType.Bomb, File.Load <Model>("Models/powerups/bomb"), powerupMat);
HardwareRendering.InitializeModel(ModelType.Weight, File.Load <Model>("Models/powerups/weight"), powerupMat);
HardwareRendering.InitializeModel(ModelType.Magnet, File.Load <Model>("Models/powerups/magnet"), powerupMat);
HardwareRendering.InitializeModel(ModelType.Speedpad, File.Load <Model>("Models/elements/speedpad"), elementsMat);
HardwareRendering.InitializeModel(ModelType.Stack, File.Load <Model>("Models/elements/stack"), elementsMat);
HardwareRendering.InitializeModel(ModelType.Shadow, File.Load <Model>("Models/primitives/plane"), shadowMat);
HardwareRendering.InitializeModel(ModelType.YellowLight, File.Load <Model>("Models/primitives/plane"), lightPlayerMat);
HardwareRendering.InitializeModel(ModelType.BlueLight, File.Load <Model>("Models/primitives/plane"), lightBlueMat);
HardwareRendering.InitializeModel(ModelType.RedLight, File.Load <Model>("Models/primitives/plane"), lightRedMat);
HardwareRendering.InitializeModel(ModelType.TracksOil, File.Load <Model>("Models/primitives/plane"), carTrackOilMat);
HardwareRendering.InitializeModel(ModelType.TracksSpeed, File.Load <Model>("Models/primitives/plane"), carTrackSpeedMat);
HardwareRendering.InitializeModel(ModelType.WheelFl, File.Load <Model>("Models/vehicles/wheel_fl"), playerMat);
HardwareRendering.InitializeModel(ModelType.WheelBz, File.Load <Model>("Models/vehicles/wheel_bz"), playerMat);
HardwareRendering.InitializeModel(ModelType.WheelPolice, File.Load <Model>("Models/vehicles/wheel_police"), policeMat);
HardwareRendering.InitializeModel(ModelType.Vault, File.Load <Model>("Models/elements/vault"), elementsMat);
HardwareRendering.InitializeModel(ModelType.ArrowBase, File.Load <Model>("Models/elements/arrow_green"), elementsMat);
HardwareRendering.InitializeModel(ModelType.ArrowEnemy, File.Load <Model>("Models/elements/arrow_red"), elementsMat);
for (int i = 0; i < powerupName.Length; i++)
{
ModelType modelType = (ModelType)Enum.Parse(typeof(ModelType), powerupName[i], true);
HardwareRendering.InitializeModel(modelType, File.Load <Model>("Models/powerups/" + powerupName[i]), powerupMat);
}
foreach (string s in dynamicElements)
{
ModelType modelType = (ModelType)Enum.Parse(typeof(ModelType), s, true);
HardwareRendering.InitializeModel(modelType, File.Load <Model>("Models/elements/" + s), elementsMat);
}
}
void CreateSkybox()
{
bool useRandomSkybox = true;
string[] skyboxTextures = { "daybreak", "midday", "evening", "sunset", "midnight", };
string skyTexture = useRandomSkybox ? skyboxTextures[MyRandom.Range(0, 5)] : "midday";
Material skyboxMat = new Material(File.Load <Texture2D>("Images/skyboxes/" + skyTexture));
// Hardware instancing
HardwareRendering.InitializeModel(ModelType.Skybox, File.Load <Model>("Models/elements/skybox"), skyboxMat);
// Visible skybox to render normaly
GameObject skybox = new GameObject("skybox", ModelType.Skybox, true);
skybox.transform.Scale(2); // not more than this or it will be culled
skybox.material = skyboxMat;
}
/// <summary>
/// This constructor is ONLY for the use of hardware instanciation..
/// </summary>
/// <param name="name"></param>
/// <param name="modelType"></param>
/// <param name="addToDrawings">True if the model is drawn, false if not.</param>
public GameObject(string name, ModelType modelType, bool addToDrawings)
{
Debug.Assert(!NameExists(name), "Name " + name + " must be unique!");
this.name = name;
DrawOrder = 0;
transform = new Transform();
components = new List <IComponent>();
AddGameObject(this);
UseHardwareInstanciation = true;
ModelType = modelType;
if (addToDrawings)
{
HardwareRendering.AddInstance(modelType, this);
}
}
public virtual object Clone()
{
int counter = 0;
lock (LockCounter) {
counter = InstanceCount++;
}
string newName = name + "_clone_" + counter;
GameObject newObject;
if (UseHardwareInstanciation)
{
newObject = new GameObject(newName, ModelType, true);
}
else
{
newObject = new GameObject(newName);
newObject.Model = Model;
newObject.material = material?.Clone();
}
newObject.UseHardwareInstanciation = UseHardwareInstanciation;
newObject.ModelType = ModelType;
newObject.Alpha = Alpha;
newObject.transform.CopyFrom(this.transform);
newObject.tag = tag;
newObject.active = true;
foreach (IComponent c in this.components)
{
newObject.AddComponent((IComponent)c.Clone());
}
// Instanciating
if (Model != null && UseHardwareInstanciation)
{
HardwareRendering.AddInstance(ModelType, newObject);
}
return(newObject);
}
public static void LoadScene(string sceneName, int sceneId = 1)
{
// Disable the physics-manager when loading the scene to avoid inconsistency between collision-handlings and loading
PhysicsManager.Instance.IsActive = false;
//GameManager.LvlScene = sceneId;
GameObject.ClearAll();
HardwareRendering.Reset();
ParticleRendering.Reset();
currentScene = scenes[sceneName];
Screen.SetupViewportsAndCameras(Graphics.gDM, currentScene.GetNumCameras());
if (currentScene != null)
{
currentScene.Load();
}
StartScene();
// Enable the physics-manager after all is loaded and positioned
PhysicsManager.Instance.IsActive = true;
}
public static void Destroy(GameObject o)
{
if (o == null)
{
return;
}
o.active = false;
// Instanciating
if (o.Model != null)
{
HardwareRendering.RemoveInstance(o.ModelType, o);
}
//if (o.HasComponent<RigidBodyComponent>()) RigidBodyComponent.allcolliders.Remove(o.GetComponent<RigidBodyComponent>()); // to avoid increase in colliders
RemoveGameObject(o);
//TODO free up memory
foreach (Component c in o.components)
{
c.Destroy();
}
}
void CreatePlayers()
{
//Material playerMat = new Material(File.Load<Texture2D>("Images/textures/player_colors"), File.Load<Texture2D>("Images/lightmaps/elements"));
for (int i = 0; i < GameManager.NumPlayers; i++)
{
Vector3 startPos = _startPositions[i];
GameObject player = new GameObject("player_" + i.ToString(), File.Load <Model>("Models/vehicles/forklift"));
player.tag = ObjectTag.Player;
player.transform.position = startPos;
player.material = new Material(File.Load <Texture2D>("Images/textures/player_colors_p" + (i + 1).ToString()), File.Load <Texture2D>("Images/lightmaps/elements"));
player.AddComponent(new Player(i, i % 2, startPos));
player.AddComponent(new MovingRigidBody());
//subcomponents
player.AddComponent(new PlayerAttack());
player.AddComponent(new PlayerInventory());
player.AddComponent(new PlayerMovement());
player.AddComponent(new PlayerParticles());
player.AddComponent(new PlayerPowerup());
player.AddComponent(new PlayerStamina());
player.AddComponent(new DynamicShadow());
player.AddComponent(new SpeechManager(i));
player.AddComponent(new TutorialUI(i));
// Modify player's name and model and color(choosen by user during menu)
if (MenuManager.Instance != null)
{
MenuManager.Instance.ChangeModelNameColorPlayer(player, i);
int modelIndex = 0;
if (ScenesCommunicationManager.Instance != null && ScenesCommunicationManager.Instance.PlayersInfo != null && ScenesCommunicationManager.Instance.PlayersInfo.ContainsKey("player_" + i))
{
modelIndex = ScenesCommunicationManager.Instance.PlayersInfo["player_" + i].Item2;
}
player.AddComponent(new FrontLight(FrontLight.Type.FrontAndBack, modelIndex));
player.AddComponent(new AnimatedWheels(AnimatedWheels.Type.BackOnly, 5, modelIndex));
}
else
{
player.AddComponent(new FrontLight(FrontLight.Type.FrontAndBack, 0));
player.AddComponent(new AnimatedWheels(AnimatedWheels.Type.BackOnly, 5, 0));
}
ElementManager.Instance.Add(player.GetComponent <Player>());
// Model instanciation
ModelType modelType = (ModelType)Enum.Parse(typeof(ModelType), "player" + i, true);
player.UseHardwareInstanciation = true;
player.ModelType = modelType;
HardwareRendering.InitializeModel(modelType, player.Model, player.material);
HardwareRendering.AddInstance(modelType, player);
//ARROWS
//arrow for base
GameObject arrow = new GameObject("arrow_" + i, ModelType.ArrowBase, true);
arrow.AddComponent(new Arrow(player, false, i, player.GetComponent <PlayerInventory>().IsAlmostFull));
arrow.transform.Scale(.6f);
//arrow for enemy
if (GameManager.NumPlayers > 1)
{
GameObject arrow2 = new GameObject("arrow2_" + i, ModelType.ArrowEnemy, true);
arrow2.AddComponent(new Arrow(player, true, i, () => true));
arrow2.transform.Scale(.3f);
}
}
}
protected override void Draw(GameTime gameTime)
{
// render scene for real
GraphicsDevice.SetRenderTarget(PostProcessingManager.SceneTarget);
GraphicsDevice.Clear(Graphics.SkyBlue);
base.Draw(gameTime);
_graphics.PreferMultiSampling = true;
//-----3D-----
GraphicsDevice.DepthStencilState = DepthStencilState.Default; // new DepthStencilState() { DepthBufferEnable = true }; // activates z buffer
HardwareRendering.Draw();
ParticleRendering.Draw();
if (PhysicsDrawer.Instance.DoDrawings)
{
foreach (Camera cam in Screen.Cameras)
{
GraphicsDevice.Viewport = cam.Viewport;
// Allow physics drawing for debug-reasons (display boundingboxes etc..)
PhysicsDrawer.Instance.Draw(cam);
//gizmos
GraphicsDevice.RasterizerState = Screen._wireRasterizer;
Gizmos.DrawWire(cam);
GraphicsDevice.RasterizerState = Screen._fullRasterizer;
Gizmos.DrawFull(cam);
}
Gizmos.ClearOrders();
}
// draw everything 3D to get the depth info
_graphics.GraphicsDevice.SetRenderTarget(PostProcessingManager.DepthTarget);
_graphics.GraphicsDevice.Clear(Color.Black);
HardwareRendering.DrawDepth();
ParticleRendering.DrawDepth();
// apply post processing
PostProcessingManager.Instance.Draw(_spriteBatch);
// Drop the render target
GraphicsDevice.SetRenderTarget(null);
//-----2D-----
int i = 0;
foreach (Camera cam in Screen.Cameras)
{
GraphicsDevice.Viewport = cam.Viewport;
_spriteBatch.Begin();
if (showUI)
{
foreach (GameObject go in GameObject.All)
{
go.Draw2D(i);
}
}
_spriteBatch.End();
i++;
}
GraphicsDevice.Viewport = Screen.FullViewport;
if (showUI)
{
_spriteBatch.Begin();
foreach (GameObject go in GameObject.All)
{
go.Draw2D(-1);
}
_spriteBatch.End();
}
if (ShowFps)
{
try {
string text = string.Format(
"Frames per second: {0}/{1}\n" +
"Instances: {2}\n",
(1.0f / gameTime.ElapsedGameTime.TotalSeconds).ToString("0.00"),
(_frames++ / gameTime.TotalGameTime.TotalSeconds).ToString("0.00"),
GameObject.All.Length);
_spriteBatch.Begin();
_spriteBatch.DrawString(_font, text, new Vector2(65, 265), Color.Black);
_spriteBatch.DrawString(_font, text, new Vector2(64, 264), Color.White);
_spriteBatch.End();
} catch {
// Do nothing
}
}
}
