public static FrameBuffer GetInstance() { if(instance==null){ instance=new FrameBuffer(); } return instance; }
public FrameBuffer Regist( string key, FrameBuffer frameBuffer ) { if( Find( key ) != null ){ return null; } frameBufferTable[ key ] = frameBuffer; return frameBuffer; }
private void PlatformConstruct(GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage, bool shared) { _frameBuffer = new FrameBuffer(); _frameBuffer.SetColorTarget(_texture2D,0); // If we don't need a depth buffer then we're done. if (preferredDepthFormat == DepthFormat.None) return; throw new NotImplementedException(); }
public void blur_Gauss( fx_Quad quad, int blur_amount, Texture texture_to_blur, FrameBuffer texture_frame_buffer, DrawBuffersEnum attachement, float destination_scale = 1) { blur_Gauss( quad, blur_amount, new Vector2(1.0f, 0.0f), new Vector2(0.0f, 1.0f), texture_to_blur, texture_frame_buffer, attachement, destination_scale); }
/// <summary> /// If available, returns the next frame from the video. If not, returns null /// </summary> /// <returns></returns> public Frame PlayNextFrame() { if (FramesInBuffer) { var result = FrameBuffer.First; FrameBuffer.RemoveFirst(); return(result); } return(null); }
public UIExtension(FrameBuffer buffer) { _buffer = buffer; _uiBuffer = new FrameBuffer(_buffer.Width, _buffer.Height); _buffer.GetFramebufferCopy(_uiBuffer.RawFrameBuffer); buffer.FrameDrawn += Buffer_FrameDrawn; _uiGraphics = new FrameBufferGraphics(_uiBuffer); BasePanel = new Panel(); }
protected override void PreDrawMask(FrameBuffer clippingMask) { clippingMask.Bind(); GLWrapper.PushViewport(new RectangleI(0, 0, clippingMask.Texture.Width, clippingMask.Texture.Height)); GLWrapper.Clear(new ClearInfo(Colour4.White)); GLWrapper.SetBlend(new BlendingParameters { Source = BlendingType.Zero, Destination = BlendingType.OneMinusSrcColor, SourceAlpha = BlendingType.Zero, DestinationAlpha = BlendingType.OneMinusSrcAlpha, }); }
/// <summary> /// Ensures that there is no active <see cref="Buffers.FrameBuffer"/> object bound to the RenderContext. /// </summary> public void UnbindFrameBuffer() { if (_frameBufferHandle == GLHandle.Zero) { return; } GL.BindFramebuffer(FramebufferTarget.Framebuffer, GLHandle.Zero); _frameBufferHandle = GLHandle.Zero; _frameBuffer.BoundContext = null; _frameBuffer = null; }
public Engine(string contentDirectory = "Content", Vector2?screenSize = null, bool fullscreen = true, bool exclusiveFullscreen = true, string firstSceneName = null, params Scene [] scenes) { if (SharedEngine != null) { throw new InvalidOperationException(); } graphics = new GraphicsDeviceManager(this) { IsFullScreen = fullscreen, HardwareModeSwitch = exclusiveFullscreen }; Window.AllowUserResizing = true; Window.ClientSizeChanged += (sender, e) => { if (graphics == null || GraphicsDevice == null) { return; } graphics.PreferredBackBufferWidth = Window.ClientBounds.Width; graphics.PreferredBackBufferHeight = Window.ClientBounds.Height; graphics.ApplyChanges(); if (!isCustomSize) { frameBuffer.Size = new Vector2(graphics.PreferredBackBufferWidth, graphics.PreferredBackBufferHeight); } CalculateBackBufferArea(); }; frameBuffer = new FrameBuffer(screenSize ?? new Vector2(graphics.PreferredBackBufferWidth, graphics.PreferredBackBufferHeight)); frameBuffer.SizeChanged += (sender, e) => CalculateBackBufferArea(); isCustomSize = screenSize != null; Content.RootDirectory = contentDirectory; Services.AddService(new EntityManager()); Services.AddService(new SystemManager()); Services.AddService(new ProcessorManager()); Services.AddService(new SceneManager(firstSceneName, scenes)); Services.AddService(new Coroutine()); Services.AddService(new Logger()); Services.AddService(new InputService()); ProcessorManager.SharedManager.RegisterProcessor(new FrameRateCalculateProcessor()); SharedEngine = this; }
public RenderPass(FrameBuffer myFrameBuffer, SubPass[] mySubpasses = null) { List <AttachmentDescription> GBufferSupportedTypes = new List <AttachmentDescription>(); List <AttachmentReference> attachmentColorReferences = new List <AttachmentReference>(); AttachmentReference myDepthBuffer; SubpassDescription GeometryBufferSubpassDescription = new SubpassDescription() { PipelineBindPoint = PipelineBindPoint.Graphics }; foreach (var Attachment in myFrameBuffer.GetAttachments()) { GBufferSupportedTypes.Add(Attachment.AttachmentDescription); if (Attachment.AttachmentReference.Layout != ImageLayout.DepthStencilAttachmentOptimal) { attachmentColorReferences.Add(Attachment.AttachmentReference); } else { GeometryBufferSubpassDescription.DepthStencilAttachment = Attachment.AttachmentReference; } } GeometryBufferSubpassDescription.ColorAttachments = attachmentColorReferences.ToArray(); //Above is for the Geometry Buffer to intialize. uint starting = 1; uint ending = 2; List <SubpassDependency> myIncomingDependencies = new List <SubpassDependency>(); List <SubpassDescription> mySubpassDescriptions = new List <SubpassDescription>(); if (mySubpasses != null) { for (int i = 0; i < mySubpasses.Length; i++) { myIncomingDependencies.AddRange(mySubpasses[i].GetSubpassDependencies()); mySubpassDescriptions.Add(mySubpasses[i].GetSubpassDescription()); } ; } var aRenderPassCreateInfo = new RenderPassCreateInfo { Attachments = GBufferSupportedTypes.ToArray(), Subpasses = mySubpassDescriptions.ToArray(), Dependencies = myIncomingDependencies.ToArray() }; myFrameBuffer.SetRenderPass(this); CreateRenderPass(aRenderPassCreateInfo); }
///<summary> /// Compile this Composition chain into a series of RenderTarget operations. ///</summary> protected void Compile() { ClearCompiledState(); bool compositorsEnabled = false; /// Set previous CompositorInstance for each compositor in the list CompositorInstance lastComposition = originalScene; originalScene.PreviousInstance = null; CompositionPass pass = originalScene.Technique.OutputTarget.GetPass(0); pass.ClearBuffers = viewport.ClearBuffers; pass.ClearColor = viewport.BackgroundColor; foreach (CompositorInstance instance in instances) { if (instance.Enabled) { compositorsEnabled = true; instance.PreviousInstance = lastComposition; lastComposition = instance; } } /// Compile misc targets lastComposition.CompileTargetOperations(compiledState); /// Final target viewport (0) outputOperation.RenderSystemOperations.Clear(); lastComposition.CompileOutputOperation(outputOperation); // Deal with viewport settings if (compositorsEnabled != anyCompositorsEnabled) { anyCompositorsEnabled = compositorsEnabled; if (anyCompositorsEnabled) { // Save old viewport clearing options oldClearEveryFrameBuffers = viewport.ClearBuffers; // Don't clear anything every frame since we have our own clear ops viewport.SetClearEveryFrame(false); } else { // Reset clearing options viewport.SetClearEveryFrame(oldClearEveryFrameBuffers > 0, oldClearEveryFrameBuffers); } } dirty = false; }
public void Render( GraphicsContext graphics, Camera camera, LightModel light, Model model, BgModel bg ) { // offscreen rendering FrameBuffer oldBuffer = graphics.GetFrameBuffer(); // render the scene graphics.SetFrameBuffer(sceneBuffer); graphics.SetViewport(0, 0, sceneBuffer.Width, sceneBuffer.Height); graphics.SetClearColor(0.0f, 0.5f, 1.0f, 1.0f); renderSimpleScene(graphics, camera, light, model, bg); // apply gaussian along X axis graphics.SetFrameBuffer(gaussianXBuffer); graphics.SetViewport(0, 0, gaussianXBuffer.Width, gaussianXBuffer.Height); renderGaussianX(graphics); // apply gaussian along Y axis graphics.SetFrameBuffer(gaussianXYBuffer); graphics.SetViewport(0, 0, gaussianXYBuffer.Width, gaussianXYBuffer.Height); renderGaussianY(graphics); // final draw { // restore frame buffer graphics.SetFrameBuffer(oldBuffer); graphics.SetViewport(0, 0, oldBuffer.Width, oldBuffer.Height); graphics.SetClearColor(0.0f, 0.5f, 1.0f, 1.0f); graphics.Clear(); int width = sceneBuffer.Width / 4; int height = sceneBuffer.Height / 4; texRenderer.Begin(); texRenderer.Render(texGaussianXY, 0, 0, 0, 0, sceneBuffer.Width, sceneBuffer.Height); texRenderer.Render(texScene, 0, height * 0, 0, 0, width, height); texRenderer.Render(texGaussianX, 0, height * 1, 0, 0, width, height); texRenderer.Render(texGaussianXY, 0, height * 2, 0, 0, width, height); texRenderer.End(); } }
protected override void OnRenderTargetChange(FrameBuffer oldRenderTarget) { if (mInFrame) { throw new AgateException( "Cannot change the current render target inside BeginFrame..EndFrame block!"); } System.Diagnostics.Debug.Assert(mGraphics == null); mRenderTarget = RenderTarget.Impl as Drawing_FrameBuffer; OnRenderTargetResize(); }
public override void OnProcessing(Frame current) { if (buffer == null || !current.SameSizeAs(buffer.First)) { buffer = new FrameBuffer(framesNeeded, current.Width, current.Height); } var result = new MotionProcessorResult(); //Check for duplicate frames, and assume previous result for them if (buffer.Count > 0 && !current.IsDifferentFrom(buffer.First)) { current.ProcessorResult = (MotionProcessorResult)buffer.First.ProcessorResult; current.IsReadyForRender = true; return; } if (buffer.Count == framesNeeded) { buffer.RemoveFirst(); } buffer.Enqueue(current); if (buffer.Count == framesNeeded) { var prev = buffer.First; var roi = new System.Windows.Rect ( new Point(current.Width * LeftBoundPCT, current.Height * TopBoundPCT), new Point(current.Width * RightBoundPCT, current.Height * BottomBoundPCT) ); var changedPixels = current.ChangeExtentPoints(prev, Threshold, roi); result.Threshold = Threshold; result.ChangedPixels = changedPixels; result.ChangedPixelsCount = changedPixels.Count; result.Frame = current; result.FrameIndex = current.FrameIndex; result.FrameTime = current.FrameTime; } current.ProcessorResult = result; current.IsReadyForRender = true; }
private void PlatformConstruct(GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage, bool shared) { _frameBuffer = new FrameBuffer(); _frameBuffer.SetColorTarget(_texture2D, 0); // If we don't need a depth buffer then we're done. if (preferredDepthFormat == DepthFormat.None) { return; } throw new NotImplementedException(); }
public void Initialize() { m_CoroutineManager = new CoroutineManager(); m_ResourceLoader = new ResourceLoader(); m_FrameBuffer = new FrameBuffer(); m_FrameDataCollector = new FrameDataCollector(); m_InputManager = new InputManager(); m_GameLogicManager = new GameLogicManager(); m_LevelManager = new LevelManager(); m_CameraManager = new CameraManager(); Utils.Random.seed = 1; m_LevelManager.Start(); }
/// <summary> /// Makes sure the first frame buffer is always the one we want to draw from. /// This saves us the need to sync the draw indices across draw node trees /// since the Shared.FrameBuffers array is already shared. /// </summary> private void finalizeFrameBuffer() { if (currentFrameBufferIndex != 0) { Trace.Assert(currentFrameBufferIndex == 1, $"Only the first two framebuffers should be the last to be written to at the end of {nameof(Draw)}."); FrameBuffer temp = Shared.FrameBuffers[0]; Shared.FrameBuffers[0] = Shared.FrameBuffers[1]; Shared.FrameBuffers[1] = temp; currentFrameBufferIndex = 0; } }
private ImageAsset getOffscreenImage(Scene scene, Texture2D texture) { FrameBuffer offScreenFramebufferCache = UISystem.offScreenFramebufferCache; offScreenFramebufferCache.SetColorTarget(texture, 0); scene.Update(0f); Matrix4 identity = Matrix4.Identity; scene.RootWidget.RenderToFrameBuffer(offScreenFramebufferCache, ref identity, false); return(new ImageAsset(texture) { AdjustScaledSize = true }); }
/// <summary> /// adrr contains the save address of the generated image, /// and must have the extension .pgm; /// Example /home/user/image.pgm /// </summary> public void ExportMapPGM(string adrr, int baseColor, int lineColor) { FrameBuffer frame = new FrameBuffer((int)this.size.X + 1, (int)this.size.Y + 1, baseColor); foreach (intTuple item in this.edge) { Vector2 a = this.vertex[item.A]; Vector2 b = this.vertex[item.B]; LineGeneration.plotLine(a, b, frame, lineColor); } frame.Export(adrr); }
public CompositorChain(Viewport vp) { this.viewport = vp; originalScene = null; instances = new List <CompositorInstance>(); dirty = true; anyCompositorsEnabled = false; compiledState = new List <CompositorTargetOperation>(); outputOperation = null; oldClearEveryFrameBuffers = viewport.ClearBuffers; renderSystemOperations = new List <CompositorRenderSystemOperation>(); listener = new RQListener(); Debug.Assert(viewport != null); }
public CXPCapabilityMessageSender(PresenterModel model, PresenterCapability capability) { this.m_Model = model; this.m_LocalId = m_Model.Participant.Guid; this.m_Classroom = new ClassroomModel(null, "CXP Capability Classroom", ClassroomModelType.CXPCapability); this.m_Capability = capability; this.m_Participants = new Dictionary <string, ParticipantModel>(); this.m_SsrcToSenderId = new Dictionary <uint, Guid>(); this.m_Receivers = new Dictionary <string, CXPCapabilityMessageReceiver>(); m_Capability.OnStreamAdded += new PresenterCapability.OnStreamAddedHandler(OnStreamAdded); m_Capability.OnStreamRemoved += new PresenterCapability.OnStreamRemovedHandler(OnStreamRemoved); using (Synchronizer.Lock(this)) { // Initialize the message chunking utilities. this.m_Encoder = new Chunk.ChunkEncoder(); // TODO: Make the buffer size dynamic, ie., grow if we send a single very large message. // Make the buffer store up to 5MB worth of data. this.m_FrameBuffer = new FrameBuffer(5 * 1024 * 1024 / this.m_Encoder.MaximumChunkSize); // Create the NackManager which is responsible for sending NACKs on behalf of // our set of RTPMessageReceivers. this.m_NackManager = new RTPNackManager(this, this.m_Classroom); } // Create network services outside of the "lock(this)" so they can lock their own objects // without worrying about locking order. // Create the PresenterNetworkService which will watch for changes to the model and send messages. this.m_PresenterNetworkService = new PresenterNetworkService(this, this.m_Model); // Create the StudentSubmissionsNetworkService which will watch for requests to submit and send messages. this.m_StudentSubmissionNetworkService = new StudentSubmissionNetworkService(this, this.m_Model); // Create the SynchronizationNetworkService which will watch for all synchronization messages. this.m_SynchronizationNetworkService = new SynchronizationNetworkService(this, this.m_Model); // Create the ScriptingNetworkService which will watch for all scripting messages. this.m_ScriptingNetworkService = new ScriptingNetworkService(this, this.m_Model); // Create the BeaconService which will broadcast periodic information about the presentation. this.m_BeaconService = new Beacons.DefaultBeaconService(this, this.m_Model); // Report Network status to the UI m_CapabilityNetworkStatus = new CapabilityNetworkStatus(this.m_Model); m_CapabilityNetworkStatus.Register(); // Send an initial message to announce our node to others in the venue. SendObject(new CapabilityMessageWrapper(null, m_LocalId, Guid.Empty, m_Capability.IsSender)); }
public void WindowMovedOrResized(Vector2I size) // bool fullScreen )//, Vec2I windowSize ) { if (Disposed) { return; } EngineThreading.CheckMainThread(); //unsafe //{ //!!!!было //MyOgreSceneManager.destroyShadowTextures( SceneManager.realObject ); //!!!!как теперь? текстуры композитинга удалять? где еще? //MyOgreSceneManager.destroyAdditionalMRTs( SceneManager.realObject ); //} //foreach( Viewport viewport in viewports ) //{ // foreach( CompositorInstance instance in viewport.CompositorInstances ) // instance.DoRealEnabledUpdate( false ); //} 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); } //unsafe //{ // OgreRenderWindow.windowMovedOrResized( realObjectRenderWindow, fullScreen );//, windowSize.X, windowSize.Y ); //} //GetSizeFromNative(); //update aspect ratio foreach (Viewport viewport in viewports) { viewport.UpdateAspectRatio(); } }
static void Main(string[] args) { FrameBuffer buffer = new FrameBuffer(Console.WindowWidth, Console.WindowHeight) { FrameLimit = 60 }; FrameBufferGraphics graphics = new FrameBufferGraphics(buffer); buffer.Run(); UIExtension ext = new UIExtension(buffer); ImageBox imageBox = new ImageBox() { Image = Image.Load <Rgb24>(@"C:\Users\wamwo\Downloads\congaparrot.gif"), Width = 32, Height = 32 }; ext.Controls.Add(imageBox); ImageBox imageBox2 = new ImageBox() { Image = Image.Load <Rgb24>(@"C:\Users\wamwo\Downloads\congaparrot.gif"), Width = 32, Height = 32, X = 32 }; ext.Controls.Add(imageBox2); ImageBox imageBox3 = new ImageBox() { Image = Image.Load <Rgb24>(@"C:\Users\wamwo\Downloads\congaparrot.gif"), Width = 32, Height = 32, X = 64 }; ext.Controls.Add(imageBox3); ImageBox imageBox4 = new ImageBox() { Image = Image.Load <Rgb24>(@"C:\Users\wamwo\Downloads\congaparrot.gif"), Width = 32, Height = 32, X = 96 }; ext.Controls.Add(imageBox4); buffer.AddDrawExtension(ext); }
public void render(fx_Quad quad, fx_Special special, Texture depth_texture, FrameBuffer scene_fbo, Texture scene_texture) { autoFocus(depth_texture); //printFocusDistance(); genCOC(quad, special, depth_texture); resetBokeh(); extractBokeh(quad, depth_texture, scene_texture); //printBokehCount(); genBokeh(depth_texture); genDOF(quad, depth_texture); blendDOF(quad, special, scene_fbo, scene_texture); }
public void init() { //Model.getDefaultShaderProgram(); //Initializes the default shader this.graphicsContext.Enable(EnableMode.DepthTest, true); //this.graphicsContext.Enable(EnableMode.CullFace, true); this.graphicsContext.Enable(EnableMode.Blend, true); //this.graphicsContext.Enable(EnableMode.ScissorTest, true); //his.graphicsContext.Enable(EnableMode.Dither, true); //this.graphicsContext.Enable(EnableMode.StencilTest, true); this.graphicsContext.SetBlendFunc(BlendFuncMode.Add, BlendFuncFactor.SrcAlpha, BlendFuncFactor.OneMinusSrcAlpha); this.graphicsContext.SetCullFace(CullFaceMode.Back, CullFaceDirection.Ccw); this.mainFrameBuffer = this.graphicsContext.GetFrameBuffer(); }
public void blur_Gauss( fx_Quad quad, int blur_amount, float blur_angle, Texture texture_to_blur, FrameBuffer texture_frame_buffer, DrawBuffersEnum attachement, float destination_scale = 1) { Vector2 angle_mod = EngineHelper.createRotationVector(blur_angle); blur_Gauss( quad, blur_amount, angle_mod, angle_mod, texture_to_blur, texture_frame_buffer, attachement, destination_scale); }
protected override void load_Buffers() { _tFinalScene = new Texture(TextureTarget.Texture2D, _resolution.W, _resolution.H, 0, false, false, PixelInternalFormat.Rgba16f, PixelFormat.Rgba, PixelType.Float, TextureMinFilter.Linear, TextureMagFilter.Linear, TextureWrapMode.Clamp); _tFinalScene.load(); _fFinalScene = new FrameBuffer("Final Scene"); _fFinalScene.load(new Dictionary <FramebufferAttachment, Texture>() { { FramebufferAttachment.ColorAttachment0, _tFinalScene } }); }
void Start() { frameBuffer = GetComponent<FrameBuffer>(); renderTexture = frameBuffer.GetCurrentTexture(); rect = new Rect(0f, 0f, Game.width, Game.height); texture2D = new Texture2D((int)Game.width, (int)Game.height); colorArray = new Color[(int)Game.width * (int)Game.height]; if (collectibleList == null) { collectibleList = new List<Collectible>(); } position = Vector2.zero; }
public int Push(ref FrameBuffer f) { m.WaitOne(); if (data_frame.Count < 3) { data_frame.Enqueue(f); m.ReleaseMutex(); return(1); } else { m.ReleaseMutex(); return(0); } }
void recordDraw(PrimaryCommandBuffer cmd, FrameBuffer fb) { pipeline.RenderPass.Begin(cmd, fb); cmd.SetViewport(fb.Width, fb.Height); cmd.SetScissor(fb.Width, fb.Height); cmd.BindDescriptorSet(pipeline.Layout, descriptorSet); pipeline.Bind(cmd); cmd.BindVertexBuffer(vbo, 0); cmd.Draw(36); pipeline.RenderPass.End(cmd); }
public void RenderToTexture(Texture2D texture, Matrix4 transform) { if (texture == null) { throw new ArgumentNullException("texture"); } if (!texture.IsRenderable) { throw new ArgumentException("Texture is not renderable.", "texture"); } FrameBuffer offScreenFramebufferCache = UISystem.offScreenFramebufferCache; offScreenFramebufferCache.SetColorTarget(texture, 0); this.RenderToFrameBuffer(offScreenFramebufferCache, ref transform, true); }
/// <summary> /// Creates a new <see cref="BufferedDrawNodeSharedData"/> with a specific amount of effect buffers. /// </summary> /// <param name="effectBufferCount">The number of effect buffers.</param> /// <exception cref="ArgumentOutOfRangeException">If <paramref name="effectBufferCount"/> is less than 0.</exception> public BufferedDrawNodeSharedData(int effectBufferCount) { if (effectBufferCount < 0) { throw new ArgumentOutOfRangeException(nameof(effectBufferCount), "Must be positive."); } MainBuffer = new FrameBuffer(); effectBuffers = new FrameBuffer[effectBufferCount]; for (int i = 0; i < effectBufferCount; i++) { effectBuffers[i] = new FrameBuffer(); } }
void buildCommandBuffers() { cmdPool.Reset(); for (int i = 0; i < swapChain.ImageCount; ++i) { FrameBuffer fb = frameBuffers[i]; cmds[i].Start(); renderPass.Begin(cmds[i], fb); renderPass.End(cmds[i]); cmds[i].End(); } }
public void Run(string[] args) { using (new DisplayWindowBuilder(args) .BackbufferSize(800, 600) .QuitOnClose() .Build()) { Surface someSurface = new Surface("Images/wallpaper.png"); bool capturing = false; FrameBuffer capture = new FrameBuffer(1600, 1200); while (AgateApp.IsAlive) { if (Input.Unhandled.Keys[KeyCode.C]) { capturing = true; Input.Unhandled.Keys.Release(KeyCode.C); } if (capturing) { Display.RenderTarget = capture; someSurface.SetScale(2, 2); } Display.BeginFrame(); Display.Clear(Color.White); someSurface.Draw(); Display.Primitives.FillRect(Color.Gray, new Rectangle(10, 10, 10, 10)); Display.EndFrame(); if (capturing) { capture.RenderTarget.SaveTo("CapturedImage.png", ImageFileFormat.Png); Display.RenderTarget = Display.CurrentWindow.FrameBuffer; someSurface.SetScale(1, 1); capturing = false; Debug.WriteLine("Captured image to CapturedImage.png"); } AgateApp.KeepAlive(); } } }
public Depth() { if(depth == null) { depth = new ShaderProgram(VFS.GetFileBytes("vfs1:/shaders/Depth.cgx")); depth.SetAttributeBinding(0, "a_Position"); depth.SetUniformBinding(0, "WorldViewProj"); } RenderPassTarget = new Texture2D((int)RootNode.graphicsContext.GetDisplay().Width, (int)RootNode.graphicsContext.GetDisplay().Height , false, PixelFormat.Rgba, PixelBufferOption.Renderable); RenderPassBuf = new FrameBuffer(); RenderPassBuf.SetColorTarget(RenderPassTarget,0); DepthBuffer temp = new DepthBuffer(RenderPassTarget.Width, RenderPassTarget.Height, PixelFormat.Depth24Stencil8); RenderPassBuf.SetDepthTarget(temp); }
public DynamicTexture(Context context, Format format, Vector4i size) { if (context == null) throw new ArgumentNullException("context"); if (format == null) throw new ArgumentNullException("format"); this.format = format; this.frameBuffer = new FrameBuffer(); this.mainProgram = new Program(); this.dimensions = size; var builder = ShaderBuilder.CreateFromAssemblyResource("Glare.Graphics.Shaders.DynamicTexture.glsl"); mainProgram.Shaders.AddRange( builder.VertexShader("Common", "Vertex"), builder.FragmentShader("Common", "Fragment")); mainProgram.MustLink(); mainProgramAction = mainProgram.FragmentStage.Uniforms["Act"]; mainProgram.Attributes["Position"].BindArray(new Vector2f[] { new Vector2f(-1, 1), new Vector2f(-1, -1), new Vector2f(1, 1), new Vector2f(1, -1) }); }
public override void ComputeNextFrame(FrameBuffer frameBuffer) { base.ComputeNextFrame(frameBuffer); TIA.StartFrame(); CPU.RunClocks = (FrameBuffer.Scanlines + 3) * 76; while (CPU.RunClocks > 0 && !CPU.Jammed) { if (TIA.WSYNCDelayClocks > 0) { CPU.Clock += (ulong)TIA.WSYNCDelayClocks / 3; CPU.RunClocks -= TIA.WSYNCDelayClocks / 3; TIA.WSYNCDelayClocks = 0; } if (TIA.EndOfFrame) { break; } CPU.Execute(); } TIA.EndFrame(); }
public Video(DisposableI parent, ApplicationI application, DepthStencilFormats depthStencilFormats, bool vSync) : base(parent) { try { this.application = application; FileTag = "Vita_"; currentPixelTextures = new Texture2D[4]; currentSamplerStates = new SamplerState[4]; PixelFormat format = PixelFormat.None; switch (depthStencilFormats) { case DepthStencilFormats.None: format = PixelFormat.None; break; case DepthStencilFormats.Defualt: format = PixelFormat.Depth16; break; case DepthStencilFormats.Depth24Stencil8: format = PixelFormat.Depth24Stencil8; break; case DepthStencilFormats.Depth16: format = PixelFormat.Depth16; break; case DepthStencilFormats.Depth24: format = PixelFormat.Depth24; break; default: Debug.ThrowError("Video", "Unsuported DepthStencilFormat type"); break; } context = new GraphicsContext(0, 0, PixelFormat.Rgba, format, MultiSampleMode.None); currentFrameBuffer = context.Screen; BackBufferSize = new Size2(currentFrameBuffer.Width, currentFrameBuffer.Height); ((VitaApplication)application).Vita_SetFrameSize(currentFrameBuffer.Width, currentFrameBuffer.Height); currentEnableMode = EnableMode.None; context.Enable(currentEnableMode); } catch (Exception e) { Dispose(); throw e; } }
public abstract void CopyContentsToMemory(PixelBox pb, FrameBuffer buffer);
public void ClearFrameBuffer(FrameBuffer buffers, ColorEx color) { ClearFrameBuffer(buffers, color, 1.0f, 0); }
public void ClearFrameBuffer(FrameBuffer buffers) { ClearFrameBuffer(buffers, ColorEx.Black, 1.0f, 0); }
/// <summary> /// Error throwing implementation, it's not possible to copy a MultiRenderTarget. /// </summary> /// <param name="pb"></param> /// <param name="buffer"></param> public override void CopyContentsToMemory( PixelBox pb, FrameBuffer buffer ) { throw new NotSupportedException( "It's not possible to copy a MultiRenderTarget." ); }
public void ClearFrameBuffer(FrameBuffer buffers, ColorEx color, float depth) { ClearFrameBuffer(buffers, color, depth, 0); }
/// <summary></summary> public TransitionFadeBase( Scene next_scene ) : base(next_scene) { Vector2i size = new Vector2i( Director.Instance.GL.Context.GetViewport().Width, Director.Instance.GL.Context.GetViewport().Height ); if ( !m_graphics_resources_init ) { m_previous_scene_render = new TextureInfo( new Texture2D( size.X, size.Y, false, PixelFormat.Rgba, PixelBufferOption.Renderable ) ); m_next_scene_render = new TextureInfo( new Texture2D( size.X, size.Y, false, PixelFormat.Rgba, PixelBufferOption.Renderable ) ); m_fbuf1 = new FrameBuffer(); m_fbuf2 = new FrameBuffer(); m_fbuf1.SetColorTarget( m_previous_scene_render.Texture, 0 ); m_fbuf2.SetColorTarget( m_next_scene_render.Texture, 0 ); m_graphics_resources_init = true; } else { Common.Assert( m_previous_scene_render.TextureSizei == size ); Common.Assert( m_next_scene_render.TextureSizei == size ); } }
/** * Assign the review state to sync gui/input states to */ private void SetReviewState(ReviewState state) { switch(state) { case ReviewState.None: m_recordButton.setControlIsEnabled(true); m_pauseButton.setControlIsEnabled(false); if(m_group.Buffer != null && m_group.Buffer.CurrentTime > 0) { m_playButton.setControlIsEnabled(true); } else m_playButton.setControlIsEnabled(false); m_group.UpdateAction = UpdateAction.None; break; case ReviewState.Recording: m_recordButton.setControlIsEnabled(true); m_playButton.setControlIsEnabled(false); m_pauseButton.setControlIsEnabled(false); if(m_reviewState == ReviewState.ReplayPaused) { // regenerate FrameBuffer regenBuffer = new FrameBuffer(); m_group.Buffer.CopyFramesTo(regenBuffer); m_group.Buffer = regenBuffer; // make sure the replay timeline is cleared m_replayTimeline.setProgressValue(0); } else { // create a new buffer m_group.Buffer = new FrameBuffer(); } m_group.UpdateAction = UpdateAction.Record; break; case ReviewState.Replaying: m_recordButton.setControlIsEnabled(false); m_playButton.setControlIsEnabled(false); m_pauseButton.setControlIsEnabled(true); // reset the read/write position in the frame buffer if we're initiating a replay if(m_reviewState == ReviewState.None) //m_group.Buffer.Seek(0); m_group.UpdateAction = UpdateAction.Replay; break; case ReviewState.ReplayPaused: m_recordButton.setControlIsEnabled(true); m_playButton.setControlIsEnabled(true); m_pauseButton.setControlIsEnabled(false); m_group.UpdateAction = UpdateAction.None; break; } m_reviewState = state; }
/// <summary> /// Determines whether to clear the viewport before rendering. /// </summary> ///<remarks> /// You can use this method to set which buffers are cleared /// (if any) before rendering every frame. ///</remarks> ///<param name="clear">Whether or not to clear any buffers</param> ///<param name="buffers">One or more values from FrameBuffer denoting /// which buffers to clear, if clear is set to true. Note you should /// not clear the stencil buffer here unless you know what you're doing. ///</param> public void SetClearEveryFrame(bool clear, FrameBuffer buffers) { clearEveryFrame = clear; clearBuffers = buffers; }
public RSClearOperation(FrameBuffer buffers, ColorEx color, float depth, int stencil) { this.buffers = buffers; this.color = color; this.depth = depth; this.stencil = stencil; }
public override void CopyContentsToMemory( PixelBox dst, FrameBuffer buffer ) { if ( ( dst.Left < 0 ) || ( dst.Right > Width ) || ( dst.Top < 0 ) || ( dst.Bottom > Height ) || ( dst.Front != 0 ) || ( dst.Back != 1 ) ) { throw new Exception( "Invalid box." ); } XFG.GraphicsDevice device = Driver.XnaDevice; //in 3.1, this was XFG.ResolveTexture2D, an actual RenderTarget provides the exact same //functionality, especially seeing as RenderTarget2D is a texture now. //the difference is surface is actually set on the device -DoubleA XFG.RenderTarget2D surface; byte[] data = new byte[ dst.ConsecutiveSize ]; int pitch = 0; if ( buffer == RenderTarget.FrameBuffer.Auto ) { buffer = RenderTarget.FrameBuffer.Front; } XFG.DisplayMode mode = device.DisplayMode; surface = new XFG.RenderTarget2D(device, mode.Width, mode.Height, false, XFG.SurfaceFormat.Rgba64, XFG.DepthFormat.Depth24Stencil8); //XFG.ResolveTexture2D( device, mode.Width, mode.Height, 0, XFG.SurfaceFormat.Rgba32 ); if ( buffer == RenderTarget.FrameBuffer.Front ) { // get the entire front buffer. This is SLOW!! device.SetRenderTarget(surface); if ( IsFullScreen ) { if ( ( dst.Left == 0 ) && ( dst.Right == Width ) && ( dst.Top == 0 ) && ( dst.Bottom == Height ) ) { surface.GetData<byte>( data ); } else { Rectangle rect = new Rectangle(); rect.Left = dst.Left; rect.Right = dst.Right; rect.Top = dst.Top; rect.Bottom = dst.Bottom; surface.GetData<byte>( 0, XnaHelper.ToRectangle( rect ), data, 0, 255 ); } } #if !( XBOX || XBOX360 ) else { Rectangle srcRect = new Rectangle(); srcRect.Left = dst.Left; srcRect.Right = dst.Right; srcRect.Top = dst.Top; srcRect.Bottom = dst.Bottom; // Adjust Rectangle for Window Menu and Chrome System.Drawing.Point point = new System.Drawing.Point(); point.X = (int)srcRect.Left; point.Y = (int)srcRect.Top; SWF.Control control = SWF.Control.FromHandle( _windowHandle ); point = control.PointToScreen( point ); srcRect.Top = point.Y; srcRect.Left = point.X; srcRect.Bottom += point.Y; srcRect.Right += point.X; surface.GetData<byte>( 0, XnaHelper.ToRectangle( srcRect ), data, 0, 255 ); } #endif } else { device.SetRenderTarget( surface ); if ( ( dst.Left == 0 ) && ( dst.Right == Width ) && ( dst.Top == 0 ) && ( dst.Bottom == Height ) ) { surface.GetData<byte>( data ); } else { Rectangle rect = new Rectangle(); rect.Left = dst.Left; rect.Right = dst.Right; rect.Top = dst.Top; rect.Bottom = dst.Bottom; surface.GetData<byte>( 0, XnaHelper.ToRectangle( rect ), data, 0, 255 ); } } PixelFormat format = XnaHelper.Convert( surface.Format ); if ( format == PixelFormat.Unknown ) { throw new Exception( "Unsupported format" ); } IntPtr dataPtr = Memory.PinObject( data ); PixelBox src = new PixelBox( dst.Width, dst.Height, 1, format, dataPtr ); src.RowPitch = pitch / PixelUtil.GetNumElemBytes( format ); src.SlicePitch = surface.Height * src.RowPitch; PixelConverter.BulkPixelConversion( src, dst ); Memory.UnpinObject( data ); surface.Dispose(); }
public override void ComputeNextFrame(FrameBuffer frameBuffer) { base.ComputeNextFrame(frameBuffer); AssertDebug(CPU.Jammed || CPU.RunClocks <= 0 && (CPU.RunClocks % CPU.RunClocksMultiple) == 0); AssertDebug(CPU.Jammed || ((CPU.Clock + (ulong)(CPU.RunClocks / CPU.RunClocksMultiple)) % (114 * (ulong)FrameBuffer.Scanlines)) == 0); ulong startOfScanlineCpuClock = 0; Maria.StartFrame(); Cart.StartFrame(); for (var i = 0; i < FrameBuffer.Scanlines && !CPU.Jammed; i++) { AssertDebug(CPU.RunClocks <= 0 && (CPU.RunClocks % CPU.RunClocksMultiple) == 0); var newStartOfScanlineCpuClock = CPU.Clock + (ulong)(CPU.RunClocks / CPU.RunClocksMultiple); AssertDebug(startOfScanlineCpuClock == 0 || newStartOfScanlineCpuClock == startOfScanlineCpuClock + 114); startOfScanlineCpuClock = newStartOfScanlineCpuClock; CPU.RunClocks += (7 * CPU.RunClocksMultiple); var remainingRunClocks = (114 - 7) * CPU.RunClocksMultiple; CPU.Execute(); if (CPU.Jammed) break; if (CPU.EmulatorPreemptRequest) { Maria.DoDMAProcessing(); var remainingCpuClocks = 114 - (CPU.Clock - startOfScanlineCpuClock); CPU.Clock += remainingCpuClocks; CPU.RunClocks = 0; continue; } var dmaClocks = Maria.DoDMAProcessing(); // CHEAT: Ace of Aces: Title screen has a single scanline flicker without this. Maria DMA clock counting probably not 100% accurate. if (i == 203 && FrameBuffer.Scanlines == 262 /*NTSC*/ || i == 228 && FrameBuffer.Scanlines == 312 /*PAL*/) if (dmaClocks == 152 && remainingRunClocks == 428 && (CPU.RunClocks == -4 || CPU.RunClocks == -8)) dmaClocks -= 4; // Unsure exactly what to do if Maria DMA processing extends past the current scanline. // For now, throw away half remaining until we are within the current scanline. // KLAX initialization starts DMA without initializing the DLL data structure. // Maria processing then runs away causing an invalid CPU opcode to be executed that jams the machine. // So Maria must give up at some point, but not clear exactly how. // Anyway, this makes KLAX work without causing breakage elsewhere. while ((CPU.RunClocks + remainingRunClocks) < dmaClocks) { dmaClocks >>= 1; } // Assume the CPU waits until the next div4 boundary to proceed after DMA processing. if ((dmaClocks & 3) != 0) { dmaClocks += 4; dmaClocks -= (dmaClocks & 3); } CPU.Clock += (ulong)(dmaClocks / CPU.RunClocksMultiple); CPU.RunClocks -= dmaClocks; CPU.RunClocks += remainingRunClocks; CPU.Execute(); if (CPU.Jammed) break; if (CPU.EmulatorPreemptRequest) { var remainingCpuClocks = 114 - (CPU.Clock - startOfScanlineCpuClock); CPU.Clock += remainingCpuClocks; CPU.RunClocks = 0; } } Cart.EndFrame(); Maria.EndFrame(); }
public CompositionPass(CompositionTargetPass parent) { this.parent = parent; type = CompositorPassType.RenderQuad; identifier = 0; firstRenderQueue = RenderQueueGroupID.SkiesEarly; lastRenderQueue = RenderQueueGroupID.SkiesLate; clearBuffers = FrameBuffer.Color | FrameBuffer.Depth; clearColor = new ColorEx(0f, 0f, 0f, 0f); clearDepth = 1.0f; clearStencil = 0; stencilCheck = false; stencilFunc = CompareFunction.AlwaysPass; stencilRefValue = 0; stencilMask = (int)0x7FFFFFFF; stencilFailOp = StencilOperation.Keep; stencilDepthFailOp = StencilOperation.Keep; stencilPassOp = StencilOperation.Keep; stencilTwoSidedOperation = false; }
public void EnableRenderTarget() { currentFrameBuffer = context.Screen; context.SetFrameBuffer(currentFrameBuffer); }
public RenderTarget2D (GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage, bool shared) :base (graphicsDevice, width, height, mipMap, preferredFormat, SurfaceType.RenderTarget, shared) { DepthStencilFormat = preferredDepthFormat; MultiSampleCount = preferredMultiSampleCount; RenderTargetUsage = usage; #if DIRECTX // Create a view interface on the rendertarget to use on bind. _renderTargetView = new RenderTargetView(graphicsDevice._d3dDevice, _texture); #elif PSM _frameBuffer = new FrameBuffer(); _frameBuffer.SetColorTarget(_texture2D,0); #endif // If we don't need a depth buffer then we're done. if (preferredDepthFormat == DepthFormat.None) return; #if DIRECTX // Setup the multisampling description. var multisampleDesc = new SharpDX.DXGI.SampleDescription(1, 0); if ( preferredMultiSampleCount > 1 ) { multisampleDesc.Count = preferredMultiSampleCount; multisampleDesc.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern; } // Create a descriptor for the depth/stencil buffer. // Allocate a 2-D surface as the depth/stencil buffer. // Create a DepthStencil view on this surface to use on bind. using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(graphicsDevice._d3dDevice, new Texture2DDescription { Format = SharpDXHelper.ToFormat(preferredDepthFormat), ArraySize = 1, MipLevels = 1, Width = width, Height = height, SampleDescription = multisampleDesc, BindFlags = BindFlags.DepthStencil, })) { // Create the view for binding to the device. _depthStencilView = new DepthStencilView(graphicsDevice._d3dDevice, depthBuffer, new DepthStencilViewDescription() { Format = SharpDXHelper.ToFormat(preferredDepthFormat), Dimension = DepthStencilViewDimension.Texture2D }); } #elif PSM throw new NotImplementedException(); #elif OPENGL #if GLES GL.GenRenderbuffers(1, ref glDepthStencilBuffer); #else GL.GenRenderbuffers(1, out glDepthStencilBuffer); #endif GraphicsExtensions.CheckGLError(); GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, this.glDepthStencilBuffer); GraphicsExtensions.CheckGLError(); var glDepthStencilFormat = GLDepthComponent16; switch (preferredDepthFormat) { case DepthFormat.Depth16: glDepthStencilFormat = GLDepthComponent16; break; case DepthFormat.Depth24: glDepthStencilFormat = GLDepthComponent24; break; case DepthFormat.Depth24Stencil8: glDepthStencilFormat = GLDepth24Stencil8; break; } GL.RenderbufferStorage(GLRenderbuffer, glDepthStencilFormat, this.width, this.height); GraphicsExtensions.CheckGLError(); #endif }
public void EnableRenderTarget(DepthStencilI depthStencil) { currentFrameBuffer = context.Screen; ((DepthStencil)depthStencil).enable(); context.SetFrameBuffer(currentFrameBuffer); }
/// <summary> /// The constructor. Dimensions of the viewport are expressed as a pecentage between /// 0 and 100. This allows the dimensions to apply irrespective of /// changes in the target's size: e.g. to fill the whole area, /// values of 0,0,100,100 are appropriate. /// </summary> /// <param name="camera">Reference to the camera to be the source for the image.</param> /// <param name="target">Reference to the render target to be the destination for the rendering.</param> /// <param name="left">Left</param> /// <param name="top">Top</param> /// <param name="width">Width</param> /// <param name="height">Height</param> /// <param name="zOrder">Relative Z-order on the target. Lower = further to the front.</param> public Viewport(Camera camera, RenderTarget target, float left, float top, float width, float height, int zOrder) { Debug.Assert(camera != null, "Cannot use a null Camera to create a viewport."); Debug.Assert(target != null, "Cannor use a null RenderTarget to create a viewport."); LogManager.Instance.Write("Creating viewport rendering from camera '{0}', relative dimensions L:{1},T:{2},W:{3},H:{4}, Z-Order:{5}", camera.Name, left, top, width, height, zOrder); this.camera = camera; this.target = target; this.zOrder = zOrder; relativeLeft = left; relativeTop = top; relativeWidth = width; relativeHeight = height; backColor = ColorEx.Black; clearEveryFrame = true; clearBuffers = FrameBuffer.Color | FrameBuffer.Depth; // Calculate actual dimensions UpdateDimensions(); isUpdated = true; showOverlays = true; showSkies = true; showShadows = true; materialSchemeName = MaterialManager.DefaultSchemeName; // notify camera camera.NotifyViewport(this); }
public override void CopyContentsToMemory( PixelBox dst, FrameBuffer buffer ) { this._device.CopyContentsToMemory( this, dst, buffer ); }
public void SetClearEveryFrame(bool clear) { clearEveryFrame = clear; clearBuffers = FrameBuffer.Color | FrameBuffer.Depth; }
public Terrain() { this.frameBuffer = new FrameBuffer(); }
public RenderTarget2D (GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage, bool shared) :base (graphicsDevice, width, height, mipMap, preferredFormat, SurfaceType.RenderTarget, shared) { DepthStencilFormat = preferredDepthFormat; MultiSampleCount = preferredMultiSampleCount; RenderTargetUsage = usage; #if DIRECTX GenerateIfRequired(); #elif PSM _frameBuffer = new FrameBuffer(); _frameBuffer.SetColorTarget(_texture2D,0); #endif // If we don't need a depth buffer then we're done. if (preferredDepthFormat == DepthFormat.None) return; #if DIRECTX #elif PSM throw new NotImplementedException(); #elif OPENGL var glDepthFormat = GLDepthComponent16; var glStencilFormat = GLStencilIndex8; switch (preferredDepthFormat) { case DepthFormat.Depth16: glDepthFormat = GLDepthComponent16; break; #if GLES case DepthFormat.Depth24: glDepthFormat = GraphicsCapabilities.SupportsDepth24 ? GLDepthComponent24 : GraphicsCapabilities.SupportsDepthNonLinear ? GLDepthComponent16NonLinear : GLDepthComponent16; break; case DepthFormat.Depth24Stencil8: glDepthFormat = GraphicsCapabilities.SupportsDepth24 ? GLDepthComponent24 : GraphicsCapabilities.SupportsDepthNonLinear ? GLDepthComponent16NonLinear : GLDepthComponent16; glStencilFormat = GLStencilIndex8; break; #else case DepthFormat.Depth24: glDepthFormat = GLDepthComponent24; break; case DepthFormat.Depth24Stencil8: glDepthFormat = GLDepthComponent24; glStencilFormat = GLStencilIndex8; break; #endif } Threading.BlockOnUIThread(() => { #if GLES GL.GenRenderbuffers(1, ref glDepthBuffer); #else GL.GenRenderbuffers(1, out glDepthBuffer); #endif GraphicsExtensions.CheckGLError(); if (preferredDepthFormat == DepthFormat.Depth24Stencil8) { if (GraphicsCapabilities.SupportsPackedDepthStencil) { this.glStencilBuffer = this.glDepthBuffer; GL.BindRenderbuffer(GLRenderbuffer, this.glDepthBuffer); GraphicsExtensions.CheckGLError(); GL.RenderbufferStorage(GLRenderbuffer, GLDepth24Stencil8, this.width, this.height); GraphicsExtensions.CheckGLError(); } else { GL.BindRenderbuffer(GLRenderbuffer, this.glDepthBuffer); GraphicsExtensions.CheckGLError(); GL.RenderbufferStorage(GLRenderbuffer, glDepthFormat, this.width, this.height); GraphicsExtensions.CheckGLError(); #if GLES GL.GenRenderbuffers(1, ref glStencilBuffer); #else GL.GenRenderbuffers(1, out glStencilBuffer); #endif GraphicsExtensions.CheckGLError(); GL.BindRenderbuffer(GLRenderbuffer, this.glStencilBuffer); GraphicsExtensions.CheckGLError(); GL.RenderbufferStorage(GLRenderbuffer, glStencilFormat, this.width, this.height); GraphicsExtensions.CheckGLError(); } } else { GL.BindRenderbuffer(GLRenderbuffer, this.glDepthBuffer); GraphicsExtensions.CheckGLError(); GL.RenderbufferStorage(GLRenderbuffer, glDepthFormat, this.width, this.height); GraphicsExtensions.CheckGLError(); } }); #endif }
public CompositorChain(Viewport vp) { this.viewport = vp; originalScene = null; instances = new List<CompositorInstance>(); dirty = true; anyCompositorsEnabled = false; compiledState = new List<CompositorTargetOperation>(); outputOperation = null; oldClearEveryFrameBuffers = viewport.ClearBuffers; renderSystemOperations = new List<CompositorRenderSystemOperation>(); listener = new RQListener(); Debug.Assert(viewport != null); }