private static unsafe Memory *AllocGraphicsMemoryBuffer(IntPtr data_ptr, int data_size)
{
var data = Bgfx.alloc((uint)data_size);
Unsafe.CopyBlockUnaligned(data->data, data_ptr.ToPointer(), (uint)data_size);
return(data);
}
private static unsafe Memory *GetMemoryBufferReference <T>(T[] array)
{
var size = (uint)(array.Length * Unsafe.SizeOf <T>());
var data = Bgfx.make_ref(Unsafe.AsPointer(ref array[0]), size);
return(data);
}
public static void Reset(int width, int height, ResetFlags resetFlags, TextureFormat format)
{
unsafe
{
Bgfx.reset((uint)width, (uint)height, (uint)resetFlags, format);
}
}
public static void SetModelTransform(ref Mat4 transform)
{
Bgfx.set_transform(
Unsafe.AsPointer(ref transform.M11),
1
);
}
public static void SetTransientIndexBuffer(TransientIndexBuffer index_buffer, int first_index, int num_indices)
{
unsafe
{
Bgfx.set_transient_index_buffer(&index_buffer, (uint)first_index, (uint)num_indices);
}
}
public static void SetTransientVertexBuffer(byte stream, TransientVertexBuffer vertex_buffer, int start_vertex, int num_vertices)
{
unsafe
{
Bgfx.set_transient_vertex_buffer(stream, &vertex_buffer, (uint)start_vertex, (uint)num_vertices);
}
}
public static IntPtr MakeRef(IntPtr data, uint size)
{
unsafe
{
return(new IntPtr(Bgfx.make_ref(data.ToPointer(), size)));
}
}
public static DynamicVertexBufferHandle CreateDynamicVertexBuffer(Vertex[] vertices, VertexLayout layout, BufferFlags flags = BufferFlags.None)
{
var memory = GetMemoryBufferReference(vertices);
var dyn_vertex_buffer = Bgfx.create_dynamic_vertex_buffer_mem(memory, &layout.InternalHandle, (ushort)flags);
return(dyn_vertex_buffer);
}
private unsafe void ImplSubmitValues()
{
for (int i = 0; i < Parameters.Length; ++i)
{
var p = Parameters[i];
if (p.ArrayLength == 0)
{
continue;
}
if (p.Constant)
{
if (p.SubmitedOnce)
{
continue;
}
else
{
p.SubmitedOnce = true;
}
}
var val = p.Value;
Bgfx.SetUniform(p.Uniform, &val);
}
}
internal GraphicsContext(IntPtr graphics_surface_ptr, int width, int height)
{
var timer = Stopwatch.StartNew();
Bgfx.SetPlatformData(new PlatformData
{
WindowHandle = graphics_surface_ptr
});
var bgfx_callback_handler = new BgfxCallbackHandler();
var settings = new InitSettings
{
Backend = RendererBackend.Default,
ResetFlags = ResetFlags.Vsync,
Width = width,
Height = height,
CallbackHandler = bgfx_callback_handler
};
Bgfx.Init(settings);
Console.WriteLine($" > GFX INIT : {timer.Elapsed.TotalSeconds.ToString()}");
var caps = Bgfx.GetCaps();
Info = new GraphicsInfo(caps.Backend, caps.MaxTextureSize);
Console.WriteLine($"GRAPHICS BACKEND : {Info.RendererBackend.ToString()}");
index_buffers = new IndexBuffer[16];
}
public bool ProcessEvents(ResetFlags resetFlags)
{
Event ev;
bool resizeRequired = false;
while ((ev = eventQueue.Poll()) != null)
{
switch (ev.Type)
{
case EventType.Exit:
return(false);
case EventType.Size:
var size = (SizeEvent)ev;
WindowWidth = size.Width;
WindowHeight = size.Height;
resizeRequired = true;
break;
}
}
if (resizeRequired)
{
Bgfx.Reset(WindowWidth, WindowHeight, resetFlags);
}
return(true);
}
/////////////////////////////////////////
static string GetCacheFileName()
{
if (Bgfx.GetCurrentBackend() == RendererBackend.Noop)
{
return("");
}
string folder = PathUtility.Combine(VirtualFileSystem.Directories.Project, @"Caches\ShaderCache");
string name = "";
if (Bgfx.GetCurrentBackend() == RendererBackend.Direct3D11 || Bgfx.GetCurrentBackend() == RendererBackend.Direct3D12)
{
name = "Direct3D11";
}
else if (Bgfx.GetCurrentBackend() == RendererBackend.OpenGLES)
{
name = "OpenGLES";
}
else if (Bgfx.GetCurrentBackend() == RendererBackend.Vulkan)
{
name = "Vulkan";
}
else
{
Log.Fatal("GpuProgramManager: Shader model is not specified. Bgfx.GetCurrentBackend() == {0}.", Bgfx.GetCurrentBackend());
}
return(Path.Combine(folder, name + ".cache"));
//return Path.Combine( folder, Bgfx.GetCurrentBackend().ToString() + ".cache" );
}
public bool ProcessEvents(ResetFlags resetFlags)
{
WindowEvent?ev;
var reset = false;
while ((ev = window.Poll()) != null)
{
var e = ev.Value;
switch (e.Type)
{
case WindowEventType.Exit:
return(false);
case WindowEventType.Size:
WindowWidth = e.Width;
WindowHeight = e.Height;
reset = true;
break;
}
}
if (reset)
{
Bgfx.Reset(WindowWidth, WindowHeight, resetFlags);
}
return(true);
}
internal static int CallBgfxFrame()
{
int result = Bgfx.Frame();
UpdateOcclusionQuery();
return(result);
}
public static DynamicIndexBufferHandle CreateDynamicIndexBuffer(ushort[] indices, BufferFlags flags = BufferFlags.None)
{
var memory = GetMemoryBufferReference(indices);
var dyn_index_buffer = Bgfx.create_dynamic_index_buffer_mem(memory, (ushort)flags);
return(dyn_index_buffer);
}
internal void RenderingProcess_SetRenderState(RenderOperationType renderOperation, bool canWriteRGBA)
{
if (needUpdate)
{
Update();
}
//!!!!что-то еще выставлять?
var renderOperationState = ConvertRenderOperation(renderOperation);
RenderState state = cachedState | renderOperationState;
int colorRGBA = 0;
// <param name="colorRgba">The color used for "factor" blending modes.</param>
if (advancedBlendingWriteMask != uint.MaxValue)
{
state |= RenderState.BlendIndependent;
colorRGBA = (int)advancedBlendingWriteMask;
}
if (!canWriteRGBA)
{
state &= ~(RenderState.WriteRGB | RenderState.WriteA);
}
Bgfx.SetRenderState(state, colorRGBA);
//Bgfx.SetRenderState( cachedState | renderOperationState | RenderState.Multisampling, colorRGBA );
}
public void WindowMovedOrResized(Vector2I size) // bool fullScreen )//, Vec2I windowSize )
{
if (Disposed)
{
return;
}
EngineThreading.CheckMainThread();
this.size = size;
//!!!!по идее не во всех графических API надо пересоздавать
if (thisIsApplicationWindow)
{
Bgfx.Reset(size.X, size.Y, RenderingSystem.GetApplicationWindowResetFlags());
}
else
{
frameBuffer.Dispose();
frameBuffer = new FrameBuffer(windowHandle, size.X, size.Y);
}
//update aspect ratio
foreach (Viewport viewport in viewports)
{
viewport.UpdateAspectRatio();
}
}
private unsafe void ImplDrawSurface(RenderSurface surface, int index)
{
var vertex_buffer = new TransientVertexBuffer(4, Vertex2DLayout);
fixed(void *v = surface.Vertices)
{
Unsafe.CopyBlock((void *)vertex_buffer.Data, v, (uint)(4 * Vertex2D.Stride));
}
var pass = (byte)(max_render_pass + index + 1);
gfx.SetViewport(pass, 0, 0, Game.Instance.ScreenSize.W, Game.Instance.ScreenSize.H);
var proj = screen_projection;
gfx.SetProjection(pass, &proj.M11);
//gfx.SetClearColor(pass, Color.Blue);
Bgfx.SetTexture(0, current_shader_program.Samplers[0], surface.RenderTarget.NativeTexture, TextureFlags.FilterPoint | TextureFlags.ClampUVW);
Bgfx.SetRenderState(render_state);
Bgfx.SetIndexBuffer(index_buffer, 0, 6);
Bgfx.SetVertexBuffer(0, vertex_buffer, 0, vertex_index);
Bgfx.Submit(pass, surface.Shader?.Program ?? current_shader_program.Program);
}
static void RenderThread(Sample sample)
{
// initialize the renderer
Bgfx.Init();
Bgfx.Reset(sample.WindowWidth, sample.WindowHeight, ResetFlags.Vsync);
// enable debug text
Bgfx.SetDebugFeatures(DebugFeatures.DisplayText);
// set view 0 clear state
Bgfx.SetViewClear(0, ClearTargets.Color | ClearTargets.Depth, 0x303030ff);
// main loop
while (sample.ProcessEvents(ResetFlags.Vsync))
{
// set view 0 viewport
Bgfx.SetViewRect(0, 0, 0, sample.WindowWidth, sample.WindowHeight);
// make sure view 0 is cleared if no other draw calls are submitted
Bgfx.Touch(0);
// write some debug text
Bgfx.DebugTextClear();
Bgfx.DebugTextWrite(0, 1, DebugColor.White, DebugColor.Blue, "SharpBgfx/Samples/00-HelloWorld");
Bgfx.DebugTextWrite(0, 2, DebugColor.White, DebugColor.Cyan, "Description: Initialization and debug text.");
// advance to the next frame. Rendering thread will be kicked to
// process submitted rendering primitives.
Bgfx.Frame();
}
// clean up
Bgfx.Shutdown();
}
static unsafe void RenderThread(Sample sample)
{
// initialize the renderer
Bgfx.Init();
Bgfx.Reset(sample.WindowWidth, sample.WindowHeight, ResetFlags.Vsync);
// enable debug text
Bgfx.SetDebugFeatures(DebugFeatures.DisplayText);
// set view 0 clear state
Bgfx.SetViewClear(0, ClearTargets.Color | ClearTargets.Depth, 0x303030ff);
// check capabilities
var caps = Bgfx.GetCaps();
var computeSupported = caps.SupportedFeatures.HasFlag(DeviceFeatures.Compute);
var indirectSupported = caps.SupportedFeatures.HasFlag(DeviceFeatures.DrawIndirect);
if (computeSupported)
{
RunCompute(sample, indirectSupported);
}
else
{
RunUnsupported(sample);
}
// clean up
Bgfx.Shutdown();
}
public void Submit()
{
Bgfx.SetVertexBuffer(vertexBuffer, count * 4);
Bgfx.SetIndexBuffer(indexBuffer, 0, count * 6);
Bgfx.SetRenderState(RenderState.ColorWrite | RenderState.BlendFunction(RenderState.BlendSourceAlpha, RenderState.BlendInverseSourceAlpha));
Bgfx.Submit(0);
}
// Start is called before the first frame update
void Start()
{
width = (int)image.rectTransform.rect.width;
height = (int)image.rectTransform.rect.height;
bool isInit = Bgfx.Init();
Debug.Log("bgfx initial result: " + isInit);
// enable debug text
//Bgfx.SetDebugFeatures(DebugFeatures.DisplayText);
//// set view 0 clear state
//Bgfx.SetViewClear(0, ClearTargets.Color | ClearTargets.Depth, 0x303030ff);
// Bgfx.SetWindowHandle(image.mainTexture.GetNativeTexturePtr());
//PlatformData platformData = new PlatformData();
//platformData.DisplayType = System.IntPtr.Zero;
//platformData.WindowHandle = image.mainTexture.GetNativeTexturePtr();
//string str = "aassssssssss";
//IntPtr initstr = Marshal.StringToHGlobalAnsi(str);
//platformData.Context = imageTem.mainTexture.g;
//platformData.Backbuffer = System.IntPtr.Zero;
//platformData.BackbufferDepthStencil = System.IntPtr.Zero;
//Bgfx.SetPlatformData(platformData);
}
public void End()
{
unsafe
{
Bgfx.vertex_layout_end((VertexLayoutPtrData *)Unsafe.AsPointer(ref InternalHandle));
}
}
public void Begin()
{
unsafe
{
Bgfx.vertex_layout_begin((VertexLayoutPtrData *)Unsafe.AsPointer(ref InternalHandle), GraphicsContext.RendererBackend);
}
}
public void Add(Attrib attrib, AttribType attribType, byte num, bool normalized, bool asInt)
{
unsafe
{
Bgfx.vertex_layout_add((VertexLayoutPtrData *)Unsafe.AsPointer(ref InternalHandle), attrib, num, attribType, normalized, asInt);
}
}
public void SetTranform(Matrix4 matrix)
{
unsafe
{
int cacheIndex = Bgfx.SetTransform(matrix.Pointer());
}
}
public void SetProjectionTransform(int viewport, Matrix4 projection)
{
unsafe
{
Bgfx.SetViewTransform((byte)viewport, null, projection.Pointer());
}
}
public void SetViewTransform(int viewport, Matrix4 view)
{
unsafe
{
Bgfx.SetViewTransform((byte)viewport, view.Pointer(), null);
}
}
public static int CallBgfxFrame()
{
int result = Bgfx.Frame();
lastFrameNumber = result;
UpdateOcclusionQuery();
return(result);
}
public void Dispose()
{
defaultProgram.Dispose();
textureColor.Dispose();
spriteRenderer.Dispose();
Bgfx.Shutdown();
}
