Jump to content
  • Advertisement

grizu

Member
  • Content Count

    6
  • Joined

  • Last visited

Community Reputation

111 Neutral

About grizu

  • Rank
    Newbie

Personal Information

  • Interests
    Programming
  1. Ok! Thanks for your help. For now I've got enough to play around with
  2. The article doesn't describe this step. I can't simply sum and divide, because there may be areas where a probe completely overrides another (local probe overriding the skybox), and also a border region where the probes blend. I just got the idea - I could use simple transparent blending (srcAlpha - OneMinusSrcAlpha) to effectively lerp between the current probe and what is already in the reflection buffer. Not sure if the calculation would be 100% correct, and I guess this would lead to plopping if the order of the probes changes. I'm just curious how others do this I also stepped through the unity frame debugger, and they seem to do something with the stencil buffer, but I haven't yet figured out what. That came to my mind as well Thanks for the suggestion!
  3. Hello everyone, I currently play around with reflection probes in a deferred renderer and I'm a bit stuck on how to apply the probes. I have one global skybox and several local probes with bounding boxes, which may overlap. So - my questions are: 1) In a forward renderer I would bind all the probes, find the ones that influence the current object and blend them somehow. For deferred I would basically render the probes' volumes, but how can I calculate individual weights if I just render volume after volume? I've read through this article and some of the references, but couldn't find anything, sorry if I overlooked something. 2) Low resolution reflection probes should not contain the skybox. I would like to use the high resolution skybox as reflection source for any pixel that reflects the sky. Would this work / does this make sense? Maybe with using the stencil buffer somehow to mask those "unrendered" areas? I'm touching this subject for the first time, so any help or pointers in the right direction is greatly appreciated. Thanks!
  4. I'm building a small framework with DirectX 12.  Current topic is the handling of shader parameters and the DX 12 root signature.   When loading a shader, I reflect all its bind points, and register them with a central ParamManager by name. The application provides the data from various points (global frame data, material data, mvp, etc.). Before draw, the ParamManager should be able to resolve all bindings.   It isn't finished yet, but looks like it could work quite well. Main inspiration for this is the Hieroglyph3 engine (http://hieroglyph3.codeplex.com/).   Now, how should I handle the DX 12 root signature?   I think about doing this:   - for each binding in the shader, specify its update frequency: per frame, per material, per object. It would be great if this could be done with custom annotations. I.e:   [UsageStatic] ConstantBuffer<PerFrameData> : register(b0)  Idea taken from: http://diligentgraphics.com/2016/03/23/resource-binding-model-in-diligent-engine-2-0/   - I would then, after initial load of all shaders, loop through all needed parameters, group them by frequency, and dynamically build a root signature. There could maybe be one root signature per pass. Maybe shaders could also specify an annotation like [HintUseOwnRootSignature] for special cases.     1. Is this a meaningful approach or just nonsense? :) Should I just hardcode some root signature and make sure the shaders match? Bind CBs to slots by convection maybe? How do you handle the root signature? I also like the idea of specifying the signature in HLSL.   2. Would this custom annotation-thing work? I'm not sure how to specify metadata (all shaders are pure hlsl) in a simple way. I've seen this done with Lua, XML, Json, ...     I think this dynamic-signature-approach could also work, if at some point I decide to only use dynamic indexing. It's still just grouped parameters.   Thanks for reading and your help  :)
  5. Thanks for the info.   ... I just found the BuddyAllocator from the DirectX samples, which exactly describes these two strategies. https://github.com/Microsoft/DirectX-Graphics-Samples/blob/master/MiniEngine/Core/BuddyAllocator.h
  6. Hello forum,   I have been a quiet reader for some time now, a lot of questions already have been answered, so thanks :) I'm just starting with C++ and DirectX12, coming from web development. It's so much fun... ;)   One question about buffers. They live in one of two types of heaps: upload, and default.   Upload buffers are used for data which changes quite often, so I create one big upload buffer, suballocate as needed and just store offset and size.  Per object data, dynamic vertices, etc.   How about a buffer which lives in a default heap? Can you suballocate the same way? Create one big resource? Or is management in the default heap always done through methods like CreatePlacedResource, CreateReservedResource, ...?   The reason this came up: I try to write small wrapper classes for constant, vertex and index buffers, and I would like the classes to take an argument dynamic/static. I'm not sure how to handle this.   Thanks, Chris
  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!