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);
}
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);
}
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();
}
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);
}
