/// <summary>
/// Called once at startup.
/// </summary>
void Start()
{
meshManager = MeshManager.Instance;
voxManager = VoxelGridManager.Instance;
voxManager.updateStruct = updateVoxelStructure;
}
private void Initialize(ILevelControllerOptions options)
{
// Constructs all the in-level components, then stores the ones that'll be needed later in member variables.
// Done this way rather than directly initializing the member variables because this way if they're reordered,
// the compiler will complain if something's being constructed before its dependency.
var surface = GeodesicSphereFactory.Build(options);
var simulation = new SimulationController(surface, options);
var cameraController = new CameraController(options);
var meshManager = new MeshManager(surface);
var cursorTracker = new CursorTracker(cameraController.Camera, meshManager);
var fieldManipulator = new FieldManipulator(surface, cursorTracker, options);
var colorMapView = new ColorMapView(surface, meshManager.Mesh, options);
var particleMapView = new ParticleMapView(surface, options);
var rawValuesView = new RawValuesView(cursorTracker);
var timeDilationView = new TimeView(50, options.Timestep);
var latLongGridView = new LatLongGridView(options.Radius);
_simulationController = simulation;
_colorMapView = colorMapView;
_particleMapView = particleMapView;
_rawValuesView = rawValuesView;
_timeView = timeDilationView;
_latLongGridView = latLongGridView;
_cameraController = cameraController;
_cursorTracker = cursorTracker;
_fieldManipulator = fieldManipulator;
}
public static GameSaver gameSaver; //TODO rm
void Start()
{
IObjectCreator creator = new ObjectCreator();
IInputMamager inputMamager = new InputManager();
IObjectPublisher publisher = new ObjectPubisher(creator, inputMamager);
IMeshManager meshManager = new MeshManager(publisher);
IGameplayManager gameplayManager = new GameplayManager(meshManager);
var updateManagerHolder = new GameObject("UpdateManagerHolder");
updateManagerHolder.AddComponent <UpdateManager>();
updateManagerHolder.AddComponent <Corutinier>();
IUpdateManager updateManager = updateManagerHolder.GetComponent <UpdateManager>();
updateManager.AddSubscriber(gameplayManager);
inputMamager.AddSubscriber(gameplayManager);
ICorutinier corutinier = updateManagerHolder.GetComponent <Corutinier>();
gameSaver = new GameSaver(gameplayManager);
gameSaver.Restore();
//gameplayManager.FillMesh(Constants.HEIGHT-1);
//meshFiller.FillMesh();
}
public void InitializeTree(DirectoryInfo directory)
{
this.directory = directory;
meshManager = new MeshManager(numberOfMeshes, numberOfMeshLoadingJobs);
FileInfo index = directory.GetFiles("voxelIndex.json")[0];
StreamReader reader = new StreamReader(index.FullName);
string s = reader.ReadToEnd();
JSONNode json = JSON.Parse(s);
if (json.IsArray)
{
topNodes = new PointCloudNode[json.AsArray.Count];
for (int i = 0; i < json.AsArray.Count; i++)
{
topNodes[i] = PointCloudNode.AddNode(json.AsArray[i], this.directory, gameObject, this);
}
}
else
{
topNodes = new PointCloudNode[1];
topNodes[0] = PointCloudNode.AddNode(json, this.directory, gameObject, this);
}
if (moveCameraToCenter)
{
Camera.main.transform.position = topNodes[0].boundsInModelSpace.center;
}
System.GC.Collect(); //Garbage Collection
}
public Engine(IDevice device, IConfiguration configuration, IWindowHost host)
{
WindowHost = host;
//windowHost.Bind(this);
Configuration = configuration;
Device = new TheDevice(host, device, false);
Device.Initialize();
statsManager = new StatsManager();
entityManager = new EntityManager();
lightManager = new LightManager(this);
inputManager = new InputManager(this);
cameraManger = new CameraManager(this);
materialManager = new MaterialManager(this);
shaderManager = new ShaderManager(this);
meshManager = new MeshManager(this);
renderManager = new RenderManager(this);
textureManager = new TextureManager(this);
fontManager = new FontManager(this);
uiManager = new UIManager(this);
}
void GetReferences()
{
m_meshManager = FindObjectOfType <MeshManager>();
m_uvTool = FindObjectOfType <UVTool>();
m_buildingMenu = UICollection.instance.GetGameObject("Menu Building").GetComponent <UIBehaviour>();
m_uvMenu = UICollection.instance.GetGameObject("Menu UV").GetComponent <UIBehaviour>();
}
// Use this for initialization
void Start()
{
TextObj = TextContainer.GetComponent <TextMesh>();
Driver = EFPContainer.GetComponent <ExternalFeedDriver>();
MeshManagerObj = EFPContainer.GetComponent <MeshManager>();
GridManager = EFPContainer.GetComponent <VoxelGridManager>();
}
public ShootingTarget(Vector3 position, Vector3 rotation, ShootingTargetType type,
SoundEffect shotSFX, SoundEffect knockdownSFX)
{
isActive = true;
targetType = type;
this.shotSFX = shotSFX;
this.knockdownSFX = knockdownSFX;
sfxVolume = 0.75f;
slidingDirection = new Vector3(maxMovement, 0.0f, 0.0f);
shiftingDirection = new Vector3(0.0f, 0.0f, maxMovement);
initialPosition = position;
initialRotation = rotation;
animationSpeed = 3.0f;
runFallAnimation = false;
// Skew starting time for randomized animations
totalTime = (float)rand.NextDouble() * 10.0f;
// Load the target mesh
targetMesh = MeshManager.LoadMesh("target.m3d");
targetMesh.Position = position;
targetMesh.RotationAngles = rotation;
targetMesh.Scale = 3.0f;
}
private void InitializeTree(DirectoryInfo dir)
{
Stopwatch stopwatch = Stopwatch.StartNew();
this.directory = dir;
meshManager = new MeshManager(numberOfMeshes, numberOfMeshLoadingJobs);
JSONNode modelJSON = ReadJSON(this.directory, "pc_model.json");
JSONArray trees = modelJSON["nodes"].AsArray;
InitColorPalette(modelJSON["classes"].AsArray);
topNodes = new PCTree[trees.Count];
int i = 0;
foreach (JSONNode tree in trees)
{
Vector3 min = tree["min"].AsVector3();
Vector3 max = tree["max"].AsVector3();
PCTree t = new PCTree();
t.bounds = new Bounds((max + min) / 2, (max - min));
t.treeFile = tree["file"].ToString().Trim('"');
topNodes[i++] = t;
}
stopwatch.Stop();
UnityEngine.Debug.Log("PC Model Loaded in ms: " + stopwatch.ElapsedMilliseconds);
if (moveCameraToCenter)
{
Camera.main.transform.position = topNodes[0].bounds.center;
}
System.GC.Collect(); //Garbage Collection
}
public void MarkForRender(MeshManager mesh)
{
if (!_meshes.Contains(mesh))
{
_meshes.Add(mesh);
}
}
protected override void CreateScene()
{
((Overlay)OverlayManager.Instance.getByName("Gangsta/Demo/Target")).show();
Light l = mSceneManager.CreateLight("Light");
l.Position = new Math3D.Vector3(400, 500, 300);
l.SetSpecularColour(1.0f, 1.0f, 1.0f);
l.SetCastShadows(true);
mSceneManager.SetShadowTechnique(ShadowTechnique.ShadowTypeStencilModulative);
mSceneManager.SetShadowColour(Converter.GetColor(0.5f, 0.5f, 0.5f));
mSceneManager.SetAmbientLight(Converter.GetColor(0.5f, 0.5f, 0.5f));
mSceneManager.SetSkyBox(true, "Gangsta/Skybox/Io");
Plane plane = new Plane();
plane.Normal.x = 0.0f;
plane.Normal.y = 1.0f;
plane.Normal.z = 0.0f;
plane.D = 0.0f;
MeshPtr m = MeshManager.GetSingleton().CreatePlane("Plane_mesh", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME,
plane, 400.0f, 400.0f, 10, 10, true,
1, 16.0f, 16.0f, Vector3.NegativeUnitZ);
Entity e = mSceneManager.CreateEntity("Plane_entity", "Plane_mesh");
e.SetCastShadows(false);
e.SetMaterialName("Gangsta/Ground/Dust");
m.SetNull();
m = null;
SceneNode n = mSceneManager.GetRootSceneNode().CreateChildSceneNode("Plane_node");
n.AttachObject(e);
}
protected override void Awake()
{
base.Awake();
ObserverState = ObserverStates.Stopped;
if (Test)
{
// create dummy SurfaceObject
List <Vector3> testVerts = new List <Vector3>();
testVerts.Add(new Vector3(-0.5f, -0.5f, -0.5f));
testVerts.Add(new Vector3(0, 0, 0));
testVerts.Add(new Vector3(0.5f, 0.5f, 0.5f));
Mesh testMesh = new Mesh();
testMesh.SetVertices(testVerts);
SurfaceObject testSO = CreateSurfaceObject(testMesh, "test", gameObject.transform);
testSO.Renderer.transform.position = new Vector3(1, 1, 1);
// create matching dummy SurfacePoints
Transform tmpTransform = testSO.Renderer.transform;
List <Vector3> tmpWvertices = testSO.Filter.sharedMesh.vertices.ToList();
int tmpTriCount = testSO.Filter.sharedMesh.triangles.ToList().Count;
for (int i = 0; i < tmpWvertices.Count; i++)
{
tmpWvertices[i] = tmpTransform.TransformPoint(tmpWvertices[i]);
}
SurfacePoints extras = new SurfacePoints(
MeshManager.IntersectionPoints(testSO.Renderer.bounds), tmpWvertices,
tmpTriCount, testSO.Renderer.bounds);
// Log
UpdateOrAddSurfaceObject(testSO, extras);
}
}
protected virtual void Awake()
{
playerManager = GetComponent <PlayerManager>();
pointManager = GetComponent <LevelPoints>();
meshManager = GetComponent <MeshManager>();
arqdutManager = GetComponent <ArqdutManager>();
}
/// <summary>
/// Fully constructs this Tile. This includes creating a Mesh, painting
/// the terrain, and adding details (grass, objects, etc.)
///
/// By default, calculating heights is done off of the main thread but
/// can be disabled.
/// </summary>
/// <param name="onComplete">Called after all calculations have completed.
/// <see cref="onComplete"/>Can be null if the result is not needed.</param>
/// <param name="async">Perform mesh computation asynchronously</param>
public void Generate(Action onComplete, bool async = true)
{
//Cache current LOD
_lastGeneratedLodLevel = GetLodLevel();
MeshManager.LodLevel = _lastGeneratedLodLevel;
if (async)
{
MeshManager.CreateHeightmapAsync(() => {
MeshManager.CreateMesh();
PostCreateMeshGenerate();
if (onComplete != null)
{
onComplete();
}
});
}
else
{
MeshManager.CreateHeightmap();
MeshManager.CreateMesh();
PostCreateMeshGenerate();
if (onComplete != null)
{
onComplete();
}
}
}
private void OnEnable()
{
_meshManager = target as MeshManager;
_visualElement = new VisualElement();
_visualTreeAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/MeshGeneration.uxml");
_uss = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Editor/MeshGeneration.uss");
_visualElement.styleSheets.Add(_uss);
}
void Apply(MeshManager manager, DeltaDoneDelegate onDone, bool undo)
{
if (m_co != null)
{
m_co.done = true;
}
m_co = Scheduler.StartCoroutine(DoApply(manager, onDone, undo));
}
public override void StartClientSide(ICoreClientAPI api)
{
base.StartClientSide(api);
MeshManager.Init(api.World as ClientMain);
OBJSys = new SystemObjectLifetime(api.World as ClientMain);
}
protected override void Awake()
{
m_meshManager = GameObject.FindObjectOfType <MeshManager>();
if (m_meshManager == null)
{
Debug.LogWarning("Could not find MeshManager!");
}
}
public ChunkMeshGenerator(Game game)
{
_game = game;
_meshManager = game.Processors.GetOrThrow <MeshManager>();
_chunkStore = (LookupDictionaryStore <ChunkPos, Chunk>)game.Components.GetStore <Chunk>();
_storageStore = game.Components.GetStore <ChunkPaletteStorage <Block> >();
_textureCellStore = game.Components.GetStore <TextureCoords4>();
}
public void RedoAction(MeshManager manager, DeltaDoneDelegate onDone)
{
Apply(manager);
if (onDone != null)
{
onDone();
}
}
private void Awake()
{
rend = GetComponent <MeshRenderer>();
filter = GetComponent <MeshFilter>();
mesh = filter.mesh;
meshManager = GameObject.FindWithTag("LevelHandler").GetComponent <MeshManager>();
}
public void Init(MeshManager manager, Data data, MeshPatternDelta delta)
{
m_data = data;
m_delta = delta;
m_manager = manager;
CalcBounds();
}
private void Initialize()
{
graphicsDevice = ScreenManager.GraphicsDevice;
content = ScreenManager.Content;
spriteBatch = ScreenManager.SpriteBatch;
font = ScreenManager.Font;
MeshManager.InitializeManager(graphicsDevice, content);
screenWidth = graphicsDevice.Viewport.Width;
screenHeight = graphicsDevice.Viewport.Height;
clearColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
// Create Render Targets
mainRT = new RenderTarget2D(graphicsDevice, screenWidth, screenHeight, false, SurfaceFormat.Color,
DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PreserveContents);
reflectionRT = new RenderTarget2D(graphicsDevice, screenWidth / 2, screenHeight / 2, true, SurfaceFormat.Color,
DepthFormat.Depth24Stencil8);
occlusionRT = new RenderTarget2D(graphicsDevice, screenWidth / 8, screenHeight / 8, false, SurfaceFormat.Color,
DepthFormat.None);
bloomRT = new RenderTarget2D(graphicsDevice, screenWidth / 8, screenHeight / 8, false, SurfaceFormat.Color,
DepthFormat.None);
postEffects = new PostProcessingEffects(graphicsDevice,
content.Load <Effect>(@"Effects\PostProcessingEffects"));
// Create renderers
lightRenderer = new LightRenderer(graphicsDevice,
content.Load <Effect>(@"Effects\Light"));
terrainRenderer = new TerrainRenderer(graphicsDevice,
content.Load <Effect>(@"Effects\Terrain"));
surfaceRenderer = new SurfaceRenderer(graphicsDevice,
content.Load <Effect>(@"Effects\Surface"));
waterRenderer = new WaterRenderer(graphicsDevice,
content.Load <Effect>(@"Effects\Water"));
billboardRenderer = new BillboardRenderer(graphicsDevice,
content.Load <Effect>(@"Effects\Billboard"));
meshRenderer = new MeshRenderer(graphicsDevice,
content.Load <Effect>(@"Effects\Mesh"));
// Create camera
camera = new FirstPersonCamera();
camera.AspectRatio = graphicsDevice.Viewport.AspectRatio;
camera.AABBSize = new Vector2(1.0f, 8.0f);
camera.DrawDistance = 10000.0f;
camera.MoveSpeed = 25.0f;
camera.FreeFlyEnabled = false;
camera.PitchMinDegrees = -75.0f;
camera.PitchMaxDegrees = 60.0f;
camera.Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f),
camera.AspectRatio, 0.1f, 10000.0f);
secretSFX = content.Load <SoundEffect>(@"SoundEffects\shotgun_pump");
// Load level data
LoadLevel(@"Levels\" + levelFileName);
}
public DecorativeTypeZMinus(string name, string shape, string modname) : base(name + shape + "z-", false)
{
this.ParentType = name + shape;
this.IsPlaceable = true;
if (MeshManager.GetMesh(modname, shape + "z-", out string mesh))
{
this.Mesh = mesh;
}
}
public void Apply(MeshManager manager)
{
VoxelBlob targetData = manager.m_blob;
byte newMat = material;
material = targetData[width, layer, depth];
targetData[width, layer, depth] = newMat;
manager.MarkChunksForRegenForPoint(width, layer, depth);
}
public void DrawMesh(int playerAmount)
{
if (meshManager.mesh.vertexCount > 0)
{
meshManager.AddIndicesAndDrawMesh(playerAmount);
}
meshManager.SetVertices(MeshManager.ConcatV2ListsToV3(innerPoints, outerPoints));
}
void Start()
{
objectStorage = new ObjectStorage();
levelManager = new LevelManager(this);
meshManager = new MeshManager(levelManager, objectStorage, grid);
GameObject.Find("water").GetComponent <Spacing>().Manager = levelManager;
meshManager.CreateRoad();
isPlaying = true;
}
void Start()
{
prefabStorage = new PrefabStorage();
levelBuilder = new LevelBuilder(this);
meshManager = new MeshManager(levelBuilder, prefabStorage, grid);
GameObject.Find("WaterDrop").GetComponent <PlayerController>().Builder = levelBuilder;
meshManager.CreateRoad();
isPlaying = true;
}
public Verticle(MeshManager Owner, int Xnumber, List <int> XAliases, Vector3 XpositionRelative)
{
Initialise();
OwnerManager = Owner;
number = Xnumber;
Aliases = XAliases;
positionRelative = XpositionRelative;
//normal = OwnerManager.mesh.normals[Aliases[0]];
SetPositionAbsolute();
}
public void UndoAction(MeshManager manager, DeltaDoneDelegate onDone)
{
blobDelta.UndoAction(manager, onDone);
if (m_converter != null)
{
m_converter.shouldAbort = true;
m_converter = null;
}
}
protected override void OnLoad(EventArgs e)
{
// Initialize GL settings
GPUCapabilities.Initialize();
GLState.DepthTest = true;
GLState.CullFace = true;
GLState.BlendFunc(BlendingFactorSrc.DstAlpha, BlendingFactorDest.OneMinusDstAlpha);
GL.ClearColor(0.25f, 0.25f, 0.25f, 1.0f);
// Set up camera
camera = new Camera(this);
camera.Perspective(Width, Height, (float)Math.PI / 4, 1f, 1000);
camera.Position = new Vector3(0, 20, 200);
camera.Target = new Vector3(0, 0, -1);
camera.SetAsCurrent(); // Use this camera for rendering
// Set up PackageManager
PackageManager.BasePath = "../../Assets/";
// Load shaders
ShaderManager.LoadCollection("Shaders/collection.xml");
var shader = ShaderManager.Get("cubemappedmodel");
// Load texture
textures = new TextureManager();
var texture = textures.Get("Textures/cubemap.tex", true);
texture.Quality.Mipmaps = true;
// Load up a mesh
MeshManager meshManager = new MeshManager();
var mesh = meshManager.Get("Meshes/sphere.mesh", true);
// Construct a model from shader, texture and mesh, with default material
model = new Model()
{
Shader = shader,
Texture = texture,
Mesh = mesh,
Material = new Material()
};
// set up rendering queue
renderQueue = new RenderQueue();
renderQueue.AllowInstancing = false;
}
/// <summary>
/// Must be overriden by child classes for their own server specific startup behaviour.
/// </summary>
protected override void StartupComponents()
{
m_log.Info("[STARTUP]: Beginning startup processing");
Version = Util.EnhanceVersionInformation();
m_log.Info("[STARTUP]: Version: " + Version + "\n");
Console = new Console(this,"Region", this);
IConfig cnf = m_configSource.Source.Configs["Startup"];
string loginURI = "http://127.0.0.1:9000/";
string firstName = string.Empty;
string lastName = string.Empty;
string password = string.Empty;
string startlocation = "";
bool loadtextures = true;
bool multipleSims = false;
if (cnf != null)
{
loginURI = cnf.GetString("login_uri", "");
firstName = cnf.GetString("first_name", "test");
lastName = cnf.GetString("last_name", "user");
password = cnf.GetString("pass_word", "nopassword");
loadtextures = cnf.GetBoolean("load_textures", true);
MeshSculpties = cnf.GetBoolean("mesh_sculpties", MeshSculpties);
BackFaceCulling = cnf.GetBoolean("backface_culling", BackFaceCulling);
AvatarMesh = cnf.GetString("avatar_mesh", AvatarMesh);
AvatarMaterial = cnf.GetString("avatar_material", AvatarMaterial);
AvatarScale = cnf.GetFloat("avatar_scale", AvatarScale);
startlocation = cnf.GetString("start_location", "");
multipleSims = cnf.GetBoolean("multiple_sims", multipleSims);
ProcessFoliage = cnf.GetBoolean("process_foliage", ProcessFoliage);
m_limitFramesPerSecond = cnf.GetBoolean("limitfps", m_limitFramesPerSecond);
}
LoadTextures = loadtextures;
MainConsole.Instance = Console;
// Initialize LibOMV
if (NetworkInterface == null) NetworkInterface = new RadegastNetworkModule(RInstance);
NetworkInterface.MultipleSims = multipleSims;
NetworkInterface.OnLandUpdate += OnNetworkLandUpdate;
NetworkInterface.OnConnected += OnNetworkConnected;
NetworkInterface.OnObjectAdd += OnNetworkObjectAdd;
NetworkInterface.OnSimulatorConnected += OnNetworkSimulatorConnected;
NetworkInterface.OnObjectUpdate += OnNetworkObjectUpdate;
NetworkInterface.OnObjectRemove += OnNetworkObjectRemove;
NetworkInterface.OnAvatarAdd += OnNetworkAvatarAdd;
//NetworkInterface.OnChat +=new NetworkChatDelegate(OnNetworkChat);
//NetworkInterface.OnFriendsListUpdate +=new NetworkFriendsListUpdateDelegate(OnNetworkFriendsListChange);
//NetworkInterface.Login(loginURI, firstName + " " + lastName, password, startlocation);
// Startup the GUI
Renderer = new RaegastRenderer(this,Device);
Renderer.Startup();
GUIFont defaultFont = Renderer.GuiEnvironment.GetFont("defaultfont.png");
skin = Renderer.GuiEnvironment.Skin;
skin.Font = defaultFont;
skincolor = skin.GetColor(GuiDefaultColor.Face3D);
skincolor.A = 255;
skin.SetColor(GuiDefaultColor.Face3D, skincolor);
skincolor = skin.GetColor(GuiDefaultColor.Shadow3D);
skincolor.A = 255;
skin.SetColor(GuiDefaultColor.Shadow3D, skincolor);
// Set up event handler for the GUI window events.
Renderer.Device.OnEvent += new OnEventDelegate(OnDeviceEvent);
Renderer.Device.Resizeable = true;
MeshManager = new MeshManager(Renderer.SceneManager.MeshManipulator, Renderer.Device);
SceneGraph = new VSceneGraph(this);
// Set up the picker.
SceneGraph.TrianglePicker = new TrianglePickerMapper(Renderer.SceneManager.CollisionManager);
SceneGraph.TriangleSelector = Renderer.SceneManager.CreateMetaTriangleSelector();
// Only create a texture manager if the user configuration option is enabled for downloading textures
if (LoadTextures)
{
TextureManager = new TextureManager(this,Renderer.Device, Renderer.Driver, SceneGraph.TrianglePicker, SceneGraph.TriangleSelector, "IdealistCache", NetworkInterface);
TextureManager.OnTextureLoaded += OnNetworkTextureDownloaded;
}
AvatarController = new AvatarController(NetworkInterface, null);
TerrainManager = ModuleManager.GetTerrainManager(this, m_configSource);
Renderer.SceneManager.SetAmbientLight(new Colorf(1f, 0.2f, 0.2f, 0.2f));
// This light simulates the sun
//SceneNode light2 = Renderer.SceneManager.AddLightSceneNode(Renderer.SceneManager.RootSceneNode, new Vector3D(0, 255, 0), new Colorf(0f, 0.5f, 0.5f, 0.5f), 250, -1);
SceneNode light2 = Renderer.SceneManager.AddLightSceneNode(Renderer.SceneManager.RootSceneNode, new Vector3D(0, 255, 0), new Colorf(0f, 0.6f, 0.6f, 0.6f), 512, -1);
// Fog is on by default, this line disables it.
//Renderer.SceneManager.VideoDriver.SetFog(new Color(0, 255, 255, 255), false, 9999, 9999, 0, false, false);
float fogBrightness = 0.8f;
Renderer.SceneManager.VideoDriver.SetFog(new Color(0, (int)(0.5f * 255 * fogBrightness), (int)(0.5f * 255 * fogBrightness), (int)(1.0f * 255 * fogBrightness)), true, 50, 100, 0, true, true);
//ATMOSkySceneNode skynode = new ATMOSkySceneNode(Renderer.Driver.GetTexture("irrlicht2_up.jpg"), null, Renderer.SceneManager, 100, -1);
//ATMOSphere atmosphere = new ATMOSphere(Renderer.Device.Timer, null, Renderer.SceneManager, -1);
//atmosphere.SkyTexture = Renderer.Driver.GetTexture("irrlicht2_up.jpg");
Renderer.Driver.SetTextureFlag(TextureCreationFlag.CreateMipMaps, false);
bool Broken = false;
if (!Broken) Renderer.SceneManager.AddSkyBoxSceneNode(null, new Texture[] {
Renderer.Driver.GetTexture("topax2.jpg"),
Renderer.Driver.GetTexture("irrlicht2_dn.jpg"),
Renderer.Driver.GetTexture("rightax2.jpg"),
Renderer.Driver.GetTexture("leftax2.jpg"),
Renderer.Driver.GetTexture("frontax2.jpg"),
Renderer.Driver.GetTexture("backax2.jpg")},
0);
Renderer.Driver.SetTextureFlag(TextureCreationFlag.CreateMipMaps, true);
CameraController = new CameraController(this,Renderer.SceneManager);
SceneGraph.WaterNode = new WaterSceneNode(null, Renderer.SceneManager, new Dimension2Df(180, 180), new Dimension2D(100, 100), new Dimension2D(512, 512));
SceneGraph.WaterNode.Position = new Vector3D(0, 30, 0);
//SceneGraph.WaterNode.WaveHeight *= .4f;
SceneGraph.WaterNode.RefractionFactor = 0.3f;
SceneGraph.WaterNode.WaveDisplacement = 2f;
SceneGraph.WaterNode.WaveHeight = 2f;
SceneGraph.WaterNode.WaveLength = 2f;
SceneGraph.WaterNode.WaveSpeed = 5f;
SceneGraph.WaterNode.WaveRepetition = 20f;
SceneGraph.WaterNode.Scale = new Vector3D(0.2f,0.2f,0.2f);
SceneGraph.WaterNode.MultiColor = new Colorf(0.9f, 0.7f, 0.7f, 1.0f);
UserInterface = new UserInterfaceManager(this, Renderer.Driver, Renderer.SceneManager, Renderer.GuiEnvironment, CameraController, AvatarController);
UserInterface.DefaultFont = defaultFont;
XmlReader xml = Broken? null: XmlReader.Create(new StreamReader("../../../media/About.xml"));
while (xml != null && xml.Read())
{
switch (xml.NodeType)
{
case XmlNodeType.Text:
UserInterface.AboutText = xml.ReadContentAsString();
break;
case XmlNodeType.Element:
if (xml.Name.Equals("startUpModel"))
{
}
else if (xml.Name.Equals("messageText"))
UserInterface.AboutCaption = xml.GetAttribute("caption");
break;
}
}
string formsUiConfigurationOption = m_configSource.Source.Configs["Startup"].GetString("forms", "true");
if (formsUiConfigurationOption == "true")
{
frmCommunications f = new frmCommunications(NetworkInterface);
f.Visible = true;
this.m_formsThread = new Thread(delegate() { Application.DoEvents(); Thread.Sleep(50); });
m_formsThread.Start();
}
AnimationManager = new AnimationManager(this);
TimeSpan timeTaken = DateTime.UtcNow - StartupTime;
m_log.InfoFormat("[STARTUP]: Startup took {0}m {1}s", timeTaken.Minutes, timeTaken.Seconds);
}
void LoadMeshStuff()
{
// Set up camera
camera = new Camera(this);
camera.Perspective(Width, Height, (float)Math.PI / 4, 1f, 1000);
camera.Position = new Vector3(0, 20, 200);
camera.Target = new Vector3(0, 0, 0);
camera.SetAsCurrent(); // Use this camera for rendering
// Set up PackageManager
PackageManager.BasePath = "../../Assets/";
// Load shaders
var modelshader = ShaderManager.Get("transparentmodel");
// Load texture
textures = new TextureManager();
var texture = textures.Get("Textures/lucymetal.tex", true);
texture.Quality.Mipmaps = true;
// Load up a mesh
MeshManager meshManager = new MeshManager();
var mesh = meshManager.Get("Meshes/lucy.mesh", true);
var lucyMaterial = new Material();
lucyMaterial.Textures.Add("textureSampler", texture);
lucyMaterial.ShaderProgram = modelshader;
// Construct a model from shader, texture and mesh, with default material
model = new Model()
{
Mesh = mesh,
Material = lucyMaterial
};
// set up rendering queue
renderQueue = new RenderQueue()
{
AllowInstancing = false
};
}
protected override void OnLoad(EventArgs e)
{
// Initialize GL settings
GPUCapabilities.Initialize();
GLState.DepthTest = true;
GLState.CullFace = true;
GLState.BlendFunc(BlendingFactorSrc.SrcColor, BlendingFactorDest.OneMinusSrcAlpha);
GL.ClearColor(0.25f, 0.25f, 0.25f, 1.0f);
// Set up camera
camera = new Camera(this);
camera.Perspective(Width, Height, (float)Math.PI / 4, 1f, 1000);
camera.Position = new Vector3(0, 20, 200);
camera.Target = new Vector3(0, 0, 0);
camera.SetAsCurrent();
// Set up PackageManager
PackageManager.BasePath = "../../Assets/";
// Load shaders
ShaderManager.LoadCollection("Shaders/collection.xml");
// Load texture
textures = new TextureManager();
var texture = textures.Get("Textures/lucymetal.tex", true);
texture.Quality.Mipmaps = true;
var groundtexture = textures.Get("Textures/concreteslabs.tex", true);
groundtexture.Quality.Mipmaps = true;
groundtexture.Quality.TextureWrapMode = TextureWrapMode.Repeat;
// Load up a mesh
MeshManager meshManager = new MeshManager();
var mesh = meshManager.Get("Meshes/lucy.mesh", true);
var groundmesh = meshManager.Get("Meshes/plane.mesh", true);
var modelMaterial = new Material()
{
ShaderProgram = ShaderManager.Get("transparentmodel"),
Transparent = false,
UniformData = new List<IUniformData>()
{
new UniformDataVector4() {
Name = "color",
Data = new Vector4(1,1,1,0.75f),
},
new UniformDataFloat() {
Name = "specularIntensity",
Data = 0.5f,
}
}
};
modelMaterial.Textures.Add("textureSampler", texture);
// Construct a model from shader, texture and mesh, with default material
model = new Model()
{
Mesh = mesh,
Material = modelMaterial
};
var modelMaterial2 = modelMaterial.Copy();
modelMaterial2.Transparent = true;
// Construct a model from shader, texture and mesh, with default material
model2 = new Model()
{
Mesh = mesh,
Material = modelMaterial2
};
var groundMaterial = modelMaterial.Copy();
groundMaterial.Textures["textureSampler"] = groundtexture;
// Construct a model from shader, texture and mesh, with default material
groundplane = new Model()
{
Mesh = groundmesh,
Material = groundMaterial
};
model.Transform.Position += new Vector3(1, 0, 0);
model2.Transform.Position += new Vector3(-1, 0, 0);
groundplane.Transform.Position += new Vector3(0, -1, 0);
// set up rendering queue
renderQueue = new RenderQueue();
renderQueue.AllowInstancing = false;
}
protected override void OnLoad(EventArgs e)
{
PackageManager.BasePath = "../../Assets/";
GPUCapabilities.Initialize();
GLState.DepthTest = true;
GLState.CullFace = true;
GL.ClearColor(0.25f, 0.25f, 0.25f, 1.0f);
ShaderManager.LoadCollection("Shaders/collection.xml");
SceneManager.Initialize(500, 5, 20, Vector3.Zero);
SceneManager.CullByObject = false;
renderQueue = new RenderQueue();
renderQueue.AllowInstancing = true;
meshes = new MeshManager();
camera = new Hatzap.Camera(this);
camera.SetAsCurrent();
camera.Position = new Vector3(0, 1, 1);
camera.Target = new Vector3(-1, 0, 0);
camera.Update(0);
camera.Rotate(new Vector2(-(float)Math.PI / 2.5f, 0));
var rand = new Hatzap.Utilities.Random();
int n = 8;
float sizeScale = 10.0f;
// All objects will have the same material
Material material = new Material();
material.ShaderProgram = ShaderManager.Get("instancedmodel");
// To disable instancing, use these:
//material.ShaderProgram = ShaderManager.Get("simplemodel");
//renderQueue.AllowInstancing = false;
for (int x = -n; x <= n; x++)
{
for (int y = -n; y <= n; y++)
{
for (int z = -n; z <= n; z++)
{
var instancedObject = new Model();
// Set shader, mesh and material (no texture)
instancedObject.Mesh = meshes.Get("Meshes/suzanne.mesh", true);
instancedObject.Material = material.Copy();
// Set transform
instancedObject.Transform.Position = new Vector3(
(x + (float)(rand.NextDouble() - 0.5)) * sizeScale,
(y + (float)(rand.NextDouble() - 0.5)) * sizeScale,
(z + (float)(rand.NextDouble() - 0.5)) * sizeScale);
instancedObject.Transform.Rotation = Quaternion.FromEulerAngles(
x * 360.0f / n / (float)Math.PI,
y * 360.0f / n / (float)Math.PI,
z * 360.0f / n / (float)Math.PI);
float color = 1f;
color = color - ((y + n) / (n * 2.0f));
instancedObject.Material.Add(new UniformDataVector4(){
Data = new Vector4(color, color, color, 1),
Name = "Color",
});
// Don't calculate matrices on every frame
instancedObject.Transform.Static = true;
// Insert model in the scene octree. (Because I'm lazy and didn't want
// to write code to update all these meshes in the queue by hand. Also
// culling is done by scene automatically.)
SceneManager.Insert(instancedObject);
}
}
}
}
protected override void OnLoad(EventArgs e)
{
// Initialize GL settings
GPUCapabilities.Initialize();
GLState.DepthTest = true;
GLState.AlphaBleding = false;
GLState.CullFace = true;
GL.ClearColor(0.25f, 0.25f, 0.25f, 1.0f);
// Set up camera
camera = new Camera(this);
camera.Perspective(Width, Height, (float)Math.PI / 4, 1f, 1000);
camera.Position = new Vector3(0, 20, 100);
camera.Target = new Vector3(0, 0, -1);
camera.SetAsCurrent();
// Set up PackageManager
PackageManager.BasePath = "../../Assets/";
// Load shaders
ShaderManager.LoadCollection("Shaders/collection.xml");
// Load texture
textures = new TextureManager();
var texture = textures.Get("Textures/concreteslabs.tex", true);
texture.Quality.Mipmaps = true;
texture.Quality.TextureWrapMode = TextureWrapMode.Repeat;
// Load up a mesh
MeshManager meshManager = new MeshManager();
var mesh = meshManager.Get("Meshes/dragon.mesh", true);
// Create base material
materials = new MaterialManager();
materials.Insert("uniformexamplematerial.mat", new Material()
{
UniformData = new List<IUniformData>()
{
new UniformDataFloat() {
Name = "time",
Data = 0.0f
},
new UniformDataVector2() {
Name = "toffset",
Data = Vector2.Zero
},
new UniformDataVector4() {
Name = "color",
Data = Vector4.One
}
}
});
// Construct a model from shader, texture and mesh, with default material
model = new Model()
{
Shader = ShaderManager.Get("uniformexamplemodel"),
Texture = texture,
Mesh = mesh,
Material = materials.Get("uniformexamplematerial.mat")
};
model2 = new Model()
{
Shader = ShaderManager.Get("uniformexamplemodel"),
Texture = texture,
Mesh = mesh,
Material = materials.Get("uniformexamplematerial.mat")
};
model3 = new Model()
{
Shader = ShaderManager.Get("uniformexamplemodel"),
Texture = texture,
Mesh = mesh,
Material = materials.Get("uniformexamplematerial.mat")
};
model.Transform.Position += new Vector3(-1, 0.5f, 0);
model2.Transform.Position += new Vector3(1, 0.5f, 0);
model3.Transform.Position += new Vector3(0, -0.75f, 0);
model.Transform.Rotation *= new Quaternion(0, (float)Math.PI, 0);
// set up rendering queue
renderQueue = new RenderQueue();
renderQueue.AllowInstancing = false;
}
private void MenuImportMesh_Click(object sender, RoutedEventArgs e)
{
// Configure open file dialog box
Microsoft.Win32.OpenFileDialog openDlg = new Microsoft.Win32.OpenFileDialog();
openDlg.FileName = ""; // Default file name
openDlg.DefaultExt = ".*"; // Default file extension
openDlg.Filter = "All files |*.*"; // Filter files by extension
// Show open file dialog box
Nullable<bool> result = openDlg.ShowDialog();
// Process open file dialog box results
if (result == true)
{
// Open document
string filename = openDlg.FileName;
//Create a new importer
AssimpContext importer = new AssimpContext();
//This is how we add a configuration (each config is its own class)
//NormalSmoothingAngleConfig config = new NormalSmoothingAngleConfig(66.0f);
//importer.SetConfig(config);
var flags = PostProcessPreset.TargetRealTimeMaximumQuality | PostProcessSteps.Triangulate | PostProcessSteps.SortByPrimitiveType | PostProcessSteps.FlipUVs;
//Import the model. All configs are set. The model
//is imported, loaded into managed memory. Then the unmanaged memory is released, and everything is reset.
Scene model = importer.ImportFile(filename, flags);
var mesh = new Hatzap.Models.Mesh();
Assimp.Mesh aMesh = null;
foreach (var item in model.Meshes)
{
if (item.PrimitiveType != Assimp.PrimitiveType.Triangle)
continue;
aMesh = item;
break;
}
if (aMesh != null)
{
AssimpConvertor ac = new AssimpConvertor();
mesh = ac.FromAssimp(aMesh);
}
else
{
Debug.WriteLine("ERROR: No triangle meshes found in imported model.");
}
importer.Dispose();
if (mesh == null)
return;
filename = System.IO.Path.GetFileNameWithoutExtension(filename);
filename += ".mesh";
// Configure save file dialog box
Microsoft.Win32.SaveFileDialog saveDlg = new Microsoft.Win32.SaveFileDialog();
saveDlg.FileName = filename; // Default file name
saveDlg.DefaultExt = ".mesh"; // Default file extension
saveDlg.Filter = "Mesh files (.mesh)|*.mesh"; // Filter files by extension
// Show save file dialog box
result = saveDlg.ShowDialog();
// Process save file dialog box results
if (result == true)
{
// Save document
filename = saveDlg.FileName;
MeshManager meshManager = new MeshManager();
using (var fs = File.OpenWrite(filename))
{
meshManager.TemporarySaveAsset(mesh, fs);
}
}
}
}
