public void LoadAll()
{
// Find data directory and go to it
bool dataDirFound = false;
{
string dir = FindDirectory(dataDirectory);
if (dir != null)
{
dataDirFound = true;
Directory.SetCurrentDirectory(dir);
}
}
if (dataDirFound)
{
materialManager = MaterialManager.GetSingleton();
//
string textureDirName = "textures";
string textureDir = FindDirectory(textureDirName);
if (textureDir != null)
{
materialManager.loadAllFromDir(textureDir);
}
// Find mesh/model directory
string modelDirName = "models";
string modelDir = FindDirectory(modelDirName);
if (modelDir != null)
{
meshManager = new MeshManager(materialManager, modelDir);
}
else
{
Logger.LogError(Logger.ErrorState.Critical, "Model directory not found");
}
// Find shader directory
string shaderDirName = "shaders";
string shaderDir = FindDirectory(shaderDirName);
if (shaderDir != null)
{
shaderManager = new ShaderManager(shaderDir);
}
else
{
Logger.LogError(Logger.ErrorState.Critical, "Shader directory not found");
}
}
else
{
Logger.LogError(Logger.ErrorState.Critical, "Data directory not found");
}
}
public static void readMaterialFile(string mttlibLine, MaterialManager materialManager, ref Material material)
{
// mtllib voxelColor.mtl
char[] space = { ' ' };
string[] matFileLines = mttlibLine.Split(space);
string filename = matFileLines[1];
string fullPath = Directory.GetCurrentDirectory() + System.IO.Path.DirectorySeparatorChar + filename;
material = materialManager.loadMaterial(fullPath);
}
public TextureMap GetMap(ShaderUniformName uniformName)
{
if (textureMaps.ContainsKey(uniformName))
{
return(textureMaps[uniformName]);
}
else
{
Logger.LogError(Logger.ErrorState.Limited, "Material " + materialName + " does not have a map for " + ShaderUniformManager.GetSingleton().GetUniformName(uniformName) + "");
return(MaterialManager.GetSingleton().GetDefaultMap(uniformName));
}
}
public void RenderShaderDataOwnerMesh(DrawableMesh mesh, IShaderDataOwner owner)
{
if (mesh == null)
{
Logger.LogError(Logger.ErrorState.Critical, "RenderMesh, no mesh given");
return;
}
SetActiveShader(mesh.ShaderProgram);
if (activeProgram == null)
{
Logger.LogError(Logger.ErrorState.Critical, "RenderMesh, no active shader");
return;
}
List <ShaderUniformName> ownerUniforms = owner.GetUniforms();
ShaderUniformManager man = ShaderUniformManager.GetSingleton();
foreach (ShaderUniformName name in ownerUniforms)
{
man.SetData(activeProgram, name, owner);
}
if (mesh != owner)
{
List <ShaderUniformName> meshUniforms = mesh.GetUniforms();
foreach (ShaderUniformName name in meshUniforms)
{
man.SetData(activeProgram, name, mesh);
}
}
if (mesh.BoundMaterial != null)
{
MaterialManager matMan = MaterialManager.GetSingleton();
matMan.SetMaterialToShader(mesh.BoundMaterial, activeProgram);
}
mesh.draw();
}
// Reads on .obj file
static public MeshData CreateFromFile(string filename, MaterialManager materialManager)
{
MeshData newData = new MeshData();
List<Vector3> positions = new List<Vector3>();
List<Vector3> normals = new List<Vector3>();
List<Vector2> texCoords = new List<Vector2>();
List<OBJFileReader.OBJFace> faces = new List<OBJFileReader.OBJFace>();
Material meshMaterial = new Material("");
OBJFileReader.readOBJ(filename, materialManager, ref faces, ref positions, ref normals, ref texCoords, ref meshMaterial);
// Create positions
newData.hasPositionData = true;
newData.hasTexCoordData = true;
newData.hasNormalData = true;
bool useIndices = true;
List<OBJFileReader.OBJFace> uniqueFaces = null;
Dictionary<OBJFileReader.OBJFace, int> uniqueFacesDict = null;
if (useIndices)
{
uniqueFaces = new List<OBJFileReader.OBJFace>();
uniqueFacesDict = new Dictionary<OBJFileReader.OBJFace, int>();
newData.indices = new List<int>();
newData.hasIndexData = true;
}
newData.positions = new List<Vector3>();
newData.texCoords = new List<Vector2>();
newData.normals = new List<Vector3>();
bool addFace = true;
foreach (OBJFileReader.OBJFace face in faces)
{
if (useIndices)
{
//OBJFileReader.OBJFinder finder = new OBJFileReader.OBJFinder(face);
bool alreadyFound = uniqueFacesDict.ContainsKey(face);
int faceIndex = -1;
if (alreadyFound)
{
uniqueFacesDict.TryGetValue(face, out faceIndex);
addFace = false;
}
else
{
faceIndex = uniqueFacesDict.Count;
uniqueFacesDict.Add(face, faceIndex);
// Add face info to arrays
addFace = true;
}
newData.indices.Add(faceIndex);
}
// This is always true when not using indices
if (addFace)
{
newData.positions.Add(positions[(int)face.positionIndex - 1]);
newData.texCoords.Add(texCoords[(int)face.texCoordIndex - 1]);
newData.normals.Add(normals[(int)face.normalIndex - 1]);
}
}
Logger.LogInfo("Mesh Data read from " + filename);
newData.drawType = MeshData.DataDrawType.Triangles;
newData.GenerateBufferHandles();
Error.checkGLError("Mesh Data created from file: " + filename);
return newData;
}
public void Load(AssetManager assetManager, SyncSystem syncSystem)
{
TunableManager tm = TunableManager.GetSingleton();
lightController = new InstanssiLightController(
tm.GetString("demosettings.light_server_ip")
, tm.GetString("demosettings.light_server_host_name")
, tm.GetInt("demosettings.light_server_port")
, tm.GetInt("bunny_lights.amount")
, tm.GetInt("demosettings.physical_lights_amount")
, tm.GetInt("demosettings.light_server_interval"));
mountainsNumber = tm.GetInt("scene_number.mountains");
moonNumber = tm.GetInt("scene_number.moon");
bunnyNumber = tm.GetInt("scene_number.bunny");
warpNumber = tm.GetInt("scene_number.warp");
seaNumber = tm.GetInt("scene_number.sea");
crystalsNumber = tm.GetInt("scene_number.crystals");
// Audio
Logger.LogInfo("Loading demo audio");
string audioFileName = tm.GetString("audio.filename");
music = audioSystem.LoadAudioFile(audioFileName);
syncSystem.SetAudioProperties(tm.GetInt("audio.bpm"), tm.GetFloat("audio.length_seconds")
, tm.GetInt("audio.rows_per_beat"));
syncSystem.SetManualSceneAdvanceRate(tm.GetFloat("sync.manual_scene_advance_speed"));
// Camera
CameraComponent camera = Renderer.GetSingleton().GetCamera();
camera.FOV = tm.GetFloat("camera.fov");
camera.Speed = tm.GetFloat("camera.speed");
camera.SpeedStep = tm.GetFloat("camera.speed_step");
camera.Near = tm.GetFloat("camera.near_plane");
camera.Far = tm.GetFloat("camera.far_plane");
camera.CreateMatrices();
// Camera frames
Logger.LogInfo("Loading demo frames");
List <PosAndDir> frames = new List <PosAndDir>();
int frameAmount = tm.GetInt("camera_frames.amount");
for (int frameI = 0; frameI < frameAmount; frameI++)
{
Vector3 pos = tm.GetVec3("camera_frames.frame_" + frameI + "_pos");
Vector3 dir = tm.GetVec3("camera_frames.frame_" + frameI + "_dir");
frames.Add(new PosAndDir(pos, dir));
}
Renderer.GetSingleton().SetCameraFrames(frames);
// Shaders
Logger.LogInfo("Loading demo shaders");
ShaderProgram diamondShader = assetManager.GetShaderProgram("diamond");
ShaderProgram texShader = assetManager.GetShaderProgram("texturedobjmesh");
ShaderProgram gridShader = assetManager.GetShaderProgram("gridmesh");
ShaderProgram objShader = assetManager.GetShaderProgram("litobjmesh");
ShaderProgram skyboxProgram = assetManager.GetShaderProgram("skybox");
ShaderProgram starProgram = assetManager.GetShaderProgram("sky");
guiShader = assetManager.GetShaderProgram("gui");
cameraFOV = syncSystem.GetTrack("FOV");
warpFOV = syncSystem.GetTrack("W_FOV");
// Fade
if (guiShader == null)
{
Logger.LogError(Logger.ErrorState.Critical, "Did not get gui shader");
}
fadeoutAlpha = syncSystem.GetTrack("FadeOut");
Material fadeoutMaterial = new Material("blackfadeout");
fadeoutMaterial.textureMaps.Add(ShaderUniformName.DiffuseMap, MaterialManager.GetSingleton().GetColorTextureByName("black"));
MaterialManager.GetSingleton().AddNewMaterial(fadeoutMaterial);
fadeoutQuad = assetManager.CreateMesh("black_overlay"
, MeshDataGenerator.CreateQuadMesh(false, true)
, fadeoutMaterial.materialName
, guiShader
, tm.GetVec3("fade.position"));
fadeoutQuad.Transform.Scale = tm.GetFloat("fade.scale");
// Skybox
starSkyBox = assetManager.CreateMesh("stars"
, MeshDataGenerator.CreateSkybox()
, null
, skyboxProgram
, new Vector3(0, 0, 0));
starSkyboxMaterial = assetManager.GetMaterial(tm.GetString("mountain_scene.skybox_material"));
starSkyBox.Transform.SetRotationAxis(tm.GetVec3("mountain_scene.star_rotation_axis"));
skyRotation = syncSystem.GetTrack("Sky_R");
// Lights
mountainLight = Light.CreateDirectionalLight(tm.GetVec3("mountain_light.color")
, tm.GetFloat("mountain_light.ambient"), tm.GetFloat("mountain_light.intensity")
, tm.GetVec3("mountain_light.direction"));
// Models
Logger.LogInfo("Loading demo models");
Logger.LogInfo(" - Bunny");
bunnyMesh = assetManager.GetMesh("bunny"
, tm.GetString("bunny.model")
, tm.GetString("bunny.material")
, assetManager.GetShaderProgram(tm.GetString("bunny.shader"))
, tm.GetVec3("bunny.position"));
bunnyMesh.Transform.Scale = tm.GetFloat("bunny.scale");
bunnyMesh.Transform.SetRotationAxis(new Vector3(0, 1, 0));
bunnyRotation = syncSystem.GetTrack("bunny_R");
bunnyLights = new List <LightMesh>();
int bunnyLightAmount = tm.GetInt("bunny_lights.amount");
LoadLightMeshList(tm, assetManager, bunnyMesh.Transform, "bunny_lights", bunnyLightAmount, texShader, ref bunnyLights);
bunnyLightsSizesLocations = new List <int>();
for (int i = 0; i < bunnyLights.Count; i++)
{
int location = bunnyMesh.ShaderProgram.GetCustomUniformLocation("ucLightSizes[" + i + "]");
bunnyLightsSizesLocations.Add(location);
}
bunnyLightProgress = syncSystem.GetTrack("bunny_L");
Logger.LogInfo(" - Monolith");
monolith = assetManager.CreateMesh("monolith"
, MeshDataGenerator.CreateCubeMesh(tm.GetVec3("monolith.size")
, true, true)
, tm.GetString("monolith.material")
, objShader
, tm.GetVec3("monolith.position"));
monolith.Transform.SetRotationAxis(new Vector3(0, 1, 0));
monolith.Transform.Scale = tm.GetFloat("monolith.scale");
monolithRotation = syncSystem.GetTrack("mono_R");
monolithElevation = syncSystem.GetTrack("mono_Y");
// DEBUG
monolith_normals = assetManager.CreateMesh("mono_N"
, MeshDataGenerator.CreateNormalDebug(monolith.Data.positions, monolith.Data.normals)
, null
, gridShader
, monolith.Transform.GetWorldPosition());
monolith_normals.Transform.Parent = monolith.Transform;
Logger.LogInfo(" - Telescope");
telescope = new Telescope();
telescope.tower = assetManager.GetMesh("tele_tower"
, tm.GetString("telescope.tower_model")
, tm.GetString("telescope.material")
, objShader
, tm.GetVec3("telescope.tower_position"));
telescope.tower.Transform.Scale = tm.GetFloat("telescope.tower_scale");
telescope.tower.Transform.SetRotationAxis(new Vector3(0, 1, 0));
telescope.antenna = assetManager.GetMesh("tele_antenna"
, tm.GetString("telescope.antenna_model")
, tm.GetString("telescope.material")
, objShader
, tm.GetVec3("telescope.antenna_position"));
telescope.antenna.Transform.Scale = tm.GetFloat("telescope.antenna_scale");
telescope.antenna.Transform.SetRotationAxis(new Vector3(0, 0, 1));
telescope.antenna.Transform.Parent = telescope.tower.Transform;
telescopeElevation = syncSystem.GetTrack("Tele_Elev");
telescopeRotation = syncSystem.GetTrack("Tele_Rot");
mainTelescopePosition = tm.GetVec3("telescope.tower_position");
// Telescope array
int teleAmount = tm.GetInt("telescope_array.amount");
Vector3 teleArrayCorner = tm.GetVec3("telescope_array.position");
Vector3 teleArrayDir1 = tm.GetVec3("telescope_array.dir");
Vector3 teleArrayDir2 = tm.GetVec3("telescope_array.dir2");
float spacing = tm.GetFloat("telescope_array.spacing");
telescopeArrayPositions = new List <Vector3>();
for (int t = 0; t < teleAmount; t++)
{
telescopeArrayPositions.Add(teleArrayCorner + teleArrayDir1 * spacing * (t + 1));
telescopeArrayPositions.Add(teleArrayCorner + teleArrayDir2 * spacing * (t + 1));
}
// Sea
Logger.LogInfo(" - Sea");
seaShader = assetManager.GetShaderProgram("heightMapTerrain");
Vector2 seaSize = tm.GetVec2("sea.size");
float seaTrianglesDensity = tm.GetFloat("sea.detail_level");
Vector2 seaUVRepeat = tm.GetVec2("sea.UV_repeat");
seaMesh = assetManager.CreateMesh("sea"
, MeshDataGenerator.CreateTerrain(seaSize.X, seaSize.Y, seaTrianglesDensity, true, true
, seaUVRepeat.X, seaUVRepeat.Y)
, tm.GetString("sea.material")
, objShader
, tm.GetVec3("sea.position"));
// Planet mountains
Logger.LogInfo(" - Planet Mountains");
planetMountains = assetManager.CreateMesh("planet_mountains"
, MeshDataGenerator.CreateMountains(
tm.GetFloat("planet_mountain.size")
, true, tm.GetInt("planet_mountain.iterations")
, tm.GetFloat("planet_mountain.height_variation")
, tm.GetFloat("planet_mountain.flat_start")
, tm.GetFloat("planet_mountain.flat_end")
, tm.GetInt("planet_mountain.random_seed"))
, tm.GetString("planet_mountain.material")
, objShader
, tm.GetVec3("planet_mountain.position"));
planetLight = Light.CreateDirectionalLight(tm.GetVec3("planet_light.color")
, tm.GetFloat("planet_light.ambient"), tm.GetFloat("planet_light.intensity")
, tm.GetVec3("planet_light.direction"));
planetSkyBox = assetManager.CreateMesh("planet_skybox"
, MeshDataGenerator.CreateSkybox()
, null
, skyboxProgram
, new Vector3(0, 0, 0));
planetSkyboxMaterial = assetManager.GetMaterial("planet_skybox");
// Mountains
Logger.LogInfo(" - Mountains");
mountains = assetManager.CreateMesh("mountains"
, MeshDataGenerator.CreateMountains(
tm.GetFloat("mountain.size")
, true, tm.GetInt("mountain.iterations")
, tm.GetFloat("mountain.height_variation")
, tm.GetFloat("mountain.flat_start")
, tm.GetFloat("mountain.flat_end")
, tm.GetInt("mountain.random_seed"))
, tm.GetString("mountain.material")
, objShader
, tm.GetVec3("mountain.position"));
// Crystals
Logger.LogInfo(" - Crystals");
crystalMeshes = new List <Crystal>();
int crystalAmount = tm.GetInt("crystals.amount");
Random randomizer = new Random(0);
float areaSize = tm.GetFloat("crystals.area_size");
float areaTop = tm.GetFloat("crystals.area_top");
Vector3 areaPos = tm.GetVec3("crystals.area_pos");
float maxSpeed = tm.GetFloat("crystals.max_speed");
float sizeMin = tm.GetFloat("crystals.min_size");
float sizeMax = tm.GetFloat("crystals.max_size");
for (int s = 0; s < crystalAmount; s++)
{
Crystal c = new Crystal();
Vector3 position = new Vector3((float)randomizer.NextDouble() - 0.5f
, (float)randomizer.NextDouble()
, (float)randomizer.NextDouble() - 0.5f);
position = position * new Vector3(areaSize, areaSize, areaSize);
position += areaPos;
c.mesh = assetManager.CreateMesh("crystal_" + s
, MeshDataGenerator.CreateStar(new Vector3(1.0f, 0, 0), new Vector3(0, 1, 0)
, 1.0f, 2.0f, 0.5f, 0.8f, true)
, tm.GetString("crystals.material")
, assetManager.GetShaderProgram(tm.GetString("crystals.shader"))
, position);
c.mesh.Transform.Scale = sizeMin + (float)randomizer.NextDouble() * (sizeMax - sizeMin);
c.mesh.Transform.SetRotationAxis(position.Normalized());
c.speed = (float)randomizer.NextDouble() * maxSpeed;
crystalMeshes.Add(c);
}
crystalsGravity = tm.GetFloat("crystals.gravity");
Logger.LogInfo("Creating greetings");
// Title, Greets and credits
TextGenerator textgen = TextGenerator.GetSingleton();
string greet_font = tm.GetString("text.font");
PixelFont greetFont = textgen.GetFont(greet_font);
string greet_material = tm.GetString("text.material");
ShaderProgram greetShader = assetManager.GetShaderProgram(tm.GetString("text.shader"));
float textStep = tm.GetFloat("text.step");
// Title
string titleMaterial = tm.GetString("mountain_text.title_material");
string groupMaterial = tm.GetString("mountain_text.group_material");
DrawableMesh groupName = assetManager.CreateMesh("groupText"
, MeshDataGenerator.CreateQuadMesh(false, true)
, groupMaterial
, greetShader
, tm.GetVec3("mountain_scene.group_name_position"));
groupName.Transform.Scale = tm.GetFloat("mountain_scene.group_name_scale");
groupNameGreet = new Greeting();
groupNameGreet.textMesh = groupName;
groupNameGreet.alpha = 0.0f;
groupNameGreet.color = tm.GetVec3("mountain_text.color");
DrawableMesh demoName = assetManager.CreateMesh("groupText"
, MeshDataGenerator.CreateQuadMesh(false, true)
, titleMaterial
, greetShader
, tm.GetVec3("mountain_scene.demo_name_position"));
demoName.Transform.Scale = tm.GetFloat("mountain_scene.demo_name_scale");
demoNameGreet = new Greeting();
demoNameGreet.textMesh = demoName;
demoNameGreet.alpha = 0.0f;
demoNameGreet.color = tm.GetVec3("mountain_text.color");
// Greets
Vector3 greetOffset = tm.GetVec3("text.offset");
Vector3 greetSpacing = tm.GetVec3("text.spacing");
float greetScale = tm.GetFloat("text.scale");
group_greetings = new List <GreetPage>();
Vector3 monoGreetColor = tm.GetVec3("monolith_greets.color");
CreateGreets(tm, assetManager, "monolith_greets", greetFont, greet_material, monoGreetColor, greetShader
, greetOffset, greetSpacing, greetScale
, textStep, monolith.Transform, ref group_greetings);
// Credits
credits = new List <GreetPage>();
Vector3 creditsOffset = tm.GetVec3("credits.offset");
Vector3 creditsSpacing = tm.GetVec3("credits.spacing");
float creditsScale = tm.GetFloat("credits.scale");
Vector3 creditGreetColor = tm.GetVec3("credits.color");
CreateGreets(tm, assetManager, "credits", greetFont, greet_material, creditGreetColor, greetShader
, creditsOffset, creditsSpacing, creditsScale
, textStep, monolith.Transform, ref credits);
textAlpha = syncSystem.GetTrack("text_A");
Logger.LogInfo("Creating title and name");
title = new List <GreetPage>();
GreetPage titlePage = new GreetPage();
titlePage.greets.Add(groupNameGreet);
titlePage.greets.Add(demoNameGreet);
title.Add(titlePage);
if (settings.LightServer)
{
lightController.StartSync();
}
Logger.LogPhase("Bunny demo is loaded");
syncSystem.PrintEditorRowAmount();
}