Welcome to od|forum

Register now to gain access to all of our features. Once registered and logged in, you will be able to contribute to this site by submitting your own content or replying to existing content. You'll be able to customize your profile, receive reputation points as a reward for submitting content, while also communicating with other members via your own private inbox, plus much more! This message will be removed once you have signed in.

OskarSwierad

Members
  • Content count

    29
  • Joined

  • Last visited

  • Days Won

    2

Community Reputation

16 Good

About OskarSwierad

  • Rank
    Peon

Contact Methods

  • Website URL http://oskarswierad.com

Personal Information

  • Name Oskar
  • Location Poland

Recent Profile Visitors

950 profile views
  1. Hi! I prefer ACES for personal projects or early (concept) renders - and Hable or S-Log for previewing work that will be sent further to compositing. I'd like to build some custom tonemappers at some point. Like in "Advanced Techniques and Optimization of HDR Color Pipelines" by Timothy Lottes: http://developer.amd.com/resources/conference-presentations/ I generate LUTs for Houdini with a standalone Python script: # User options: RANGE_MIN = 0.001 # Minimum input pixel brightness () RANGE_MAX = 10.0 # Max input pixel brightness value LENGTH = 1024 # Number of LUT entries (precision) EXPOSURE = 1.0 # Multiplier. Useful range is 0.125 - 8.0. Default is 1.0 OUTPUT_IN_SRGB = False # False means linear TONEMAPPING = 'SLog' # 'ACES', 'Hable' or 'SLog' import math def saturate(value): return max(0.0, min(value, 1.0)) pass def s_log_tonemap(x): # Adapted from "S-Log: A new LUT for digital # production mastering and interchange applications" # https://pro.sony.com/bbsccms/assets/files/mkt/cinema/solutions/slog_manual.pdf result = ((0.432699 * math.log10(x + 0.037584) + 0.616596) + 0.03) return saturate(result) def hable_tonemap_core(x): # Hable (Uncharted 2) Tonemapping # Adapted from code by John Hable # http://filmicgames.com/archives/75 hA = 0.15 hB = 0.50 hC = 0.10 hD = 0.20 hE = 0.02 hF = 0.30 return ((x*(hA*x+hC*hB)+hD*hE) / (x*(hA*x+hB)+hD*hF)) - hE/hF def hable_tonemap(x): tonemapped = hable_tonemap_core(x) hW = 11.2 whiteScale = 1.0 / hable_tonemap_core(hW) return saturate(tonemapped * whiteScale) def aces_tonemap(x): # ACES Filmic Tone Mapping Curve # Adapted from code by Krzysztof Narkowicz # https://knarkowicz.wordpress.com/2016/01/06/ # aces-filmic-tone-mapping-curve/ tA = 2.51 tB = 0.03 tC = 2.43 tD = 0.59 tE = 0.14 result = (x * (tA*x + tB)) / (x * (tC*x + tD) + tE) return saturate(result) def linear_to_gamma_space(x): return pow(x, 1/2.2) pass def gamma_to_linear_space(x): return pow(x, 2.2) pass def encode_linear_to_log(idx): # From Houdini HDK docs, "The Houdini LUT Format": # p = e^(idx * (ln(in_end) - ln(in_start)) / (length-1) + log(in_start)) return pow(math.e, ( idx*( math.log(RANGE_MAX) - math.log(RANGE_MIN) ) / (LENGTH-1) + math.log(RANGE_MIN) )) def calculate_values(): values = [] for idx in range(0, LENGTH): exposureCorrected = EXPOSURE * encode_linear_to_log(idx) result = 0.0 if TONEMAPPING == 'ACES': result = aces_tonemap(exposureCorrected) if OUTPUT_IN_SRGB: result = linear_to_gamma_space(result) elif TONEMAPPING == 'Hable': result = hable_tonemap(exposureCorrected) if OUTPUT_IN_SRGB: result = linear_to_gamma_space(result) elif TONEMAPPING == 'SLog': result = s_log_tonemap(exposureCorrected) if not OUTPUT_IN_SRGB: result = gamma_to_linear_space(result) values.append(result) return values def generate_text(values = []): txt = [ "Version\t\t3", "Format\t\tany", "Type\t\tC", "From\t\t" + str(RANGE_MIN) + " " + str(RANGE_MAX), "To\t\t\t0 1", "Black\t\t0", "White\t\t1", "Length\t\t" + str(LENGTH), "Sampling\tLog", "LUT:", "RGB {" ] for val in values: txt.append("\t" + str(val)) txt[-1] += " }\n" return ("\n").join(txt)
  2. I haven't read it yet, but it was recommended on http://realtimerendering.com book list and it's got good reviews on Amazon. 3D Math Primer for Graphics and Game Development, 2nd Edition by Fletcher Dunn et al. As for calculus, there is an old book Calculus Made Easy by Silvanus P. Thompson. Free to download at Project Gutenberg. If you find KhanAcademy's math lessons too long or just want text instead, check out amazing Paul's Notes. This is by a professor, started intially for his students. More cool resources: CodingMath on Youtube. Tightly edited. To the point. 3Blue1Brown on Youtube. More general math. Probably what Igor meant in the original post. Nature of Code. A book about programming behaviors and forces. Could be an easy first step to understanding how solvers work.
  3. @Atom: I encountered that problem too I don't know what could I improve in the shader at the moment. Limit volume bounces, though. Nine is way, way too much. You'll get similar effects with 4, even with 3. GI seems to be of help, but only slightly. What's needed is 10x improvement in speed, not 50%. I'm almost sure that the cause of noise is this: hundreds of samples are sent but - for narrow angles, like 0.99-0.995 - only a few of them contribute to the actual light. To fix this, one should discard samples early, right after calculating the dot product( nN, nI ).
  4. @Dennis: a shader could help here (I don't know what's the cause of the sharp falloff in the middle) geometry_spot_light_v002.hip
  5. Have developers discussed any plans for specular anti-aliasing in Mantra in the past? Is it planned, not possible or never mentioned? Thin speculars need outrageous amounts of pixel samples to look stable in animation. I was wondering how to deal with the problem. Ray variance seemed to respond well at first but for smaller reflections its blocks are too broad. Detecting high frequency of normals would be nice - including normal maps and shader displacement. Ideally, Mantra should send more rays there. If that's not possible, it could apply more filtering. Currently, I deal with specular aliasing by changing roughness dynamically, according to normals' derivatives First image is constant roughness 0.005, second is varied 0.005 - 0.25. The third are derivatives.
  6. Hi, The Light Bank doesn't show any lights that are inside an imported HDA. Allowing editing contents doesn't help. What I want is to have an .hda with a lighting rig for many scenes. Is there a way to work with digital assets' lights in Light Bank? Oskar edit: OK, nevermind. Now I use Paramter Spreadsheet instead
  7. I edited the original post with an interesting ACES tonemapping. The pictures compare both algorithms with the original photo. Here are also 1D LUT files (of 1024 length) that perform ACES curve. So you can use it straight in render view Range is 0.001 - 10.0. Still untested but seems to be working. (If used in a Lookup node, it requires 'Quantize' parameter to be set to 'Quantize at this node'. I don't know why.) ACES_LUTs.zip
  8. http://www.rohandalvi.net/commercial/- nice introduction to many basic topics http://www.rohandalvi.net/shader/- when you finally want your own shader, for procedural texturing or layer mixing http://www.cgsociety.org/training/course/vex-in-houdini- great one after you know the basic stuff and want to learn proper programming in Houdini https://www.fxphd.com/fxphd/courseDetails.php?idCourse=368- I heard that this exists but don't know anything about the quality
  9. Legomir renderer the snow as a VDB volume, with a modified Billowy Smoke shader from the material pallette: I also seen a test of his where he converted it to polygons, then rendered with a shader similar to mine (what Izat linked). That is, principled shader + raytraced SSS (plugged in as Ce - emission).
  10. Amazing shading, lighting... everything Cheerful look without colors being oversaturated - that's cool too.
  11. Thank you both. I just watched Outerra's FMX slides on procedural terrain with interesting features - not just generic. Many similar problems which I encountered were approached in clever, simple ways. For example: - they add horizontal displacements after the typical height noise - slope calculations drive many things: random pebbles placement, more or less random disp, ... - mountain peaks are extra-sharpened I recommend reading it if you're interested in the topic - http://forum.outerra.com/FMX/presentation/
  12. Thanks. I agree with all of that As for the blue color, you posted a very nice reference. Maybe my sky is too desaturated (though I intentionally wanted to avoid 'polarizing filter' look).
  13. Hi, Maybe you stumbled upon my video on facebook Houdini Artists. Still, I cross-post because I'd like to get your critique - which is something hard to get on facebook! I'm working on a snow-covered terrain shading and rendering in Mantra. The geometry was sculpted by another artist but I added some details with displacements. I want to achieve a look of smooth, almost untouched snow covering rocky highlands (not Arctic glaciers). What can I improve? ~20 min per frame at 720p on Intel i7-3770 Still frame: For comparison, original terrain model (plain diffuse material):
  14. Looks really nice to use, especially with this curve. I have a problem, though, running the file on Houdini 15.0.313. Your node returns that error: Non-float value for 'previewScale' Unknown parameter: '2'
  15. Whoa, great Somehow I didn't come across your post when I searched for 'houdini tonemapping'. Having found nothing, I decided to write such a node.