View Poll Results: DO YOU THINK NVIDEA SHOULD DEVELOP MORE MDL FEATURES SAMPLES ?

Voters
1. You may not vote on this poll
  • YES ... Its Important they do it as Soon !

    1 100.00%
  • NO ... Well I am happy with Current Mdl Situation ( And others not know my mdl Code secrets .. )

    0 0%
  • MAIBE ... Nvidea Should update IRAY Features first ... ( might take some years tho ... )

    1 100.00%
Multiple Choice Poll.
Results 1 to 4 of 4

Thread: DEVELOPING SKIN SHADERS IN IRAY - We need MORE MDL SAMPLES PLEASE !

  1. #1
    Join Date
    Aug 2016
    Posts
    23

    Talking DEVELOPING SKIN SHADERS IN IRAY - We need MORE MDL SAMPLES PLEASE !


    ( Art by Chemicq One of our Skin ENtusiast Partners That been Testing our Iray Mdl Shaders : http://fav.me/db6ruaz )

    We ACTUALLY have Severall MDL Products for DAZSTUDIO IRAY Made and in STORE :

    https://gumroad.com/l/DualUber2v101

    https://gumroad.com/l/3DD-Ultimate-Uber-Layers-Fx1

    Wille they Are a BIT Too much Advanced for Daz3D users
    - And Dazstudio Interface / And Compiler Actually Dont work too well with Many Mdl Parameters ...


    We Did our best To Try to Improve SKINS in DazStudio Iray !

    But SEAMS its a IMPOSSIBLE Task
    If NVIDEA Dont Update MDL and IRAY Shader Features

    Ho well ...

    Click image for larger version. 

Name:	ULTIMATE_20UBER_20FX_20PROMO_201-50_25.jpg 
Views:	44 
Size:	164.8 KB 
ID:	9879

    HI EVERYONE !


    Man This Nvidea Iray MDL foruns are a Bit Abandoned on news ... or its just me ?
    Are there so few IRAY MDL Developers in this world ??



    Soo

    To Shake Things up As usually ...



    DO WE HAVE ANY NEWS ON SKIN SHADERS DEVELOPMENT FROM NVIDEA ?

    Did Those WIP Codes From Nvidea Mdl Developers From 2 years ago Improved ?

    CAN WE HAVE SOME MORE OPEN MDL SAMPLES FOR ADVANCED SKIN SHADERS IN IRAY PLEASE!

    Thanks so much For Listening



    PS: Been Lately Studying OSL Language
    And Seams its a Bit More Intricate than MDL

    Even CHAOS Vray / Corona Group
    Been Abanding a Bit MDL to Fully SUpport OSL

    https://docs.chaosgroup.com/display/OSLShaders

    I WOUNDER HOW HARD CAN BE TO PORT OSL TO MDL

    MAIBE IRAY DEVELOPERS SHOULD GO IN THE TREND AND ALSO FULLY SUPPORT OSL IN IRAY NEXT VERSIONS ?
    To Keep IRAY on Par with Other Renderers Features ?

    Iv been Discovering Some Interesting Sources
    As the PORT of ARNOLD ALSHADERS - to OSL

    https://goo.gl/5Htu7p

    https://goo.gl/egz2K3

    If ALSHADERS Are Converted to OSL

    Does This Mean we are a Step Further of Converting from OSL to MDL ?
    Or do OSL Language have More Features than MDL ?

    Wich mean at some point OSL Universal Usage Might Overpass MDL
    If Nvidea Doesnt Reaaly Update the Features in MDL Language

    OSL Support is Being used in So many Renderers today
    And Achieving the Goal of what MDL Should be

    WILLE MDL LANGUAGE IS ALOT MORE EASY To WOrk with
    Expecially with the NodeBased Integrations

    SO ITS CRUSSIAL AND WE REAALY NEED MORE MDL SHADERS CODE SAMPLES ! FOR EVERYTHING !

    STARTING UP ON MORE SKIN SHADERS DEVELOPMENT IN MDL !

    ...


    WHAT DO YOU GREATH GUYS THINK ?

    Thanks for the Support !



    PS2: Here is a Chalenge ! For Iray Developers !

    CONVERTING EMILY OSL SHADER TO MDL
    ( just a Appetizer ... )

    Code:
    float phongExponent(float glossiness) {
    	return (1/pow(1-glossiness, 3.5)-1);
    }
    
    surface emily_material
    (
      string specularUnlitNormTexture="00_specular_unlit.exr",
      string singleScatterTexture="00_single_scatter.exr",
      string diffuseUnlitTexture="00_diffuse_unlit.exr",
      float scatterRadius=0.5,
      color scatterColor=color(0.482, 0.169, 0.109),
      float ior=1.33,
      float phaseFunction=0.8
    )
    {
    	color diffuseUnlit=texture(diffuseUnlitTexture, u, v);
    	color singleScatter=texture(singleScatterTexture, u, v);
    	color specularUnlit=texture(specularUnlitNormTexture, u, v);
    
    	// Single scattering is approximated with a diffuse closure
    	color diffuseAmount=singleScatter;
    
    	// Multiple scattering reduced with the single scattering amount
    	color sssAmount=(color(1,1,1)-singleScatter)*diffuseUnlit;
    
    	// We have two Phong specular lobes with equal strength, so each is half as bright
    	color specularAmount=specularUnlit*0.5;
    
    	// Fresnel coefficient; this should really be glossy Fresnel that takes into
    	// account the specular roughness, but for the moment we are just using the
    	// perfect mirror Fresnel.
    	float fresnelCoeff, refractionStrength;
    	vector reflectDir, refractDir;
    	fresnel(I, N, ior, fresnelCoeff, refractionStrength, reflectDir, refractDir);
    
    	specularAmount*=fresnelCoeff;
    
    	// Compute the final result.
     	Ci=
     		specularAmount*phong(N, phongExponent(0.55))+
     		specularAmount*phong(N, phongExponent(0.75))+
     		diffuseAmount*diffuse(N)+
     		subsurface(ior, phaseFunction, scatterColor*scatterRadius, sssAmount);
    }



    CONVERTING ALSURFACE OSL SHADER TO MDL ( a Bit more of a REAL Challenge For REAL coders This one : )

    Code:
    Needed Dependencies:
    
    https://goo.gl/E9ofzu
    https://goo.gl/r4Tiuy
    https://goo.gl/oiH66r
     
    ------------------------------------------
    
    #include "appleseed/color/as_color_helpers.h"
    #include "appleseed/material/as_material_helpers.h"
    
    // Constants.
    #define BSSRDF_MODE_CUBIC       0
    #define BSSRDF_MODE_DIFFUSION   1
    #define BSSRDF_MODE_DIRECTIONAL 2
    #define BSSRDF_MODE_EMPIRICAL   3
    
    shader alSurface
    [[
        string help = "A physically plausible, energy-conserving, general-purpose surface shader.",
        string description = "Suitable for any dielectric or metallic material including skin, plastic, wood, metal, glass, etc.",
        string as_maya_node_name = "alSurface"
    ]]
    (
        normal in_globalNormal = N
        [[
            string as_maya_attribute_name = "normalCamera",
            string as_maya_attribute_name = "n"
        ]],
        vector Tn = 0
        [[
            int lockgeom = 0,
            string widget = "null"
        ]],
    
        normal in_diffuseNormal = normal(0)
        [[
            string as_maya_attribute_name = "diffuseNormal"
        ]],
        float in_diffuseStrength = 1
        [[
            string as_maya_attribute_name = "diffuseStrength"
        ]],
        color in_diffuseColor =  color(0.5)
        [[
            string as_maya_attribute_name = "diffuseColor"
        ]],
        float in_diffuseRoughness = 0
        [[
            string as_maya_attribute_name = "diffuseRoughness"
        ]],
    
        float in_backlightStrength = 0
        [[
            string as_maya_attribute_name = "backlightStrength"
        ]],
        color in_backlightColor = color(0.18)
        [[
            string as_maya_attribute_name = "backlightColor"
        ]],
    
        float in_sssMix = 0
        [[
            string as_maya_attribute_name = "sssMix"
        ]],
        int in_sssMode = 0
        [[
            string as_maya_attribute_name = "sssMode"
        ]],
        float in_sssRadius = 1.5
        [[
            string as_maya_attribute_name = "sssRadius"
        ]],
        float in_sssWeight1 = 1
        [[
            string as_maya_attribute_name = "sssWeight1"
        ]],
        color in_sssRadiusColor = color(0.439, 0.156, 0.078)
        [[
            string as_maya_attribute_name = "sssRadiusColor"
        ]],
        float in_sssRadius2 = 4.0
        [[
            string as_maya_attribute_name = "sssRadius2"
        ]],
        float in_sssWeight2 = 0
        [[
            string as_maya_attribute_name = "sssWeight2"
        ]],
        color in_sssRadiusColor2 = color(0.439, 0.08, 0.018)
        [[
            string as_maya_attribute_name = "sssRadiusColor2"
        ]],
        float in_sssRadius3 = 0.75
        [[
            string as_maya_attribute_name = "sssRadius3"
        ]],
        float in_sssWeight3 = 0
        [[
            string as_maya_attribute_name = "sssWeight3"
        ]],
        color in_sssRadiusColor3 = color(0.523, 0.637, 0.667)
        [[
            string as_maya_attribute_name = "sssRadiusColor3"
        ]],
        float in_sssDensityScale = 1
        [[
            string as_maya_attribute_name = "sssDensityScale"
        ]],
    
        normal in_specular1Normal = normal(0)
        [[
            string as_maya_attribute_name = "specular1Normal"
        ]],
        float in_specular1Strength = 1
        [[
            string as_maya_attribute_name = "specular1Strength"
        ]],
        color in_specular1Color = color(1)
        [[
            string as_maya_attribute_name = "specular1Color"
        ]],
        float in_specular1Roughness = 0.3
        [[
            string as_maya_attribute_name = "specular1Roughness"
        ]],
        float in_specular1Anisotropy = 0
        [[
            string as_maya_attribute_name = "specular1Anisotropy"
        ]],
        float in_specular1Rotation = 0
        [[
            string as_maya_attribute_name = "specular1Rotation"
        ]],
        int in_specular1FresnelMode = 0
        [[
            string as_maya_attribute_name = "specular1FresnelMode"
        ]],
        float in_specular1Ior= 1.4
        [[
            string as_maya_attribute_name = "specular1Ior"
        ]],
        color in_specular1Reflectivity = color(0.548, 0.549, 0.570)
        [[
            string as_maya_attribute_name = "specular1Reflectivity"
        ]],
        color in_specular1EdgeTint = color(0.579, 0.598, 0.620)
        [[
            string as_maya_attribute_name = "specular1EdgeTint"
        ]],
        float in_specular1RoughnessDepthScale = 1
        [[
            string as_maya_attribute_name = "specular1RoughnessDepthScale"
        ]],
        int in_specular1Distribution = 0
        [[
            string as_maya_attribute_name = "specular1Distribution"
        ]],
    
        normal in_specular2Normal = normal(0)
        [[
            string as_maya_attribute_name = "specular2Normal"
        ]],
        float in_specular2Strength = 0
        [[
            string as_maya_attribute_name = "specular2Strength"
        ]],
        color in_specular2Color = color(1)
        [[
            string as_maya_attribute_name = "specular2Color"
        ]],
        float in_specular2Roughness = 0
        [[
            string as_maya_attribute_name = "specular2Roughness"
        ]],
        float in_specular2Anisotropy = 0
        [[
            string as_maya_attribute_name = "specular2Anisotropy"
        ]],
        float in_specular2Rotation = 0
        [[
            string as_maya_attribute_name = "specular2Rotation"
        ]],
        int in_specular2FresnelMode = 0
        [[
            string as_maya_attribute_name = "specular2FresnelMode"
        ]],
        float in_specular2Ior = 1.4
        [[
            string as_maya_attribute_name = "specular2Ior"
        ]],
        color in_specular2Reflectivity = color(0.548, 0.549, 0.570)
        [[
            string as_maya_attribute_name = "specular2Reflectivity"
        ]],
        color in_specular2EdgeTint = color(0.579, 0.598, 0.620)
        [[
            string as_maya_attribute_name = "specular2EdgeTint"
        ]],
        float in_specular2RoughnessDepthScale = 1
        [[
            string as_maya_attribute_name = "specular2RoughnessDepthScale"
        ]],
        int in_specular2Distribution = 0
        [[
            string as_maya_attribute_name = "specular2Distribution"
        ]],
    
        normal in_transmissionNormal = normal(0)
        [[
            string as_maya_attribute_name = "transmissionNormal"
        ]],
        float in_transmissionStrength = 0
        [[
            string as_maya_attribute_name = "transmissionStrength"
        ]],
        color in_transmissionColor = color(1)
        [[
            string as_maya_attribute_name = "transmissionColor"
        ]],
        int in_transmissionLinkToSpecular1 = 1
        [[
            string as_maya_attribute_name = "transmissionLinkToSpecular1"
        ]],
        float in_transmissionRoughness = 0
        [[
            string as_maya_attribute_name = "transmissionRoughness"
        ]],
        float in_transmissionIor = 1.4
        [[
            string as_maya_attribute_name = "transmissionIor"
        ]],
        float in_transmissionRoughnessDepthScale = 1
        [[
            string as_maya_attribute_name = "transmissionRoughnessDepthScale"
        ]],
    
        color in_ssAttenuationColor = color(1)
        [[
            string as_maya_attribute_name = "ssAttenuationColor"
        ]],
        float in_ssDensityScale = 1
        [[
            string as_maya_attribute_name = "ssDensityScale"
        ]],
    
        float in_emissionStrength = 0
        [[
            string as_maya_attribute_name = "emissionStrength"
        ]],
        color in_emissionColor = color(1)
        [[
            string as_maya_attribute_name = "emissionColor"
        ]],
    
        color in_opacity = 1
        [[
            string as_maya_attribute_name = "opacity"
        ]],
    
        output closure color out_result = 0
        [[
            string as_maya_attribute_name = "outColor",
            string as_maya_attribute_short_name = "oc"
        ]]
    )
    {
        int do_diffuse = 1;
        int do_backlight = 1;
        int do_sss = 1;
        int do_transmission = 1;
        int do_emission = 1;
        int do_glossy2 = 1;
        int do_glossy = 1;
    
        if (raytype("transparency") || raytype("shadow"))
        {
            if (min(in_opacity) < 1.0)
                out_result = (color(1) - in_opacity) * transparent();
        }
    
        if (raytype("transparency"))
            return;
    
        if (raytype("shadow"))
        {
            do_diffuse = 0;
            do_backlight = 0;
            do_sss = 0;
            do_transmission = 1;
            do_emission = 0;
            do_glossy2 = 0;
            do_glossy = 0;
        }
        else if (raytype("light"))
        {
            do_diffuse = 0;
            do_backlight = 0;
            do_sss = 0;
            do_transmission = 0;
            do_emission = 1;
            do_glossy2 = 0;
            do_glossy = 0;
        }
    
        // Balance diffuse, transmission and backlight
        color transmissionColor = in_transmissionColor * in_transmissionStrength;
        color diffuseColor = in_diffuseColor * in_diffuseStrength;
        color backlightColor = in_backlightColor * in_backlightStrength;
        float t_sum = max(transmissionColor) + max(diffuseColor) + max(backlightColor);
    
        if (t_sum > 1.0)
        {
            float t_sum_inv = 1.0 / t_sum;
            transmissionColor *= t_sum_inv;
            diffuseColor      *= t_sum_inv;
            backlightColor    *= t_sum_inv;
        }
    
        // Disable closures we don't need.
        if (max(diffuseColor) < IMPORTANCE_THRESHOLD || in_sssMix == 1.0)
            do_diffuse = 0;
    
        if (max(backlightColor) < IMPORTANCE_THRESHOLD || in_sssMix == 1.0)
            do_backlight = 0;
    
        if (in_sssMix == 0.0 || max(diffuseColor) < IMPORTANCE_THRESHOLD)
            do_sss = 0;
    
        if (max(transmissionColor) < IMPORTANCE_THRESHOLD || in_sssMix == 1.0)
            do_transmission = 0;
    
        color emissionColor = in_emissionColor * in_emissionStrength;
        if (max(emissionColor) < IMPORTANCE_THRESHOLD)
            do_emission = 0;
    
        color specular1Color = in_specular1Color * in_specular1Strength;
        if (max(specular1Color) < IMPORTANCE_THRESHOLD)
            do_glossy = 0;
    
        color specular2Color = in_specular2Color * in_specular2Strength;
        if (max(specular2Color) < IMPORTANCE_THRESHOLD)
            do_glossy2 = 0;
    
        // Normals.
        normal globalNormal = normalize(in_globalNormal);
        normal diffuseNormal = globalNormal;
        normal transmissionNormal = globalNormal;
        normal specular2Normal = globalNormal;
        normal specular1Normal = globalNormal;
    
        if (isconnected(in_diffuseNormal))
            diffuseNormal = normalize(in_diffuseNormal);
    
        if (isconnected(in_transmissionNormal))
            transmissionNormal = normalize(in_transmissionNormal);
    
        if (isconnected(in_specular2Normal))
            specular2Normal = normalize(in_specular2Normal);
    
        if (isconnected(in_specular1Normal))
            specular1Normal = normalize(in_specular1Normal);
    
        // Create closures.
        if (do_diffuse)
            out_result += diffuseColor *
                (1.0 - in_sssMix) * oren_nayar(diffuseNormal, in_diffuseRoughness);
    
        if (do_backlight)
            out_result += backlightColor *
                (1.0 - in_sssMix) * translucent(diffuseNormal);
    
        if (do_sss)
        {
            color sssColor = diffuseColor * in_sssMix;
            float sssIor = 1.3;
    
            // Normalize the SSS weights.
            float weights[3] = {in_sssWeight1, in_sssWeight2, in_sssWeight3};
            float rcpSumWeight = 1.0 / (weights[0] + weights[1] + weights[2]);
            weights[0] *= rcpSumWeight;
            weights[1] *= rcpSumWeight;
            weights[2] *= rcpSumWeight;
    
            // Zero small weights.
            weights[0] = weights[0] > IMPORTANCE_THRESHOLD ? weights[0] : 0.0;
            weights[1] = weights[1] > IMPORTANCE_THRESHOLD ? weights[1] : 0.0;
            weights[2] = weights[2] > IMPORTANCE_THRESHOLD ? weights[2] : 0.0;
    
            string profile;
            if (in_sssMode == BSSRDF_MODE_CUBIC)
                profile = "gaussian";
            else if (in_sssMode == BSSRDF_MODE_DIFFUSION)
                profile = "better_dipole";
            else
                profile = "normalized_diffusion";
    
            color radii[3];
            radii[0] = max(color(0.0001), in_sssRadius  * in_sssRadiusColor  / (in_sssDensityScale * 7.0));
            radii[1] = max(color(0.0001), in_sssRadius2 * in_sssRadiusColor2 / (in_sssDensityScale * 7.0));
            radii[2] = max(color(0.0001), in_sssRadius3 * in_sssRadiusColor3 / (in_sssDensityScale * 7.0));
    
            // Add the SSS closures.
            for (int i = 0; i < 3; ++i)
            {
                if (weights[i] > 0.0)
                {
                    out_result += sssColor * weights[i] *
                    as_subsurface(
                        profile,
                        diffuseNormal,
                        color(1.0),
                        radii[i],
                        sssIor,
                        "fresnel_weight", 0.0);
                }
            }
        }
    
        if (do_transmission)
        {
            float transmissionRoughness = in_transmissionRoughness;
            float transmissionIor = in_transmissionIor;
    
            if (in_transmissionLinkToSpecular1)
            {
                transmissionRoughness = in_specular1Roughness;
                transmissionIor = in_specular1Ior;
            }
    
            color volumeTransmittanceColor = color(1);
            float volumeTransmittanceDistance = 0.0;
    
            if (min(in_ssAttenuationColor) < 1.0)
            {
                // Compute absorption.
                color sigmaA = (color(1) - clamp(
                        in_ssAttenuationColor,
                        color(0), color(0.999))) * in_ssDensityScale;
    
                // Convert to transmittance.
                volumeTransmittanceColor = exp(-sigmaA);
                volumeTransmittanceDistance = 1.0;
            }
    
            out_result += (1.0 - in_sssMix) * as_glass(
                "beckmann",
                transmissionNormal,
                vector(0),
                transmissionColor,
                color(0), // transmission only.
                color(1),
                transmissionRoughness,
                0,
                transmissionIor,
                volumeTransmittanceColor,
                volumeTransmittanceDistance);
        }
    
        if (do_emission)
            out_result += emissionColor * emission();
    
        if (do_glossy2)
        {
            vector T = Tn;
    
            if (in_specular2Rotation != 0)
            {
                T = rotate(
                    T,
                    -in_specular2Rotation * M_PI,
                    point(0),
                    point(specular2Normal));
            }
    
            out_result = as_alsurface_layer(
                out_result,
                in_specular2Distribution,
                specular2Normal,
                T,
                specular2Color,
                in_specular2Roughness,
                in_specular2Anisotropy,
                in_specular2FresnelMode,
                in_specular2Ior,
                in_specular2Reflectivity,
                in_specular2EdgeTint);
        }
    
        if (do_glossy)
        {
            vector T = Tn;
    
            if (in_specular1Rotation != 0)
            {
                T = rotate(
                    T,
                    -in_specular1Rotation * M_PI,
                    point(0),
                    point(specular1Normal));
            }
    
            out_result = as_alsurface_layer(
                out_result,
                in_specular1Distribution,
                specular1Normal,
                T,
                specular1Color,
                in_specular1Roughness,
                in_specular1Anisotropy,
                in_specular1FresnelMode,
                in_specular1Ior,
                in_specular1Reflectivity,
                in_specular1EdgeTint);
        }
    }
    I WOunder WHen NVIDEA MDL Will Keep up to OSL Features and Samples ...
    Maibe in more 5 or 6 Years ?

  2. #2
    Join Date
    Jan 2007
    Posts
    314

    Default

    OSL and MDL are pretty different in the sense that OSL is a shading language and MDL is a physically based material definition language. OSL is not strictly physical plausible which can be seen in the emily shader which breaks physics in various places (it generates energy towards the edge and more) In a modern pathtracer that shader will simply explode (creases in geometry will start to glow). A physical plausible variant of that shader is trivial in MDL.

    al_surface shows another issue of OSL: OSL support alone is not enough to run that shader. The shader uses custom, renderer specific closures (as_subsurface, as_glass, as_alsurface_layer) so this shader will not run in renderers that have not implemented those closures. I believe the al_surface OSL shader will run in Arnold only at the moment. And for a port it should be documented what exactly those closures do.
    Standard OSL has no more SSS features than MDL and has no support for BSDF layering, OSL leaves those to the individual renderers.
    Last edited by JanJordan; November 7th, 2017 at 11:55.

  3. #3
    Join Date
    Aug 2016
    Posts
    23

    Default

    Hello Dear Sir Jan Jordan

    Very Interesting Analisis Yours Comming from a industry best Shader Developer. Means Alot.

    Thanks so much for sharing your expert Visions on MDL and OSL

    ....

    Wille that Sincerely ... only refines my tought that ...

    NVIDEA is getting a bit behind the competition , Not Supporting More Iray Shader Features And Give more Support to MDL Language developers to Florish ...

    Iv seen you been updating Mdl Language reference Pdfs online content with latest update in 1 year to be the illucidating How to compose "plastic materials " ...

    Wich is Awsome ... But not nearly enouph ...

    ( would be better if it was a complete 200 pages article on how to compose and translate gpu gems to Mdl as Gpugems advanced skins etc ... )

    Yet no one Available to do it at NVIDEA heartquarters
    And few bosses caring really ...

    As sure NVIDEA employees have Alot better to do ...

    And All Are Ruled By The "RoadMap List" ...

    Not Really on Customers Needs ...

    ...

    So there is no Breack trough ...
    Of IRAY Community
    developers needs

    And Iray Bosses

    Wich Just Listen to IRAY Sdk Company owners ...

    Not the "Community Voice" Really...

    ...

    My Feeling is that NVIDEA As Bigger Goals for Mdl Language in the future ...

    Like Transforming Iray into 2 Engines ... Like Octane ( The renderer ) And ( Brigade ) The Realtime Renderer ...

    Wich in NVIDEA purposes would be ...

    - IRAY The Phisicaly Based Renderer
    - REALRAY * The Realtime Renderer ...

    A render for architects much like LUMION 8 is today ...
    but that can be used also to create realtime Vr Aplications

    Being Mdl Language Biggest Goal ...

    To serve as unified platform of features between both renderers ...

    So NVIDEA is basically holding on the horses and investments
    On both financially and man power ...

    Untill NVIDEA Finish that Big "Secret" Move ...

    And Release it as a blast ...
    To Shake Market Shares ...

    Of Both Cycles, Evee , And Lumion, And Otoy Brigade and Octane ...

    And Maybe NVIDEA will do that ...

    Integrating that Real-time IRAY For VR Renderer ...

    Toguether With AMAZON LUMBERYARD ...

    As a Realtime Cinematic Engine ...
    Behind CRYENGINE as they did in Cryengine CINEMA version ...

    So to enter a bit on Epic UNREAL markets Businesses
    That way with that in Goal ...

    NVIDEA is not updating IRAY engine Shader Features = On Purpose

    And focusing on other more important Areas in IRAY and IRAY VR Road map ...

    So MDL Language and whole IRAY shader pipeline is just not that much updated even in several Years
    ... So things Become more easy Code wise for Developers ...
    To Apply the Exact Same MDL Language features to both IRAY and IRAY VR realtime renderer ...

    ...

    Im not Nostradamus ...

    But im constantly studying close All movements of nvidea in this Field ... and watching all Nvidea Seminars...

    ...

    YET ....

    I think Nvidea is shooting a bit on its own Foot For TAKING TOO LONG ...

    And also as usually ( not taking compromises ) even on its own developed tecnology ...

    Wille i can understand this from a high research group as NVIDEA that is always making hundreds experiments on all fields and forms...

    And most of this experiments ( wrongly ) been left on Laboratory ...

    Instead of being more "Gifthubed" and leave as open, VoxelGi VSGI and whole gameworks been on UNREAL engine ...

    Wich was a Awsome Move with Amazing Sucess...

    Wich ALL IRAY head developers
    Should take as example ...

    And start to develop more OPEN all their iray Developments Experiences and Daily development Builds TROUGH GITHUB.COM ...

    Starting By YOU : Dear sir Jan Jordan ...

    - You could And Really Should Make

    - A big Weekly Repository in Github.com

    Were you would share in a centralized registered place,

    All Your, and Your Fellow Colleagues at Nvidea , weekly work and Research within MDL and overal IRAY for all platforms Advances ...

    That both in a big Shaders Repository
    and Well Whole Nvidea Iray MDL SDK
    Pipeline Source codes ...

    Should be Released At GitHub.

    For a More Communitary "Ala Unreal Epic" Proprietary, But Open Weekly and Daily Development Be Achieved Faster with more interaction with the Community.

    Could You Please Mister Jan

    Reach Your Bosses At Nvidea.

    With this Communitary Idea REQUEST.

    ...

    Thanks So much For Listen

    Thanks So deeply Much For Your Support

    Ruben Ismael

    SOULSStudios
    / IRAY 3D MERCHANTS at DAZ3D.com
    Last edited by SOULSSAGA; November 7th, 2017 at 14:46.

  4. #4
    Join Date
    Jan 2007
    Posts
    314

    Default

    The last update of the MDL handbook was actually august 21st and about bump and displacement mapping in MDL. In addition there is lots of sample code out. If you install the nvidia::vMaterials, you will also get a lot of basic materials in C:\ProgramData\NVIDIA Corporation\mdl, namely the complete MDL source to the modules used in maya (ifm.mdl) max (Lw*.mdl), sources from nvidia (nvidia::core_definitions) and allegorithmic.

    Involving the community more is certainly a good thing and i hope to have news about that soon.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •