internal GaussianBlurTechnique(
ShaderProgram postVertProg, ShaderProgram blurFragProg,
int iterations, float sampleScale, RenderScene scene, Logger logger = null)
{
if (postVertProg == null)
{
throw new ArgumentNullException(nameof(postVertProg));
}
if (blurFragProg == null)
{
throw new ArgumentNullException(nameof(blurFragProg));
}
if (scene == null)
{
throw new NullReferenceException(nameof(scene));
}
this.iterations = iterations;
this.scene = scene;
//Create renderers (2 so we can ping-pong between two targets)
rendererHor = new Renderer(scene, logger);
rendererHor.AddSpecialization(true); //IsHorizontal
rendererHor.AddSpecialization(sampleScale);
rendererVer = new Renderer(scene, logger);
rendererVer.AddSpecialization(false); //NOT IsHorizontal
rendererVer.AddSpecialization(sampleScale);
//Add a full-screen object to both renderers
renderObject = new AttributelessObject(scene, vertexCount: 3, new TextureInfo[0]);
rendererHor.AddObject(renderObject, postVertProg, blurFragProg, debugName: "horizontal");
rendererVer.AddObject(renderObject, postVertProg, blurFragProg, debugName: "vertical");
}
public void Initialize(ContentManager Content)
{
// Create a new render scene
RenderScene = new RenderScene();
// Create the default package
if (!Content.Packages.ContainsKey(ChessGame.DefaultPackage))
{
ContentPackage newPackage = new ContentPackage(ChessGame.DefaultPackage);
Content.Add(newPackage);
}
// Load the content
ContentPackage package = Content.Packages[ChessGame.DefaultPackage];
CreateBoardModels(package);
CreatePieceMaterials(package);
CreatePieceModels(package);
CreateSelector(package);
// Place the pieces
PlacePieces();
// Place the lights
PlaceLights();
cameraObject.Position = InitialCameraPosition;
}
internal static DeviceBuffer UploadData <T>(
ReadOnlyMemory <T> data,
RenderScene scene,
BufferUsages usages) where T : struct
{
return(UploadData <T>(data.Span, scene, usages));
}
public void RestoreScene(RenderScene scene)
{
foreach (var gameObject in scene)
{
RestoreGameObject(gameObject);
}
}
internal BoxBlurTechnique(
ShaderProgram postVertProg, ShaderProgram blurFragProg,
int sampleRange, float sampleScale, RenderScene scene, Logger logger = null)
{
if (postVertProg == null)
{
throw new ArgumentNullException(nameof(postVertProg));
}
if (blurFragProg == null)
{
throw new ArgumentNullException(nameof(blurFragProg));
}
if (scene == null)
{
throw new NullReferenceException(nameof(scene));
}
this.scene = scene;
//Setup renderer
renderer = new Renderer(scene, logger);
renderer.AddSpecialization(sampleRange);
renderer.AddSpecialization(sampleScale);
//Add a full-screen object to the renderer
renderObject = new AttributelessObject(scene, vertexCount: 3, new TextureInfo[0]);
renderer.AddObject(renderObject, postVertProg, blurFragProg, debugName: "fullscreen");
}
public CommandMoveList(RenderScene scene, List <RenderBase> lists)
: base(scene, "")
{
foreach (RenderBase render in lists)
{
commands.Add(new CommandMove(scene, render));
}
}
public RenderTexture Render(RenderScene scene, RenderTexture texture)
{
PrepareScene(scene);
var tex = Render(texture);
RestoreScene(scene);
return(tex);
}
protected override RenderScene Apply(SIGProcessingContext context)
{
if (scene1 == null && scene2 == null)
{
return(RenderScene.Empty);
}
return(merge ? RenderScene.Merge(scene1, scene2) : scene1);
}
protected override void Process(SIGProcessingContext context)
{
output = Apply(context);
if (debug)
{
AddMessage("Output: " + output.ToString(), NodeMessageType.Info);
}
else
{
RemoveMessageContains("Output: ");
}
}
public void PrepareScene(RenderScene scene)
{
if (sceneLayerStore == null)
{
sceneLayerStore = new Queue <int>(scene.Count);
}
foreach (var gameObject in scene)
{
PrepareGameObject(gameObject);
}
}
internal static DeviceBuffer UploadData <T>(
ReadOnlySpan <T> data,
RenderScene scene,
BufferUsages usages) where T : struct
{
return(UploadData <T>(
data,
scene.LogicalDevice,
scene.MemoryPool,
usages,
scene.StagingBuffer,
scene.Executor));
}
public static void loadViewToScene(String path, RenderScene scene)
{
scene.removeAllChild();
String absPath = UIProject.Instance().GetRealFile(path);
String content = FileHelper.GetFullContent(absPath);
XElement xml = XmlHelper.Parse(content);
if (xml == null)
{
return;
}
scene.getAttrByXml(xml);
scene.Refresh();
}
protected override RenderScene Apply(SIGProcessingContext context)
{
List <GameObject> results = new List <GameObject>();
foreach (var go in input)
{
var result = Find(go.transform, searchName, recurse);
if (result != null)
{
results.Add(result.gameObject);
}
}
return(RenderScene.FromList(results));
}
protected void activeRenderChange(object sender, object e)
{
RenderDock dock = sender as RenderDock;
RenderScene scene = e as RenderScene;
if (dock != null && scene != null)
{
this.actionDock = dock;
this.renderScene = scene;
}
else if (scene == null && dock == this.actionDock)
{
this.actionDock = null;
this.renderScene = null;
}
reloadSceneInfo();
}
public void RegisterWithScene(RenderScene scene)
{
if (RenderScene == scene && Registered)
{
return;
}
else if (RenderScene != scene && Registered)
{
UnregisterWithScene();
RenderScene = scene;
}
if (!Resource.IsLoaded)
{
return;
}
Registered = true;
}
internal BloomTechnique(
GBufferTechnique gbufferTechnique,
ShaderProgram postVertProg, ShaderProgram bloomFragProg, ShaderProgram gaussBlurFragProg,
RenderScene scene,
Logger logger = null)
{
if (gbufferTechnique == null)
{
throw new NullReferenceException(nameof(gbufferTechnique));
}
if (postVertProg == null)
{
throw new ArgumentNullException(nameof(postVertProg));
}
if (bloomFragProg == null)
{
throw new ArgumentNullException(nameof(bloomFragProg));
}
if (gaussBlurFragProg == null)
{
throw new ArgumentNullException(nameof(gaussBlurFragProg));
}
if (scene == null)
{
throw new NullReferenceException(nameof(scene));
}
this.gbufferTechnique = gbufferTechnique;
this.scene = scene;
//Create renderer for rendering the bloom texture
renderer = new Renderer(scene, logger);
//Add full-screen object for drawing the composition
renderObject = new AttributelessObject(scene, vertexCount: 3, new TextureInfo[0]);
renderer.AddObject(renderObject, postVertProg, bloomFragProg, debugName: "fullscreen");
//Create a BlurTechnique for blurring the bloom texture
blurTechnique = new GaussianBlurTechnique(
postVertProg,
gaussBlurFragProg,
blurIterations,
blurSampleScale,
scene,
logger);
}
public static void Run(INativeApp nativeApp, Logger logger = null)
{
using (var taskRunner = new TaskRunner(logger))
using (var host = new Host(nativeApp, appName: "Test", appVersion: 1, logger: logger))
using (var window = host.CreateWindow(windowSize: (1280, 720), deviceRequirements))
{
RenderScene scene = new RenderScene(window,
reflectionTexture: new TextureInfo(LoadTex("textures/skybox.cube")),
postVertProg: LoadProg("shaders/bin/post_fullscreen.vert.spv"),
bloomFragProg: LoadProg("shaders/bin/post_bloom.frag.spv"),
aoFragProg: LoadProg("shaders/bin/post_ambientocclusion.frag.spv"),
gaussBlurFragProg: LoadProg("shaders/bin/post_blur_gaussian.frag.spv"),
boxBlurFragProg: LoadProg("shaders/bin/post_blur_box.frag.spv"),
compositionFragProg: LoadProg("shaders/bin/post_baselighting.frag.spv"), logger);
window.AttachScene(scene);
//Add terrain to the scene
AddTerrain(nativeApp, taskRunner, scene, renderOrder: 900,
textureSources: new []
internal RoadCollection(
RoadTopology topology,
AssetLoadContext loadContext,
HeightMap heightMap,
RenderScene scene)
: this()
{
// The map stores road segments with no connectivity:
// - a segment is from point A to point B
// - with a road type name
// - and start and end curve types (angled, tight curve, broad curve).
// The goal is to create road networks of connected road segments,
// where a network has only a single road type.
// A road network is composed of 2 or more nodes.
// A network is a (potentially) cyclic graph.
// A road node has > 1 and <= 4 edges connected to it.
// A node can be part of multiple networks.
// An edge can only exist in one network.
var roadTemplateList = new RoadTemplateList(loadContext.AssetStore.RoadTemplates);
var networks = RoadNetwork.BuildNetworks(topology, roadTemplateList);
var renderBucket = scene.CreateRenderBucket("Roads", 10);
foreach (var network in networks)
{
var road = AddDisposable(
new Road(
loadContext,
heightMap,
network));
renderBucket.AddObject(road);
_roads.Add(road);
}
}
private void Render()
{
Gl.glViewport(0, 0, Width, Height);
var vp = new[] { 0f, 0f, 0f, 0f };
Gl.glGetFloatv(Gl.GL_VIEWPORT, vp);
float aspect = (vp[2] - vp[0]) / (vp[3] - vp[1]);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Glu.gluPerspective(90.0f, aspect, 0.02f, 32.0f);
Gl.glTranslatef(0, 0, -dist);
Gl.glRotatef(elev, 1, 0, 0);
Gl.glRotatef(ang, 0, 1, 0);
if (RenderScene != null)
{
RenderScene.Invoke();
}
}
public override void SetValue(object component, object value)
{
if (component is RenderBase)
{
RenderBase render = component as RenderBase;
RenderScene scene = render.getRenderScene();
render.recordOriStatus();
mProp.SetValue(component, value);
if (scene == null)
{
return;
}
if (mProp.Name == "pos")
{
scene.commandManager.AddCommand(new CommandMove(scene, render));
}
else if (mProp.Name == "size")
{
scene.commandManager.AddCommand(new CommandResize(scene, render));
}
else if (mProp.Name == "anchorPos")
{
scene.commandManager.AddCommand(new CommandAnchorPos(scene, render));
}
else if (mProp.Name == "scale")
{
scene.commandManager.AddCommand(new CommandScale(scene, render));
}
else if (mProp.Name == "Tag")
{
EventManager.RaiserEvent(Constant.RenderItemChange, scene, null);
}
scene.checkModifyStatus();
}
else
{
mProp.SetValue(component, value);
}
}
internal GBufferTechnique(
RenderScene scene,
Logger logger = null)
{
if (scene == null)
{
throw new NullReferenceException(nameof(scene));
}
this.scene = scene;
//Create buffer for storing camera transformations
cameraBuffer = new Memory.HostBuffer(
scene.LogicalDevice, scene.MemoryPool, BufferUsages.UniformBuffer,
size: CameraData.SIZE * scene.SwapchainCount);
//Create renderer for rendering into the g-buffer targets
renderer = new Renderer(scene, logger);
renderer.AddSpecialization(scene.SwapchainCount);
renderer.AddSpecialization(false); //NOT IsShadow
swapchainIndexPushDataBinding = renderer.AddPushData <int>();
}
private static void Main(string [] args)
{
RenderScene Scene = new RenderScene( );
Sphere S = new Sphere
{
Position = new Vector3(0, 0, -40),
Radius = 1
};
Scene.AddRendererObject(S);
RenderSettings Settings = new RaytracerSettings( );
Renderer R = new Raytracer( );
R.SetData(Scene, Settings);
RendererImage Render = R.Render( );
Bitmap Bmp = Render.ConvertToBitmap( );
Bmp.Save("D:\\Temp\\tempimg.png");
Process.Start("D:\\Temp\\tempimg.png");
Console.ReadLine( );
}
public static RenderScene Merge(RenderScene a, RenderScene b)
{
if (a == null && b == null)
{
return(RenderScene.Empty);
}
if (a == null || a.Count <= 0)
{
return(b);
}
if (b == null || b.Count <= 0)
{
return(a);
}
var collection = new RenderObjectCollection(a.Count + b.Count);
a.CopyTo(collection, 0);
b.CopyTo(collection, a.Count);
return(collection);
}
public void Initialize(Player player, RenderScene scene)
{
this.player = player;
if (player == Chess.Player.White)
{
renderNode = new Graphics.RenderNode()
{
Model = scene.Models[ModelNameWhite]
}
}
;
else if (player == Chess.Player.Black)
{
renderNode = new Graphics.RenderNode()
{
Model = scene.Models[ModelNameBlack]
}
}
;
UpdateTransform();
}
internal AmbientOcclusionTechnique(
GBufferTechnique gbufferTechnique,
ShaderProgram postVertProg, ShaderProgram aoFragProg, ShaderProgram boxBlurFragProg,
RenderScene scene,
Logger logger = null)
{
if (gbufferTechnique == null)
{
throw new NullReferenceException(nameof(gbufferTechnique));
}
if (postVertProg == null)
{
throw new ArgumentNullException(nameof(postVertProg));
}
if (aoFragProg == null)
{
throw new ArgumentNullException(nameof(aoFragProg));
}
if (boxBlurFragProg == null)
{
throw new ArgumentNullException(nameof(boxBlurFragProg));
}
if (scene == null)
{
throw new NullReferenceException(nameof(scene));
}
this.gbufferTechnique = gbufferTechnique;
this.scene = scene;
this.logger = logger;
//Create renderer for rendering the ao texture
renderer = new Renderer(scene, logger);
renderer.AddSpecialization(scene.SwapchainCount);
renderer.AddSpecialization(sampleKernelSize);
renderer.AddSpecialization(sampleRadius);
renderer.AddSpecialization(sampleBias);
swapchainIndexPushDataBinding = renderer.AddPushData <int>();
targetSizePushBinding = renderer.AddPushData <Int2>();
//Create random for generating the kernel and noise (using a arbitrary fixed seed)
IRandom random = new ShiftRandom(seed: 1234);
//Create the sample kernel
Span <Float4> sampleKernel = stackalloc Float4[sampleKernelSize];
GenerateSampleKernel(random, sampleKernel);
sampleKernelBuffer = DeviceBuffer.UploadData <Float4>(
sampleKernel, scene, BufferUsages.UniformBuffer);
//Create the rotation noise texture
Float4Texture rotationNoiseTexture = TextureUtils.CreateRandomFloatTexture(
random, min: (-1f, -1f, 0f, 0f), max: (1f, 1f, 0f, 0f), size: (noiseSize, noiseSize));
rotationNoiseSampler = new DeviceSampler(scene.LogicalDevice,
texture: DeviceTexture.UploadTexture(rotationNoiseTexture, scene),
repeat: true,
pointFilter: true);
//Add full-screen object for drawing the composition
renderObject = new AttributelessObject(scene, vertexCount: 3, new TextureInfo[0]);
renderer.AddObject(renderObject, postVertProg, aoFragProg, debugName: "fullscreen");
//Create a BlurTechnique for blurring the ao texture (to hide the ao sample pattern)
blurTechnique = new BoxBlurTechnique(
postVertProg,
boxBlurFragProg,
blurSampleRange,
sampleScale: 1f,
scene,
logger);
}
public CommandBase(RenderScene scene, String uniqueName)
{
this.renderScene = scene;
this.uniqueName = uniqueName;
}
public CommandMove(RenderScene scene, RenderBase render)
: base(scene, render.uniqueName)
{
this._orign = render.oriPos;
this._finish = render.pos;
}
public static void loadViewToScene(XElement xml, RenderScene scene)
{
scene.removeAllChild();
scene.getAttrByXml(xml);
scene.Refresh();
}
/// <summary>
/// Renders a scene into an off-screen buffer and creates a finished bitmap of the results</summary>
/// <param name="paintCallback">The delegate for rendering the scene. The correct
/// OpenGl rendering context is set prior to executing this delegate.</param>
/// <returns>A bitmap of the desired width and height that shows the rendered image</returns>
public Bitmap CreateBitmap(RenderScene paintCallback)
{
if (OpenGlCore.FrameBufferObjectSupported)
{
// Set up a FBO with one renderbuffer attachment and one depth buffer attachment.
Gl.glGenFramebuffersEXT(1, out m_framebuffer);
Gl.glBindFramebufferEXT(Gl.GL_FRAMEBUFFER_EXT, m_framebuffer);
Gl.glGenRenderbuffersEXT(1, out m_renderbuffer);
Gl.glBindRenderbufferEXT(Gl.GL_RENDERBUFFER_EXT, m_renderbuffer);
Gl.glRenderbufferStorageEXT(Gl.GL_RENDERBUFFER_EXT, Gl.GL_RGBA8, m_width, m_height);
Gl.glFramebufferRenderbufferEXT(Gl.GL_FRAMEBUFFER_EXT, Gl.GL_COLOR_ATTACHMENT0_EXT, Gl.GL_RENDERBUFFER_EXT, m_renderbuffer);
Gl.glGenFramebuffersEXT(1, out m_depthBuffer);
Gl.glBindRenderbufferEXT(Gl.GL_RENDERBUFFER_EXT, m_depthBuffer);
Gl.glRenderbufferStorageEXT(Gl.GL_RENDERBUFFER_EXT, Gl.GL_DEPTH_COMPONENT24, m_width, m_height);
Gl.glFramebufferRenderbufferEXT(Gl.GL_FRAMEBUFFER_EXT, Gl.GL_DEPTH_ATTACHMENT_EXT, Gl.GL_RENDERBUFFER_EXT, m_depthBuffer);
int status = Gl.glCheckFramebufferStatusEXT(Gl.GL_FRAMEBUFFER_EXT);
if (status != Gl.GL_FRAMEBUFFER_COMPLETE_EXT)
throw new InvalidOperationException("couldn't create frame buffer object");
}
else
{
m_form = new Form();
m_form.ClientSize = new Size(Width, Height);
m_form.Controls.Add(this);
}
Gl.glPushAttrib(Gl.GL_VIEWPORT_BIT);
Gl.glViewport(0, 0, m_width, m_height);
//Util3D.ReportErrors();
base.BeginPaint();
paintCallback();
base.EndPaint();
// Allocate a bitmap with its own memory.
// Panel3D uses 32 bits for the frame buffer. We don't need the alpha channel.
System.Drawing.Imaging.PixelFormat pixelFormat =
System.Drawing.Imaging.PixelFormat.Format24bppRgb;
Bitmap bitmap = new Bitmap(m_width, m_height, pixelFormat);
// Copy pixels
BitmapData lockedPixelData = null;
try
{
lockedPixelData = bitmap.LockBits(
new Rectangle(0, 0, m_width, m_height),
ImageLockMode.ReadWrite,
pixelFormat);
// Read from the default OpenGl frame buffer into the Bitmap's pixels.
// The given coordinates are from the lower-left corner and will need
// to be flipped vertically.
IntPtr pixels = lockedPixelData.Scan0;
Gl.glReadPixels(
0, 0,
m_width, m_height,
Gl.GL_BGR_EXT,
Gl.GL_UNSIGNED_BYTE,
pixels);
//Util3D.ReportErrors();
}
finally
{
if (lockedPixelData != null)
bitmap.UnlockBits(lockedPixelData);
}
//Util3D.ReportErrors();
Gl.glPopAttrib();
if (OpenGlCore.FrameBufferObjectSupported)
{
Gl.glBindFramebufferEXT(Gl.GL_FRAMEBUFFER_EXT, 0);
// Clean-up
Gl.glDeleteRenderbuffersEXT(1, ref m_depthBuffer);
Gl.glDeleteRenderbuffersEXT(1, ref m_renderbuffer);
Gl.glDeleteFramebuffersEXT(1, ref m_framebuffer);
//Util3D.ReportErrors();
}
bitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
return bitmap;
}
public CommandAdd(RenderScene scene, RenderBase opItem)
: base(scene, opItem.uniqueName)
{
xml = UIHelper.generateXmlByItem(opItem);
parentUnique = opItem.getParent().uniqueName;
}
public CommandResize(RenderScene scene, RenderBase render)
: base(scene, render.uniqueName)
{
this._orign = render.oriSize;
this._finish = render.size;
}
