Michael Davidog

Members
  • Content count

    7
  • Joined

  • Last visited

Community Reputation

0 Neutral

About Michael Davidog

  • Rank
    Newbie

Personal Information

  • Interests
    Art
    Audio
    Business
    Design
    DevOps
    Education
    Production
    Programming
    QA
  1. Radiosity C++ Directx 11 implementation

    To make that in real time, we can use the Instant Radiosity (from Keller (in 1997)) And Final gathering - that much faster than photon-based GI It based on site of Hugo Elias who documented his radiosity light mapper http://web.archive.org/web/20160311085440/http://freespace.virgin.net/hugo.elias/radiosity/radiosity.htm
  2. Radiosity C++ Directx 11 implementation

    that's what I need! Thanks! Did you read this book?
  3. Radiosity C++ Directx 11 implementation

    You can download it from here http://www.helios32.com/resources.htm But if I will follow this book I will get modern knowledge how to implement things like Enlighten and plug into an engine? Enlighten using radiosity with Final Gathering (i.e. photon mapping?)? https://twitter.com/pigselated/status/676711568990711808
  4. Radiosity C++ Directx 11 implementation

    Enlighten split direct lights to GPU and indirect to CPU (Enlighten is for indirect lights only on CPU): 1. Point sampling geometry surface - done via Final gathering (without any irradiance caching) with denoising - VPL/Instant radiosity method - I guess there no surfels/disks (GPU) 2. Project on low detail environment mesh - "The framebuffer of the previous frame is sampled sparsely on the GPU and subsequently those samples are transferred to CPU memory as input for the radiosity algorithm. The samples are projected on the low resolution proxy mesh which initializes the radiosity algorithm. Only one iteration of radiosity propagation is executed per frame. Multiple light bounces are simulated by using the previous frame as light input for the computation." 3. Compute radiosity - "The radiosity algorithm itself is executed on the CPU using a low resolution proxy mesh of the original mesh which resides in GPU memory." 4. Transfer radiosity textures to the GPU - "After the radiosity solution has been computed, the solution is transferred back to the GPU in a lightmap format." - I guess using wavelet compression to make data flow faster. 5. Sample radiosity on high detail mesh - "The lightmap is sampled on the high resolution mesh with the use of a smart upsampling technique." - I guess using UV unwrapper. Can you please advice me some good books/resources? This is the same principle as "patches" but clusters are hierachical and bigger? How can I to begin? So it is possible to divide surface into surfels and polygons? What is better? And how I can make it with polygons? Thank! But I still don't understand it. That's will looks like this: #include <iostream> Using namespace std; Struct receiver { vector receivedLight; vector outgoingLight; vector color; }; Struct emitter { vector outgoingLight; }; void surfaceSample receiver { vector formFactor; vector visibility; } void surfaceSample emitter { vector formFactor; vector visibility; } Int main (){ receiver * r; r = new receiver; emitter * e; e = new emitter; while (1) // What means "1" - one bounce? foreach (surfaceSample receiver) r->receivedLight = (0,0,0) foreach (surfaceSample emitter) r->receivedLight += emitter.outgoingLight * visibility(receiver,emitter) * formFactor(receiver,emitter) r->outgoingLight = receiver.color * r->receivedLight + receiver emittingLight // I don't understand this line delete r; delete e; } ? Yes, I want! I still don't understand all this code. I found some implementation: https://github.com/AlexanderTolmachev/radiosity-engine https://github.com/ands/lightmapper http://www.cs.cmu.edu/~./radiosity/dist/ http://dudka.cz/rrv but I don't understand all this code - I want to understand=) Radiosity: A Programmer's Perspective by Ian Ashdown (1994) - what do you think about this book (it's 23 years old, hehe)?
  5. Radiosity C++ Directx 11 implementation

    I just want to start making things by mysefl=) I need practical expirience, there so much papers around but I can't find any "paper to code" guide. So I don't know how to make existing solutions to work (in a code that I can use futher in an engine). I know there a lot of techniques but I can't implement any of them. Personally I would like to realize some Enlighten/Kuri ray-tracing+radiosity hybrid method. Here something similar http://www.nada.kth.se/~burenius/BureniusExjobb2009.pdf This guy also figured out how to implement it somehow https://blog.molecular-matters.com/2012/05/04/real-time-radiosity/
  6. Radiosity C++ Directx 11 implementation

    I don't have practical expirience and I don't know how to make all this things work in a code, so maybe I need to start from graphics programming (using directx 11/OpenGL)? Using hybrid approach (cpu + gpu) will give most benefits than pure cpu or pure gpu solution. So I want to make architecture like Enlighten. I want to make hardware- and API-agnostic system This is indirect lighting cache that interpolate indirect light on dynamic (e.g. animated)/small/complex objects using light probes? So this is spherical harmonic function (irradiance volumes)? but how ray-tracing used to make new lightmaps? Or lightmaps get information (normal and shadow mapping) from SH - one light probe per pixel? "The radiosity technique uses scalar form factors to describe the mutual influence of patches. In our solution, these form factors are replaced. For every light probe, each surface group as seen from the position of the probe is projected to SH coefficients and stored. This directional information allows to shade surfaces with normal mapping and dynamic objects whose normals are unknown during precomputation. For the shading of dynamic objects, light probes are placed in a regular 3D lightgrid. For static geometry, it is preferable to use lightmaps in order to avoid light bleeding, i.e. light being interpolated through solid objects. A lightmap is a texture that stores some kind of lighting information, in our case one light probe per pixel. To use lightmaps, a special set of UV coordinate is created for the scene. The surfaces are unwrapped in range [0, 1]^2 of the UV space without overlaps. The result is that every surface point references a unique position on the texture. Traditionally, lightmaps have been used to precalculate high-frequency static lighting and save it into an RGB texture. In our approach, a set of three textures for the tristimulus values are used to store spherical SH information about low-frequency indirect lighting only. The resolution of these textures is thus considerably lower than the resolution of commonly used lightmaps." Yes, this approach and Enlighten approach don't allow that. Is it possible somehow?
  7. Hello! Can you advice me learning resources how to develop (practically) Real-time Radiosity system using c++ and directx 11/OpenGL hybrid approach like this one http://www.davidkuri.de/downloads/SIC-GI.pdf ? Thanks!