private Texture2D GenerateFruitTexture()
{
TextureBuilder texturer = new TextureBuilder();
int size = m_fruit_texture_size;
// Randomize colors
Color fruitColor = new Color(Random.Range(0.1f, 0.9f), Random.Range(0.1f, 0.9f), Random.Range(0.1f, 0.9f), 1.0f);
texturer.ColorTexture(size, fruitColor);
int randPattern = Random.Range(0, 3);
switch (randPattern)
{
case 0:
texturer.AddPerlinNoise(Random.Range(2.0f, 100.0f), 0.2f, -0.5f);
break;
case 1:
Color fruitColor1 = new Color(Random.Range(0.1f, 0.9f), Random.Range(0.1f, 0.9f), Random.Range(0.1f, 0.9f), 1.0f);
texturer.OverlaySolidNoise(fruitColor1, Random.Range(0.1f, 0.9f), Random.Range(1.0f, 50.0f), Vector2.zero, 1.0f);
break;
case 2:
Color fruitColor2 = new Color(Random.Range(0.1f, 0.9f), Random.Range(0.1f, 0.9f), Random.Range(0.1f, 0.9f), 1.0f);
texturer.OverlayStripes(fruitColor2, Random.Range(1.0f, 10.0f), Random.Range(0.2f, 0.8f), Random.Range(0.0f, 180.0f), 1.0f);
break;
}
texturer.GetTexture().Apply();
return(texturer.GetTexture());
}
public void UpdateTexture(TextureType type)
{
Texture2D tex = TextureBuilder.GetTexture(type);
renderer.sharedMaterial.mainTexture = tex;
Debug.Log("Changed Texture");
}
static void Main(string[] args)
{
var generator = new Generator();
var world = generator.GenerateWorld(80, 32, Random.Next(int.MaxValue));
byte[] jsonUtf8GZipped = world.ToJsonUTF8GZipped(true);
// write to json
if (FileHandling.TryWriteJsonUTF8GZipped(jsonUtf8GZipped))
{
Console.WriteLine("Success Writing jsonUtf8");
}
// build a texture
if (TextureBuilder.TryGenerateBitmap(world, out Bitmap bitmap))
{
Console.WriteLine("Success Building Bitmap");
// write to .bmp
if (FileHandling.TryWriteImageToBitmap(bitmap))
{
Console.WriteLine("Success Writing Bitmap");
}
}
}
public Saplings(byte id, string name, TextureBuilder tex)
{
ID = id;
Name = name;
UseMetadata = true;
_tex = tex;
}
static void Init()
{
// Get existing open window or if none, make a new one:
TextureBuilder window = (TextureBuilder)EditorWindow.GetWindow(typeof(TextureBuilder));
window.minSize = new Vector2(320, 384);
window.maxSize = new Vector2(320, 384);
window.Show();
}
private void BuildMapTexture()
{
mapTexture = new TextureBuilder(mapData);
Material meshMaterial = renderer.material;
Shader matShader = Shader.Find("Transparent/Cutout/Diffuse");
meshMaterial.shader = matShader;
}
private void BuildMapTexture()
{
mapTexture = new TextureBuilder(mapData);
Material meshMaterial = renderer.material;
Shader matShader = Shader.Find("Transparent/Cutout/Diffuse");
meshMaterial.shader = matShader;
}
void GenerateTile()
{
// generate a new height map
float[,] heightMap = NoiseGenerator.GenerateNoiseMap(noiseSampleSize, scale, waves, offset);
float[,] hdHeigthMap = NoiseGenerator.GenerateNoiseMap(noiseSampleSize - 1, scale, waves, offset, textureResolution);
Vector3[] verts = tileMeshFilter.mesh.vertices;
for (int x = 0; x < noiseSampleSize; x++)
{
for (int z = 0; z < noiseSampleSize; z++)
{
int index = (x * noiseSampleSize) + z;
verts[index].y = heightCurve.Evaluate(heightMap[x, z]) * maxHeight;
}
}
tileMeshFilter.mesh.vertices = verts;
tileMeshFilter.mesh.RecalculateBounds();
tileMeshFilter.mesh.RecalculateNormals();
tileMeshCollider.sharedMesh = tileMeshFilter.mesh;
float[,] heatMap = GenerateHeatMap(heightMap);
float[,] moistureMap = GenerateMoistureMap(heightMap);
TerrainType[,] heatTerrainTypeMap = TextureBuilder.CreateTerrainTypeMap(heatMap, heatTerrainTypes);
TerrainType[,] moistureTerrainTypeMap = TextureBuilder.CreateTerrainTypeMap(moistureMap, moistureTerrainTypes);
switch (visualizationType)
{
case TerrainVisualization.Height:
tileMeshRenderer.material.mainTexture = TextureBuilder.BuildTexture(hdHeigthMap, heightTerrainTypes);
break;
case TerrainVisualization.Heat:
tileMeshRenderer.material.mainTexture = TextureBuilder.BuildTexture(heatMap, heatTerrainTypes);
break;
case TerrainVisualization.Moisture:
tileMeshRenderer.material.mainTexture = TextureBuilder.BuildTexture(moistureMap, moistureTerrainTypes);
break;
case TerrainVisualization.Biome:
tileMeshRenderer.material.mainTexture = BiomeBuilder.instance.BuildTexture(heatTerrainTypeMap, moistureTerrainTypeMap);
break;
}
CreateDataMap(heatTerrainTypeMap, moistureTerrainTypeMap);
TreeSpawner.instance.Spawn(dataMap);
}
private Texture2D GenerateTrunkTexture(int size)
{
TextureBuilder texturer = new TextureBuilder();
// Randomize colors
Color treeColor = new Color(0.36f, 0.27f, 0.18f, 1.0f);
Color treeColorVar = new Color(0.1f, 0.1f, 0.1f, 0.0f);
Color treeColorSpecial = new Color(0.5f, 0.5f, 0.5f, 1.0f);
Color treeColorSpecialVar = new Color(0.4f, 0.4f, 0.4f, 1.0f);
float specialChance = 0.1f;
Color[] randomTreeColors = new Color[4];
if (Random.Range(0.00f, 1.00f) > specialChance)
{
// Use normal values
randomTreeColors[0] = new Color(Random.Range(treeColor.r - treeColorVar.r, treeColor.r + treeColorVar.r),
Random.Range(treeColor.g - treeColorVar.g, treeColor.g + treeColorVar.g),
Random.Range(treeColor.b - treeColorVar.b, treeColor.b + treeColorVar.b), 1.0f);
for (int i = 1; i <= 3; i++)
{
randomTreeColors[i] = randomTreeColors[0] * new Color(Random.Range(treeColor.r - treeColorVar.r, treeColor.r + treeColorVar.r),
Random.Range(treeColor.g - treeColorVar.g, treeColor.g + treeColorVar.g),
Random.Range(treeColor.b - treeColorVar.b, treeColor.b + treeColorVar.b), 1.0f);
}
}
else
{
// Use special values
randomTreeColors[0] = new Color(Random.Range(treeColorSpecial.r - treeColorSpecialVar.r, treeColorSpecial.r + treeColorSpecialVar.r),
Random.Range(treeColorSpecial.g - treeColorSpecialVar.g, treeColorSpecial.g + treeColorSpecialVar.g),
Random.Range(treeColorSpecial.b - treeColorSpecialVar.b, treeColorSpecial.b + treeColorSpecialVar.b), 1.0f);
for (int i = 1; i <= 3; i++)
{
randomTreeColors[i] = randomTreeColors[0] * new Color(Random.Range(treeColorSpecial.r - treeColorSpecialVar.r, treeColorSpecial.r + treeColorSpecialVar.r),
Random.Range(treeColorSpecial.g - treeColorSpecialVar.g, treeColorSpecial.g + treeColorSpecialVar.g),
Random.Range(treeColorSpecial.b - treeColorSpecialVar.b, treeColorSpecial.b + treeColorSpecialVar.b), 1.0f);
}
}
texturer.ColorTexture(size, randomTreeColors[0]);
//texturer.AddPerlinNoise(50.0f,0.5f,-0.5f);
//for (int i = 0; i < 4; i++) {
// texturer.OverlaySolidNoise(m_tree_colors[i+1],m_color_thresholds[i],m_noise_scales[i],m_noise_offsets[i],m_noise_opacity[i]);
//}
texturer.OverlayStripes(randomTreeColors[1], 8.0f, 0.2f, 75.0f, 0.7f);
texturer.OverlayStripes(randomTreeColors[2], 10.0f, 0.4f, 80.0f, 0.7f);
texturer.GetTexture().Apply();
return(texturer.GetTexture());
}
private void GenerateRockMaterial()
{
TextureBuilder texturer = new TextureBuilder();
Color rockColor = new Color(0.4f, 0.4f, 0.4f, 1.0f);
texturer.ColorTexture(128, rockColor);
texturer.OverlayStripes(rockColor * 0.8f, 16, 0.4f, 0.0f, 1.0f);
Texture2D rockTex = texturer.GetTexture();
rockMat = new Material("Default");
rockMat.shader = Shader.Find("Diffuse");
rockTex.Apply();
rockMat.SetTexture("_MainTex", rockTex);
}
private void GenerateGrassMaterial()
{
TextureBuilder texturer = new TextureBuilder();
Color grassColor = new Color(0.22f, 0.64f, 0.1f, 1.0f);
texturer.ColorTexture(256, grassColor);
texturer.OverlayStripes(grassColor * 0.8f, 16, 0.4f, 0.0f, 1.0f);
texturer.CutOutGrassShape(32);
Texture2D grassTex = texturer.GetTexture();
grassMat = new Material("Default");
grassMat.shader = Shader.Find("Transparent/Cutout/Diffuse");
grassTex.mipMapBias = -0.5f;
grassTex.Apply();
grassMat.SetTexture("_MainTex", grassTex);
}
private static Texture LoadNormalMap(Engine engine, byte[] normals)
{
var imageResult = ImageResult.FromMemory(normals, ColorComponents.RedGreenBlue);
var normalMap = TextureBuilder.Create()
.WithWidth(imageResult.Width)
.WithHeight(imageResult.Height)
.WithLevels(0xFF)
.WithFormat(TextureFormat.Rgb8)
.Build(engine);
var descriptor = new PixelBufferDescriptor(imageResult.Data, PixelDataFormat.Rgb, PixelDataType.UByte);
normalMap.SetImage(engine, 0, descriptor);
normalMap.GenerateMipmaps(engine);
return(normalMap);
}
void OnChangedTexture(TextureType type)
{
if (type == TextureType.Tectonic || type == TextureType.Height)
{
displayInertia = true;
}
else
{
displayInertia = false;
}
Texture2D tex = TextureBuilder.GetTexture(type);
Sprite spr = Sprite.Create(tex, new Rect(Vector2.zero, new Vector2(tex.width, tex.height)), Vector2.zero);
image.sprite = spr;
dropdown.value = ((int)type);
Debug.Log("UI Recived ChangeTexture Signal");
}
private static Texture CreateSplatTexture(Engine engine)
{
// To generate a Gaussian splat, create a single-channel 3x3 texture with a bright pixel in
// its center, then magnify it using a Gaussian filter kernel.
var splat = new LinearImage(3, 3, 1);
splat.SetPixelData(1, 1, 0.25f);
splat = ImageSampler.ResampleImage(splat, TEXTURE_SIZE, TEXTURE_SIZE, ImageSamplerFilter.GaussianScalars);
var buffer = new PixelBufferDescriptor(splat, PixelDataFormat.R, PixelDataType.Float);
var texture = TextureBuilder.Create()
.WithWidth(TEXTURE_SIZE)
.WithHeight(TEXTURE_SIZE)
.WithLevels(1)
.WithSampler(TextureSamplerType.Texture2d)
.WithFormat(TextureFormat.R32F)
.Build(engine);
texture.SetImage(engine, 0, buffer);
return(texture);
}
public void createTexture()
{
cardInfo.texInfo = TextureBuilder.ChopUpAllTextures(cardInfo.texInfo);
cardImage = TextureBuilder.BuildTexture(cardInfo);
GetComponent <Renderer>().material.mainTexture = cardImage;
}
public static void Generate(int detailLevel)
{
//Get Number of Cells
int cellNr = 20;
if (detailLevel > 0)
{
for (int i = 0; i <= detailLevel; i++)
{
cellNr = cellNr * 4;
}
}
// Instanciate Clean Arrays
World.Cells = new Cell[cellNr];
World.CellPoints = new CellPoint[cellNr * 3];
World.CellColor = new Color[cellNr];
World.CellTecID = new UInt16[cellNr];
World.Height = new float[cellNr];
cellList = new List <Cell>();
points = new List <CellPoint>();
Icosahedron();
for (var i = 0; i < detailLevel; i++)
{
Subdivide(true);
}
/// normalize vectors to "inflate" the icosahedron into a sphere.
for (var i = 0; i < vectors.Count; i++)
{
vectors[i] = Vector3.Normalize(vectors[i]);
points.Add(new CellPoint(vectors[i]));
}
//Generate Cells
int id = 0;
for (int i = 0; i < indices.Count; i++)
{
if (i % 3 == 0)
{
id = i / 3;
cellList.Add(new Cell((uint)id));
//Debug.Log("Cell " + id + " added");
}
cellList[id].Vertexes.Add((uint)indices[i]);
points[indices[i]].Cells.Add((uint)id);
}
// Center Cells
foreach (Cell c in cellList)
{
Vector3 vec = Vector3.zero;
foreach (int nr in c.Vertexes)
{
vec += points[nr].Vector;
}
c.Location = vec / 3;
//Debug.Log("Cell ID " + c.Id + " centered at " + (vec / 3).ToString());
}
World.Cells = cellList.ToArray();
World.CellPoints = points.ToArray();
CheckConnections();
TextureBuilder.NewTextures();
//Set Scale
SetWorldScale();
}
public void createTexture()
{
texInfo = TextureBuilder.ChopUpAllTextures(texInfo);
//GetComponent<Renderer>().material.mainTexture = TextureBuilder.BuildTexture(texInfo); ;
}
public void chopTexture()
{
texColors = TextureBuilder.ChopUpTiles(this);
}
static void Main(string[] args)
{
Texture texture = null;
Skybox skybox = null;
VertexBuffer vertexBuffer = null;
IndexBuffer indexBuffer = null;
Material material = null;
MaterialInstance materialInstance = null;
Camera camera = null;
int cameraEntity = -1;
int renderable = -1;
var app = new Application(
new WindowConfig()
{
Title = "texturedquad"
},
new ApplicationConfig()
);
app.Setup = (engine, view, scene) => {
var path = Path.Combine(app.RootAssetPath, "textures/Moss_01/Moss_01_Color.png");
if (!File.Exists(path))
{
Console.WriteLine("The texture {0} does not exist", path);
Environment.Exit(1);
}
using (var stream = File.OpenRead(path)) {
var imageResult = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
Console.WriteLine("Loaded texture: {0}x{1}", imageResult.Width, imageResult.Height);
var pixelBuffer = new PixelBufferDescriptor(imageResult.Data, PixelDataFormat.Rgba, PixelDataType.UByte);
texture = TextureBuilder.Create()
.WithWidth(imageResult.Width)
.WithHeight(imageResult.Height)
.WithLevels(1)
.WithSampler(TextureSamplerType.Texture2d)
.WithFormat(TextureFormat.Rgba8)
.Build(engine);
texture.SetImage(engine, 0, pixelBuffer);
}
// Set up view
skybox = SkyboxBuilder.Create()
.WithColor(new Color(0.1f, 0.125f, 0.25f, 1.0f))
.Build(engine);
scene.Skybox = skybox;
cameraEntity = EntityManager.Create();
camera = engine.CreateCamera(cameraEntity);
view.PostProcessingEnabled = false;
view.Camera = camera;
// Create quad renderable
var vbo = new VertexBufferObject();
vbo.Write(new Vector2(-1, -1));
vbo.Write(new Vector2(0, 0));
vbo.Write(new Vector2(1, -1));
vbo.Write(new Vector2(1, 0));
vbo.Write(new Vector2(-1, 1));
vbo.Write(new Vector2(0, 1));
vbo.Write(new Vector2(1, 1));
vbo.Write(new Vector2(1, 1));
vertexBuffer = VertexBufferBuilder.Create()
.WithVertexCount(4)
.WithBufferCount(1)
.WithAttribute(VertexAttribute.Position, 0, ElementType.Float2, 0, 16)
.WithAttribute(VertexAttribute.Uv0, 0, ElementType.Float2, 8, 16)
.Build(engine);
vertexBuffer.SetBufferAt(engine, 0, vbo);
var sampleData = new SampleDataLoader();
indexBuffer = IndexBufferBuilder.Create()
.WithIndexCount(6)
.WithBufferType(IndexType.UShort)
.Build(engine);
indexBuffer.SetBuffer(engine, QUAD_INDICES);
material = MaterialBuilder.Create()
.WithPackage(sampleData.LoadBakedTexture())
.Build(engine);
var sampler = new TextureSampler(SamplerMinFilter.Linear, SamplerMagFilter.Linear);
materialInstance = material.CreateInstance();
materialInstance.SetParameter("albedo", texture, sampler);
renderable = EntityManager.Create();
RenderableBuilder.Create()
.WithBoundingBox(
new Box(
new Vector3(-1, -1, -1),
new Vector3(1, 1, 1)
)
)
.WithMaterial(0, materialInstance)
.WithGeometry(0, PrimitiveType.Triangles, vertexBuffer, indexBuffer, 0, 6)
.WithCulling(false)
.WithReceiveShadows(false)
.WithCastShadows(false)
.Build(engine, renderable);
scene.AddEntity(renderable);
};
app.Cleanup = (engine, view, scene) => {
engine.Destroy(skybox);
engine.Destroy(renderable);
engine.Destroy(materialInstance);
engine.Destroy(material);
engine.Destroy(texture);
engine.Destroy(vertexBuffer);
engine.Destroy(indexBuffer);
engine.DestroyCameraComponent(cameraEntity);
EntityManager.Destroy(cameraEntity);
};
app.Animate = (engine, view, now) => {
var zoom = 2.0f + 2.0f * MathF.Sin(now);
var width = view.Viewport.Width;
var height = view.Viewport.Height;
var aspect = (float)width / (float)height;
camera.SetProjection(Projection.Ortho,
-aspect * zoom, aspect * zoom,
-zoom, zoom,
-1, 1
);
};
app.Run();
}
public BufferPanel()
{
textureBuilder = new TextureBuilder(PerlinOptions.RandomNoise);
this.DoubleBuffered = true;
}
static void Main(string[] args)
{
Texture offscreenColorTexture = null;
Texture offscreenDepthTexture = null;
Filament.RenderTarget offscreenRenderTarget = null;
View offscreenView = null;
Scene offscreenScene = null;
Camera offscreenCamera = null;
int lightEntity = -1;
Material meshMaterial = null;
MaterialInstance meshMatInstance = null;
Mesh monkeyMesh = null;
int reflectedMonkey = -1;
Matrix4x4 transform = Matrix4x4.Identity;
int quadEntity = -1;
Vector3 quadCenter = Vector3.Zero;
Vector3 quadNormal = Vector3.Zero;
VertexBuffer quadVb = null;
IndexBuffer quadIb = null;
Material quadMaterial = null;
MaterialInstance quadMatInstance = null;
ReflectionMode mode = ReflectionMode.Camera;
var app = new Application(
new WindowConfig()
{
Title = "rendertarget",
},
new ApplicationConfig()
);
app.Setup = (engine, view, scene) => {
var tcm = engine.TransformManager;
var rcm = engine.RenderableManager;
var vp = view.Viewport;
var resourceData = new SampleDataLoader();
var monkeyData = new MonkeyDataLoader();
// Instantiate offscreen render target.
offscreenScene = engine.CreateScene();
offscreenView = engine.CreateView();
offscreenView.Scene = offscreenScene;
offscreenView.PostProcessingEnabled = false;
offscreenColorTexture = TextureBuilder.Create()
.WithWidth(vp.Width)
.WithHeight(vp.Height)
.WithLevels(1)
.WithUsage(TextureUsage.ColorAttachment | TextureUsage.Sampleable)
.WithFormat(TextureFormat.Rgba8)
.Build(engine);
offscreenDepthTexture = TextureBuilder.Create()
.WithWidth(vp.Width)
.WithHeight(vp.Height)
.WithLevels(1)
.WithUsage(TextureUsage.DepthAttachment)
.WithFormat(TextureFormat.Depth24)
.Build(engine);
offscreenRenderTarget = RenderTargetBuilder.Create()
.WithTexture(AttachmentPoint.Color, offscreenColorTexture)
.WithTexture(AttachmentPoint.Depth, offscreenDepthTexture)
.Build(engine);
offscreenView.RenderTarget = offscreenRenderTarget;
offscreenView.Viewport = new Viewport(0, 0, vp.Width, vp.Height);
offscreenCamera = engine.CreateCamera(EntityManager.Create());
offscreenView.Camera = offscreenCamera;
app.AddOffscreenView(offscreenView);
// Position and orient the mirror in an interesting way.
var c = quadCenter = new Vector3(-2, 0, -5);
var n = quadNormal = Vector3.Normalize(new Vector3(1, 0, 2));
var u = Vector3.Normalize(Vector3.Cross(quadNormal, new Vector3(0, 1, 0)));
var v = Vector3.Cross(n, u);
u = 1.5f * u;
v = 1.5f * v;
Vertex[] kQuadVertices =
{
new() { Position = c - u - v, Uv = new Vector2(1, 0) },
new() { Position = c + u - v, Uv = new Vector2(0, 0) },
new() { Position = c - u + v, Uv = new Vector2(1, 1) },
new() { Position = c + u + v, Uv = new Vector2(0, 1) },
};
var vbo = new byte[20 * 4];
MemoryStream vboStream = new MemoryStream(vbo);
BinaryWriter vboWriter = new BinaryWriter(vboStream);
vboWriter.Write(kQuadVertices[0].Position.X);
vboWriter.Write(kQuadVertices[0].Position.Y);
vboWriter.Write(kQuadVertices[0].Position.Z);
vboWriter.Write(kQuadVertices[0].Uv.X);
vboWriter.Write(kQuadVertices[0].Uv.Y);
vboWriter.Write(kQuadVertices[1].Position.X);
vboWriter.Write(kQuadVertices[1].Position.Y);
vboWriter.Write(kQuadVertices[1].Position.Z);
vboWriter.Write(kQuadVertices[1].Uv.X);
vboWriter.Write(kQuadVertices[1].Uv.Y);
vboWriter.Write(kQuadVertices[2].Position.X);
vboWriter.Write(kQuadVertices[2].Position.Y);
vboWriter.Write(kQuadVertices[2].Position.Z);
vboWriter.Write(kQuadVertices[2].Uv.X);
vboWriter.Write(kQuadVertices[2].Uv.Y);
vboWriter.Write(kQuadVertices[3].Position.X);
vboWriter.Write(kQuadVertices[3].Position.Y);
vboWriter.Write(kQuadVertices[3].Position.Z);
vboWriter.Write(kQuadVertices[3].Uv.X);
vboWriter.Write(kQuadVertices[3].Uv.Y);
// Create quad vertex buffer.
quadVb = VertexBufferBuilder.Create()
.WithVertexCount(4)
.WithBufferCount(1)
.WithAttribute(VertexAttribute.Position, 0, ElementType.Float3, 0, 20)
.WithAttribute(VertexAttribute.Uv0, 0, ElementType.Float2, 12, 20)
.Build(engine);
quadVb.SetBufferAt(engine, 0, vbo);
// Create quad index buffer.
var kQuadIndices = new ushort[] { 0, 1, 2, 3, 2, 1 };
quadIb = IndexBufferBuilder.Create()
.WithIndexCount(6)
.WithBufferType(IndexType.UShort)
.Build(engine);
quadIb.SetBuffer(engine, kQuadIndices);
// Create quad material and renderable.
quadMaterial = MaterialBuilder.Create()
.WithPackage(resourceData.LoadMirror())
.Build(engine);
quadMatInstance = quadMaterial.CreateInstance();
var sampler = new TextureSampler(SamplerMinFilter.Linear, SamplerMagFilter.Linear);
quadMatInstance.SetParameter("albedo", offscreenColorTexture, sampler);
quadEntity = EntityManager.Create();
RenderableBuilder.Create()
.WithBoundingBox(
new Box(
new Vector3(-1, -1, -1),
new Vector3(1, 1, 1)
)
)
.WithMaterial(0, quadMatInstance)
.WithGeometry(0, PrimitiveType.Triangles, quadVb, quadIb, 0, 6)
.WithCulling(false)
.WithReceiveShadows(false)
.WithCastShadows(false)
.Build(engine, quadEntity);
scene.AddEntity(quadEntity);
// Instantiate mesh material.
meshMaterial = MaterialBuilder.Create()
.WithPackage(resourceData.LoadAiDefaultMat())
.Build(engine);
var mi = meshMatInstance = meshMaterial.CreateInstance();
mi.SetParameter("baseColor", RgbType.Linear, new Color(0.8f, 1.0f, 1.0f));
mi.SetParameter("metallic", 0.0f);
mi.SetParameter("roughness", 0.4f);
mi.SetParameter("reflectance", 0.5f);
// Add monkey into the scene.
monkeyMesh = MeshReader.LoadFromBuffer(engine, monkeyData.LoadSuzanne(), mi);
var ti = tcm.GetInstance(monkeyMesh.Renderable);
transform = Matrix4x4.CreateTranslation(0, 0, -4) * tcm.GetWorldTransform(ti);
rcm.SetCastShadows(rcm.GetInstance(monkeyMesh.Renderable), false);
scene.AddEntity(monkeyMesh.Renderable);
// Create a reflected monkey, which is used only for ReflectionMode::RENDERABLES.
reflectedMonkey = EntityManager.Create();
RenderableBuilder.Create()
.WithBoundingBox(
new Box(
new Vector3(-2, -2, -2),
new Vector3(2, 2, 2)
)
)
.WithMaterial(0, mi)
.WithGeometry(0, PrimitiveType.Triangles, monkeyMesh.VertexBuffer, monkeyMesh.IndexBuffer)
.WithReceiveShadows(true)
.WithCastShadows(false)
.Build(engine, reflectedMonkey);
mode = SetReflectionMode(offscreenScene, offscreenView, reflectedMonkey, monkeyMesh, ReflectionMode.Camera);
// Add light source to both scenes.
// NOTE: this is slightly wrong when the reflection mode is RENDERABLES.
lightEntity = EntityManager.Create();
LightBuilder.Create(LightType.Sun)
.WithColor(Color.ToLinearAccurate(new sRGBColor(0.98f, 0.92f, 0.89f)))
.WithIntensity(110000)
.WithDirection(new Vector3(0.7f, -1, -0.8f))
.WithSunAngularRadius(1.9f)
.WithCastShadows(false)
.Build(engine, lightEntity);
scene.AddEntity(lightEntity);
offscreenScene.AddEntity(lightEntity);
};
private bool LoadCubemapLevel(ref Texture texture, out PixelBufferDescriptor outBuffer, out FaceOffsets outOffsets, string path, int level, string levelPrefix)
{
int size = 0;
int numLevels = 1;
outBuffer = null;
outOffsets = new FaceOffsets();
{
string faceName = levelPrefix + FaceSuffix[0] + ".rgb32f";
string facePath = Path.Combine(path, faceName);
if (!File.Exists(facePath))
{
Console.WriteLine("The face {0} does not exist", facePath);
return(false);
}
var imageInfo = ImageInfo.FromStream(File.OpenRead(facePath));
if (imageInfo.Value.Width != imageInfo.Value.Height)
{
Console.WriteLine("width != height");
return(false);
}
size = imageInfo.Value.Width;
numLevels = 1;
if (string.IsNullOrEmpty(levelPrefix))
{
numLevels = (int)MathF.Log2(size) + 1;
}
if (level == 0)
{
texture = TextureBuilder.Create()
.WithWidth(size)
.WithHeight(size)
.WithLevels(numLevels)
.WithFormat(TextureFormat.R11F_G11F_B10F)
.WithSampler(TextureSamplerType.Cubemap)
.Build(_engine);
}
}
// RGB_10_11_11_REV encoding: 4 bytes per pixel
var faceSize = size * size * Marshal.SizeOf <uint>();
FaceOffsets offsets = new FaceOffsets();
byte[] pixelBuffer = new byte[faceSize * 6];
var success = true;
for (var j = 0; j < 6; j++)
{
outOffsets[j] = faceSize * j;
string faceName = levelPrefix + FaceSuffix[j] + ".rgb32f";
string facePath = Path.Combine(path, faceName);
if (!File.Exists(facePath))
{
Console.WriteLine("The face {0} does not exist", facePath);
success = false;
break;
}
var imageResult = ImageResult.FromStream(File.OpenRead(facePath), ColorComponents.RedGreenBlueAlpha);
if (imageResult.Width != imageResult.Height || imageResult.Width != size)
{
Console.WriteLine("Face {0} has a wrong size {1}x{2}, instead of {3}x{3}", faceName, imageResult.Width, imageResult.Height, size);
success = false;
break;
}
if (imageResult.SourceComp != ColorComponents.RedGreenBlueAlpha)
{
Console.WriteLine("Could not decode face {0}", faceName);
success = false;
break;
}
Array.Copy(imageResult.Data, 0, pixelBuffer, offsets[j], imageResult.Width * imageResult.Height * Marshal.SizeOf <uint>());
}
if (!success)
{
return(false);
}
outBuffer = new PixelBufferDescriptor(pixelBuffer, PixelDataFormat.Rgb, PixelDataType.UInt_10F_11F_11F_Rev);
return(true);
}
private Texture2D GenerateLeafTexture(int size)
{
TextureBuilder texturer = new TextureBuilder();
Color leafColor = new Color(0.1f, 0.5f, 0.1f, 1.0f);
if (m_leaf_randomize_colors)
{
/*
* Color[] randomColors = new Color[4];
* randomColors[0] = new Color(Random.Range(0.2f,0.8f),Random.Range(0.2f,0.8f),Random.Range(0.2f,0.8f),1.0f);
* for(int i = 1; i <= 3; i++) {
* randomColors[i] = randomColors[0]*new Color(Random.Range(0.2f,0.8f),Random.Range(0.2f,0.8f),Random.Range(0.2f,0.8f),1.0f);
* }
* texturer.Color4GridTexture(size,randomColors);
*/
Color[] randomColors = new Color[4];
if (Random.Range(0.00f, 1.00f) > specialChance)
{
// Use normal values
randomColors[0] = new Color(Random.Range(leafColor.r - treeColorVar.r, leafColor.r + treeColorVar.r),
Random.Range(leafColor.g - treeColorVar.g, leafColor.g + treeColorVar.g),
Random.Range(leafColor.b - treeColorVar.b, leafColor.b + treeColorVar.b), 1.0f);
for (int i = 1; i <= 3; i++)
{
randomColors[i] = randomColors[0] * new Color(Random.Range(leafColor.r - treeColorVar.r, leafColor.r + treeColorVar.r),
Random.Range(leafColor.g - treeColorVar.g, leafColor.g + treeColorVar.g),
Random.Range(leafColor.b - treeColorVar.b, leafColor.b + treeColorVar.b), 1.0f);
}
}
else
{
// Use special values
randomColors[0] = new Color(Random.Range(treeColorSpecial.r - treeColorSpecialVar.r, treeColorSpecial.r + treeColorSpecialVar.r),
Random.Range(treeColorSpecial.g - treeColorSpecialVar.g, treeColorSpecial.g + treeColorSpecialVar.g),
Random.Range(treeColorSpecial.b - treeColorSpecialVar.b, treeColorSpecial.b + treeColorSpecialVar.b), 1.0f);
for (int i = 1; i <= 3; i++)
{
randomColors[i] = randomColors[0] * new Color(Random.Range(treeColorSpecial.r - treeColorSpecialVar.r, treeColorSpecial.r + treeColorSpecialVar.r),
Random.Range(treeColorSpecial.g - treeColorSpecialVar.g, treeColorSpecial.g + treeColorSpecialVar.g),
Random.Range(treeColorSpecial.b - treeColorSpecialVar.b, treeColorSpecial.b + treeColorSpecialVar.b), 1.0f);
}
}
texturer.Color4GridTexture(size, randomColors);
}
else
{
texturer.Color4GridTexture(size, m_leaf_colors);
}
//texturer.OverlaySolidNoise(m_leaf_color-new Color(0.3f,0.3f,0.3f,0.0f),0.5f,20.0f,new Vector2(0.0f,0.0f),1.0f);
//texturer.OverlaySolidNoise(m_leaf_color,0.6f,20.0f,new Vector2(0.0f,0.0f),1.0f);
if (m_leaf_randomize_shape)
{
texturer.CutOutLeafShape(1, 8, true);
}
else
{
// Default leaf shape
TextureBuilder.LeafCurvePoint[] leafPoints = new TextureBuilder.LeafCurvePoint[2];
//Vector2 up = new Vector2(0.0f,0.1f);
//Vector2 down = new Vector2(0.0f,-0.1f);
leafPoints[0].start = new Vector2(0.5f, 0.0f);
leafPoints[0].mid1 = leafPoints[0].start + new Vector2(0.0f, 0.5f);
leafPoints[0].end = new Vector2(0.2f, 0.7f);
leafPoints[0].mid2 = leafPoints[0].end + new Vector2(0.0f, -0.5f);
leafPoints[1].start = new Vector2(0.2f, 0.7f);
leafPoints[1].mid1 = leafPoints[1].start + new Vector2(0.2f, -0.3f);
leafPoints[1].end = new Vector2(0.5f, 1.0f);
leafPoints[1].mid2 = leafPoints[1].end + new Vector2(-0.1f, -0.3f);
texturer.CutOutLeafShape(leafPoints, 2, true);
}
texturer.GetTexture().Apply();
return(texturer.GetTexture());
}
