Mesh3d CreateModel(Object3dInfo obj, Vector3 diffuse, Vector3 specular, float roughness)
{
var terrain3dInfo = obj;
var terrainMaterial = new GenericMaterial();
terrainMaterial.DiffuseColor = diffuse;
terrainMaterial.SpecularColor = specular;
terrainMaterial.Roughness = roughness;
var terrainMesh = Mesh3d.Create(terrain3dInfo, terrainMaterial);
return(terrainMesh);
}
Mesh3d CreateDiffuseModelFromRaw(string obj, Vector3 color)
{
var terrain3dManager = Object3dManager.LoadFromRaw(Media.Get(obj));
var terrain3dInfo = new Object3dInfo(terrain3dManager.Vertices);
var terrainMaterial = new GenericMaterial();
terrainMaterial.DiffuseColor = new Vector3(0);
terrainMaterial.SpecularColor = new Vector3(1);
terrainMaterial.Roughness = 0.5f;
var terrainMesh = Mesh3d.Create(terrain3dInfo, terrainMaterial);
return(terrainMesh);
}
Mesh3d CreateWall(Vector2 start, Vector2 end, Quaternion rotation, Vector3 position, Vector3 color)
{
var terrain3dManager = Object3dGenerator.CreateGround(start, end, new Vector2(1), Vector3.UnitY);
var terrain3dInfo = new Object3dInfo(terrain3dManager.Vertices);
var terrainMaterial = new GenericMaterial();
terrainMaterial.DiffuseColor = color;
terrainMaterial.SpecularColor = Vector3.Zero;
terrainMaterial.Roughness = 0f;
var terrainMesh = Mesh3d.Create(terrain3dInfo, terrainMaterial);
terrainMesh.GetInstance(0).Rotate(rotation);
return(terrainMesh);
}
private ParticleGenerator(GeneratorMode mode, Vector3 position, Quaternion orientation, Vector3 initialVelocity, Vector3 gravity, float scale, float bounciness, float alphaDecrease, Vector2 planeSize, Vector3 boxSize)
{
Mode = mode;
Position = position;
Orientation = orientation;
InitialVelocity = initialVelocity;
Gravity = gravity;
Bounciness = bounciness;
PlaneSize = planeSize;
BoxSize = boxSize;
Scale = scale;
AlphaDecrease = alphaDecrease;
Info3d = Generators.Object3dGenerator.CreateGround(new Vector2(-1, -1), new Vector2(1, 1), new Vector2(1), Vector3.UnitY);
Program = ShaderProgram.Compile("ParticleGenerator.vertex.glsl", "ParticleGenerator.fragment.glsl");
DepthWriter = ShaderProgram.Compile("ParticleGenerator.vertex.glsl", "ParticleGeneratorWriteDepth.fragment.glsl");
TimeRate = 9.0f / 1000000.0f;
TimeToLife = 9.0f;
MaxInstances = 1000000;
StartTime = DateTime.Now;
Tex = new Texture(Media.Get("smoke.png"));
}
private static void SaveCache(Vector2 start, Vector2 end, Vector2 uvScale, Vector3 normal, int subdivisions, Object3dInfo info3d)
{
if(!UseCache)
return;
string filename = start.X.ToString() + start.Y.ToString() + end.X.ToString() + end.Y.ToString() +
uvScale.X.ToString() + uvScale.Y.ToString() + normal.X.ToString() + normal.Y.ToString() + normal.Z.ToString() +
subdivisions.ToString();
if(!Directory.Exists("terrain_generator_cache"))
Directory.CreateDirectory("terrain_generator_cache");
Object3dInfo.CompressAndSaveSingle(info3d, "terrain_generator_cache/" + filename);
}
public static Object3dInfo CreateTerrain(Vector2 start, Vector2 end, Vector2 uvScale, Vector3 normal, int subdivisions, Func<uint, uint, float> heightGenerator)
{
var cache = GetCachedOrNull(start, end, uvScale, normal, subdivisions);
if(cache != null)
return cache;
var VBO = new List<float>();
var VBOParts = new List<float[]>();
var indices = new List<uint>();
uint count = 0, x, y;
float partx1, partx2, party1, party2;
float[] vertex1, vertex2, vertex3, vertex4;
uint xp1, yp1;
Vector3 normal1;
for(x = 0; x < subdivisions; x++)
{
for(y = 0; y < subdivisions; y++)
{
xp1 = x + 1;
yp1 = y + 1;
partx1 = (float)x / subdivisions;
party1 = (float)y / subdivisions;
partx2 = (float)(xp1) / subdivisions;
party2 = (float)(yp1) / subdivisions;
vertex1 = GetTerrainVertex(start, end, uvScale, normal, x, y, partx1, party1, heightGenerator);
vertex2 = GetTerrainVertex(start, end, uvScale, normal, xp1, y, partx2, party1, heightGenerator);
vertex3 = GetTerrainVertex(start, end, uvScale, normal, x, yp1, partx1, party2, heightGenerator);
vertex4 = GetTerrainVertex(start, end, uvScale, normal, xp1, yp1, partx2, party2, heightGenerator);
normal1 = -Vector3.Cross(GetVector(vertex2) - GetVector(vertex1),
GetVector(vertex3) - GetVector(vertex1)).Normalized();
uint[] indicesPart = {
count, count+1, count+2, count+3, count+2, count+1
};
VBOParts.Add(new float[] { vertex3[0], vertex3[1], vertex3[2], vertex3[3], vertex3[4], normal1.X, normal1.Y, normal1.Z });
VBOParts.Add(new float[] { vertex4[0], vertex4[1], vertex4[2], vertex4[3], vertex4[4], normal1.X, normal1.Y, normal1.Z });
VBOParts.Add(new float[] { vertex1[0], vertex1[1], vertex1[2], vertex1[3], vertex1[4], normal1.X, normal1.Y, normal1.Z });
VBOParts.Add(new float[] { vertex2[0], vertex2[1], vertex2[2], vertex2[3], vertex2[4], normal1.X, normal1.Y, normal1.Z });
indices.AddRange(indicesPart);
count += 4;
}
//GC.Collect();
}
GC.Collect();
for(int i = 0; i < VBOParts.Count; i++)
{
for(int g = i < 8 ? 0 : i - 8; g < (i + 8 > VBOParts.Count ? VBOParts.Count : i + 8); g++)
{
if(i != g)
{
if(VBOParts[i][0] == VBOParts[g][0] && VBOParts[i][1] == VBOParts[g][1] && VBOParts[i][2] == VBOParts[g][2])
//if(GetVector(VBOParts[i]) == GetVector(VBOParts[g]))
{
Vector3 n = Vector3.Lerp(GetNormal(VBOParts[i]), GetNormal(VBOParts[g]), 0.5f);
VBOParts[i][5] = n.X;
VBOParts[i][6] = n.Y;
VBOParts[i][7] = n.Z;
VBOParts[g][5] = n.X;
VBOParts[g][6] = n.Y;
VBOParts[g][7] = n.Z;
}
}
}
if(i > subdivisions * 4 + 8)
for(int g = i - subdivisions * 4 - 8; g < (i - subdivisions * 4 + 8 > VBOParts.Count ? VBOParts.Count : i - subdivisions * 4 + 8); g++)
{
if(i != g)
{
if(VBOParts[i][0] == VBOParts[g][0] && VBOParts[i][1] == VBOParts[g][1] && VBOParts[i][2] == VBOParts[g][2])
//if(GetVector(VBOParts[i]) == GetVector(VBOParts[g]))
{
Vector3 n = Vector3.Lerp(GetNormal(VBOParts[i]), GetNormal(VBOParts[g]), 0.5f);
VBOParts[i][5] = n.X;
VBOParts[i][6] = n.Y;
VBOParts[i][7] = n.Z;
VBOParts[g][5] = n.X;
VBOParts[g][6] = n.Y;
VBOParts[g][7] = n.Z;
}
}
}
if(i < VBOParts.Count - subdivisions * 4 - 8)
for(int g = i + subdivisions * 4 - 8; g < (i + subdivisions * 4 + 8 > VBOParts.Count ? VBOParts.Count : i + subdivisions * 4 + 8); g++)
{
if(i != g)
{
if(VBOParts[i][0] == VBOParts[g][0] && VBOParts[i][1] == VBOParts[g][1] && VBOParts[i][2] == VBOParts[g][2])
//if(GetVector(VBOParts[i]) == GetVector(VBOParts[g]))
{
Vector3 n = Vector3.Lerp(GetNormal(VBOParts[i]), GetNormal(VBOParts[g]), 0.5f);
VBOParts[i][5] = n.X;
VBOParts[i][6] = n.Y;
VBOParts[i][7] = n.Z;
VBOParts[g][5] = n.X;
VBOParts[g][6] = n.Y;
VBOParts[g][7] = n.Z;
}
}
}
}
for(int i = 0; i < VBOParts.Count; i++)
{
VBO.AddRange(VBOParts[i]);
}
var finalObject = new Object3dInfo(VBO, indices);
SaveCache(start, end, uvScale, normal, subdivisions, finalObject);
return finalObject;
}
public static void Create()
{
var lucyobj = new Object3dInfo(Object3dManager.LoadFromObjSingle(Media.Get("sph1.obj")).Vertices);
var bbmaterial = new GenericMaterial();
bbmaterial.Roughness = 0;
bbmaterial.DiffuseColor = Vector3.Zero;
bbmaterial.SpecularColor = Vector3.One;
var lucy = Mesh3d.Create(lucyobj, bbmaterial);
lucy.ClearInstances();
lucy.AutoRecalculateMatrixForOver16Instances = true;
Game.World.Scene.Add(lucy);
Commons.PickedMesh = lucy;
Commons.Picked = null;
int cnt = 0, din = 256;
Renderer pp = new Renderer(din, din, 1);
pp.GraphicsSettings.UseDeferred = true;
pp.GraphicsSettings.UseRSM = false;
pp.GraphicsSettings.UseVDAO = true;
pp.GraphicsSettings.UseFog = false;
pp.GraphicsSettings.UseBloom = false;
pp.GraphicsSettings.UseCubeMapGI = false;
Game.DisplayAdapter.MainRenderer.CubeMaps.Clear();
var internalMapping = new Dictionary <Renderer.CubeMapInfo, CubeMapFramebuffer>();
/*
* for(float x = -10; x < 13; x += 4.0f)
* {
* for(float y = 0.2f; y < 15.3f; y += 6.0f)
* {
* for(float z = -3; z < 3.5; z += 3.0f)
* {
* CubeMapFramebuffer cubens = new CubeMapFramebuffer(din, din);
*
* cubens.SetPosition(x*0.98f - 0.35f, y, z - 0.25f);
*
* lucy.AddInstance(new Mesh3dInstance(new TransformationManager(cubens.GetPosition(), Quaternion.Identity, 0.1f), "cubemap-marker-" + cnt.ToString()));
* var info = new Renderer.CubeMapInfo()
* {
* FalloffScale = 5.0f,
* Texture = cubens.Texture,
* Position = cubens.GetPosition()
* };
* Game.DisplayAdapter.MainRenderer.CubeMaps.Add(info);
* internalMapping.Add(info, cubens);
* cnt++;
* }
* }
* }*/
for (int i = 0; i < 100; i++)
{
CubeMapFramebuffer cubens = new CubeMapFramebuffer(din, din);
cubens.SetPosition(0, i, 0);
lucy.AddInstance(new Mesh3dInstance(new TransformationManager(cubens.GetPosition(), Quaternion.Identity, 0.1f), "cubemap-marker-" + cnt.ToString()));
var info = new Renderer.CubeMapInfo()
{
FalloffScale = 7.0f,
Texture = cubens.Texture,
Position = cubens.GetPosition()
};
Game.DisplayAdapter.MainRenderer.CubeMaps.Add(info);
internalMapping.Add(info, cubens);
cnt++;
}
int index = 0;
bool livemode = false;
Game.OnKeyUp += (xa, eargs) =>
{
if (eargs.Key == OpenTK.Input.Key.PageUp)
{
index++;
}
if (eargs.Key == OpenTK.Input.Key.PageDown)
{
index--;
}
if (index > 9)
{
index = 0;
}
if (index < 0)
{
index = 9;
}
if (Commons.Picked == null)
{
index = 0;
}
Commons.Picked = lucy.GetInstance(index);
TitleOutput.Message = "Picked cubemap ID " + index.ToString();
if (eargs.Key == OpenTK.Input.Key.End)
{
livemode = !livemode;
}
if (eargs.Key == OpenTK.Input.Key.Insert)
{
for (int i = 0; i < cnt; i++)
{
Game.DisplayAdapter.MainRenderer.CubeMaps[i].Position *= -1;
internalMapping[Game.DisplayAdapter.MainRenderer.CubeMaps[i]].Clear();
}
}
if (eargs.Key == OpenTK.Input.Key.Home)
{
var cpos = Camera.MainDisplayCamera.GetPosition();
/*
* float angle = 0;
* for(int i = 0; i < cnt; i++)
* {
* float prc = (float)i / (float)cnt;
* angle += 2.39996322f;
* var disp = new Vector3(prc * 15.0f * (float)Math.Sin(angle), 1.0f - prc * 3.0f, prc * 15.0f * (float)Math.Cos(angle));
* lucy.GetInstance(i).SetPosition(cpos + disp);
* }*/
for (int x = 0; x < 10; x++)
{
for (int y = 0; y < 10; y++)
{
int i = y + x * 10;
lucy.GetInstance(i).SetPosition(cpos + new Vector3(x - 5, 0, y - 5) * 2);
}
}
}
if (eargs.Key == OpenTK.Input.Key.Up)
{
Game.DisplayAdapter.MainRenderer.CubeMaps[index].FalloffScale += 0.1f;
}
if (eargs.Key == OpenTK.Input.Key.Down)
{
Game.DisplayAdapter.MainRenderer.CubeMaps[index].FalloffScale -= 0.1f;
if (Game.DisplayAdapter.MainRenderer.CubeMaps[index].FalloffScale < 0.02)
{
Game.DisplayAdapter.MainRenderer.CubeMaps[index].FalloffScale = 0.02f;
}
}
};
int ix = 0;
Game.OnBeforeDraw += (od, dsd) =>
{
// for(int i = 0; i < 23; i++)
// {
// if((lucy.GetInstance(i).GetPosition() - Game.DisplayAdapter.MainRenderer.CubeMaps[i].Position).Length > 0.01f)
// {
var cubes = Game.DisplayAdapter.MainRenderer.CubeMaps;
if (!livemode)
{
for (int iz = 0; iz < cnt; iz++)
{
if ((lucy.GetInstance(iz).GetPosition() - cubes[iz].Position).Length > 0.01f)
{
//internalMapping[cubes[iz]].Clear();
}
}
for (int iz = 0; iz < cnt; iz++)
{
if ((lucy.GetInstance(iz).GetPosition() - cubes[iz].Position).Length > 0.01f)
{
Game.World.CurrentlyRenderedCubeMap = iz;
pp.CubeMaps = cubes;
cubes[iz].Position = lucy.GetInstance(iz).GetPosition();
internalMapping[cubes[iz]].SetPosition(lucy.GetInstance(iz).GetPosition());
pp.RenderToCubeMapFramebuffer(internalMapping[cubes[iz]]);
internalMapping[cubes[iz]].GenerateMipMaps();
Game.World.CurrentlyRenderedCubeMap = -1;
}
}
return;
}
int i = ix++;
if (ix >= cnt)
{
ix = 0;
}
Game.World.CurrentlyRenderedCubeMap = i;
pp.CubeMaps = cubes;
cubes[i].Position = lucy.GetInstance(i).GetPosition();
internalMapping[cubes[i]].SetPosition(lucy.GetInstance(i).GetPosition());
pp.RenderToCubeMapFramebuffer(internalMapping[cubes[i]]);
internalMapping[cubes[i]].GenerateMipMaps();
Game.World.CurrentlyRenderedCubeMap = -1;
// }
// }
};
}
public PhysicsTest()
{
var scene = Game.World.Scene;
Game.Invoke(() =>
{
Object3dInfo point3dinfo = new Object3dInfo(new VertexInfo[] { new VertexInfo()
{
Position = Vector3.One,
Normal = Vector3.UnitZ,
UV = Vector2.Zero
} });
Object3dInfo point3dinfo2 = Object3dGenerator.CreateCube(Vector3.One * 0.1f, Vector2.One).AsObject3dInfo();
OpenTK.Graphics.OpenGL4.GL.PointSize(111);
GenericMaterial whitemat = new GenericMaterial()
{
DiffuseColor = Vector3.One
};
Mesh3d points = Mesh3d.Create(point3dinfo2, whitemat);
//point3dinfo.DrawMode = OpenTK.Graphics.OpenGL4.PrimitiveType.Points;
//whitemat.CustomShaderProgram = ShaderProgram.Compile("Points.vertex.glsl", "Points.fragment.glsl");
points.ClearInstances();
ComputeShader updateShader = new ComputeShader("PhysicsUpdater.compute.glsl");
ShaderStorageBuffer pointsBuffer = new ShaderStorageBuffer();
var parts = new List <Particle>();
List <byte> bytes = new List <byte>();
for (int i = 0; i < 1024 * 2; i++)
{
var part = new Particle()
{
Position = new Vector3(rand(-20, 20), rand(0, 20), rand(-10, 10)),
Velocity = Vector3.Zero
};
points.AddInstance(new TransformationManager(part.Position));
bytes.AddRange(BitConverter.GetBytes(part.Position.X));
bytes.AddRange(BitConverter.GetBytes(part.Position.Y));
bytes.AddRange(BitConverter.GetBytes(part.Position.Z));
bytes.AddRange(BitConverter.GetBytes(part.Position.X));
bytes.AddRange(BitConverter.GetBytes(part.Velocity.X));
bytes.AddRange(BitConverter.GetBytes(part.Velocity.Y));
bytes.AddRange(BitConverter.GetBytes(part.Velocity.Z));
bytes.AddRange(BitConverter.GetBytes(part.Velocity.X));
}
pointsBuffer.MapData(bytes.ToArray());
pointsBuffer.Use(9);
Game.OnBeforeDraw += (z, x) =>
{
updateShader.Use();
pointsBuffer.Use(9);
updateShader.SetUniform("ParticlesCount", 1024 * 2);
updateShader.Dispatch(2, 1, 1);
pointsBuffer.Use(9);
};
points.UpdateMatrix();
scene.Add(points);
});
}
