We use cookies to ensure that we give you the best experience on our website. If you continue to use this site we will assume that you are happy with it.

Object clipping issues

Home Forums General Questions Object clipping issues

Viewing 14 posts - 1 through 14 (of 14 total)
  • Author
    Posts
  • #30892
    origgin
    Participant

    Hi guys, I am working on a lift configurator. The lift has 2 objects, ‘FRONT_CHAINS’ and ‘BACK_CHAINS’ which are supposed to be clipped at a specific dynamic height, located at the base of the ‘CHAIN_DRIVE’ object.

    Scene

    But unfortunately I do not have experience with 3D and I did not find a proper solution for my problem.

    I already tried different ways to solve this, but none of them has worked.

    My first attempt was creating a clipping plane, but far from successful :( I read verge 3d and threejs documentation about clipping planes and both were not enough clear for me. I unfortunately did not get how I could apply the newly created plane as a clipping plane in the material and if I should do something else (like setting the Local Clipping to true or even pushing the new plane to renderer.clippingPlanes (this one crashed the application)), and if so, how exactly should I do it. After some fails I gave up and started trying to do this using alpha clipping.

    So I asked a friend to create and apply a texture. A 2×2 PNG with a black and a white stripe. My idea was to move the texture using a custom value node created in blender, so I could set it using the puzzles. After a lot of research we find a way to control this, but again, did not work well. The values have different behavior than they had in blender and I can not work with them.

    I still guess the clipping plane would be the best solution for me, but I have no idea how to make this work in the code. I tried the code below but I do not notice any changes.

    var localPlane = new v3d.Plane(new v3d.Vector3(0, 0, -3), 0.8);
    
    v3d.apps[0].materials[34].clippingPlanes = [localPlane],
    v3d.apps[0].materials[34].clipShadows = true
    v3d.apps[0].materials[35].clippingPlanes = [localPlane],
    v3d.apps[0].materials[35].clipShadows = true
    
    v3d.apps[0].scene.children[35].castShadow = true

    But maybe there is even a way to do this animating the chains along a path so they really make the turn over the chain drive.

    I hope you guys can help me with that.
    Thanks ;)

    • This topic was modified 1 year, 4 months ago by origgin. Reason: Image link broken
    • This topic was modified 1 year, 4 months ago by origgin.
    • This topic was modified 1 year, 4 months ago by origgin.
    #30916

    Hi,
    Looks like you forgot to enable clipping planes on the renderer:
    v3d.apps[0].renderer.localClippingEnabled = true

    Verge3D’s Tech Chief
    FB | Twitter | VK

    #30920

    Also, it’s not recommended to access app.materials array directly, use v3d.SceneUtils.getMaterialByName() method instead.

    Verge3D’s Tech Chief
    FB | Twitter | VK

    #30930
    origgin
    Participant

    Hi, Looks like you forgot to enable clipping planes on the renderer: v3d.apps[0].renderer.localClippingEnabled = true

    Hi Alexander, thanks for the answer, but it also did not work for me. When I add this line to my code the result is exact the same as before (and the fps decrease a lot).

    Also, it’s not recommended to access app.materials array directly, use v3d.SceneUtils.getMaterialByName() method instead.

    This also does not work for me. It returns the following error

    v3d.js:1 Uncaught TypeError: Cannot read property 'length' of undefined
        at Object.getMaterialsByName (v3d.js:1)
        at Object.getMaterialByName (v3d.js:1)
        at <anonymous>:1:16

    Maybe I should mention that I am trying this all from the console at runtime. I do not know if there is any difference doing it so

    #30941

    Looks like you forgot app instance parameter:

    v3d.SceneUtils.getMaterialByName(v3d.apps[0], 'YourMaterial')

    As for clipping planes, it looks like you need different params for your plane. Keep in mind that Verge3D API coordinate space is different: x-left, y-up, z-forward. That means your clipping plane (0, 0, -3) is vertical, not horizontal. Use (0, -1, 0) or so.

    Verge3D’s Tech Chief
    FB | Twitter | VK

    #30943
    origgin
    Participant

    Looks like you forgot app instance parameter:
    v3d.SceneUtils.getMaterialByName(v3d.apps[0], 'YourMaterial')
    As for clipping planes, it looks like you need different params for your plane. Keep in mind that Verge3D API coordinate space is different: x-left, y-up, z-forward. That means your clipping plane (0, 0, -3) is vertical, not horizontal. Use (0, -1, 0) or so.

    So, this about the Verge3D coordinate system being different was new for me and this was actually the mystery behind the problem.

    Thank you very much :)

    I hope this topic can also help other people who are trying something similar.

    #30944
    origgin
    Participant

    I noticed that some time after I run this code, I get the following error

    The code:

    var localPlane = new v3d.Plane(new v3d.Vector3(0, -5, 0), 0.8);
    v3d.apps[0].renderer.localClippingEnabled = true
    
    v3d.SceneUtils.getMaterialByName(v3d.apps[0], 'CHAINS_SIDE').clippingPlanes = [localPlane]
    v3d.SceneUtils.getMaterialByName(v3d.apps[0], 'CHAINS_FRONT').clippingPlanes = [localPlane]

    The error:

    v3d.js:1 v3d.WebGLProgram: shader error:  0 35715 false gl.getProgramInfoLog No compiled fragment shader when at least one graphics shader is attached.
      v3d.WebGLShader: gl.getShaderInfoLog() vertex
    ERROR: 0:348: 'vViewPosition' : redefinition
     1: #version 300 es
    2: 
    3: #define attribute in
    4: #define varying out
    5: #define texture2D texture
    6: precision highp float;
    7: precision highp int;
    8: #define HIGH_PRECISION
    9: #define SHADER_NAME MeshMaskMaterial
    10: #define COMPAT_USE_SPEC_ENV_BLENDER_APPROX
    11: #define VERTEX_TEXTURES
    12: #define GAMMA_FACTOR 2
    13: #define MAX_BONES 0
    14: #define BONE_TEXTURE
    15: #define USE_MORPHTARGETS
    16: #define NUM_MORPH_TARGETS 1
    17: #define DOUBLE_SIDED
    18: uniform mat4 modelMatrix;
    19: uniform mat4 modelViewMatrix;
    20: uniform mat4 projectionMatrix;
    21: uniform mat4 viewMatrix;
    22: uniform mat3 normalMatrix;
    23: uniform vec3 cameraPosition;
    24: uniform bool isOrthographic;
    25: #ifdef USE_INSTANCING
    26:  attribute mat4 instanceMatrix;
    27: #endif
    28: attribute vec3 position;
    29: attribute vec3 normal;
    30: attribute vec2 uv;
    31: #ifdef USE_TANGENT
    32:     attribute vec4 tangent;
    33: #endif
    34: #ifdef USE_COLOR
    35:     attribute vec3 color;
    36: #endif
    37: #ifdef USE_MORPHTARGETS
    38:     attribute vec3 morphTarget0;
    39:     attribute vec3 morphTarget1;
    40:     attribute vec3 morphTarget2;
    41:     attribute vec3 morphTarget3;
    42:     attribute vec3 morphTarget4;
    43:     attribute vec3 morphTarget5;
    44:     #ifdef USE_MORPHNORMALS
    45:         attribute vec3 morphNormal0;
    46:         attribute vec3 morphNormal1;
    47:         attribute vec3 morphNormal2;
    48:         attribute vec3 morphNormal3;
    49:         attribute vec3 morphNormal4;
    50:         attribute vec3 morphNormal5;
    51:     #else
    52:         attribute vec3 morphTarget6;
    53:         attribute vec3 morphTarget7;
    54:         attribute vec3 morphTarget8;
    55:         attribute vec3 morphTarget9;
    56:         attribute vec3 morphTarget10;
    57:         attribute vec3 morphTarget11;
    58:     #endif
    59: #endif
    60: #ifdef USE_SKINNING
    61:     attribute vec4 skinIndex;
    62:     attribute vec4 skinWeight;
    63: #endif
    64: 
    65: #define MASK
    66: #define PI 3.14159265359
    67: #define PI2 6.28318530718
    68: #define PI_HALF 1.5707963267949
    69: #define RECIPROCAL_PI 0.31830988618
    70: #define RECIPROCAL_PI2 0.15915494
    71: #define LOG2 1.442695
    72: #define EPSILON 1e-6
    73: #ifndef saturate
    74: #define saturate(a) clamp(a, 0.0, 1.0)
    75: #endif
    76: #define whiteComplement(a) (1.0 - saturate(a))
    77: #define RECIPROCAL_3 0.333333333333
    78: float pow2(const in float x) { return x*x; }
    79: float pow3(const in float x) { return x*x*x; }
    80: float pow4(const in float x) { float x2 = x*x; return x2*x2; }
    81: float average(const in vec3 color) { return dot(color, vec3(0.3333)); }
    82: highp float rand(const in vec2 uv) {
    83: const highp float a = 12.9898, b = 78.233, c = 43758.5453;
    84: highp float dt = dot(uv.xy, vec2(a,b)), sn = mod(dt, PI);
    85: return fract(sin(sn) * c);
    86: }
    87: #ifdef HIGH_PRECISION
    88: float precisionSafeLength(vec3 v) { return length(v); }
    89: #else
    90: float max3(vec3 v) { return max(max(v.x, v.y), v.z); }
    91: float precisionSafeLength(vec3 v) {
    92: float maxComponent = max3(abs(v));
    93: return length(v / maxComponent) * maxComponent;
    94: }
    95: #endif
    96: struct IncidentLight {
    97: vec3 color;
    98: vec3 direction;
    99: bool visible;
    100: };
    101: struct ReflectedLight {
    102: vec3 directDiffuse;
    103: vec3 directSpecular;
    104: vec3 indirectDiffuse;
    105: vec3 indirectSpecular;
    106: };
    107: struct GeometricContext {
    108: vec3 position;
    109: vec3 normal;
    110: vec3 viewDir;
    111: #ifdef CLEARCOAT
    112: vec3 clearcoatNormal;
    113: #endif
    114: };
    115: vec3 transformDirection(in vec3 dir, in mat4 matrix) {
    116: return normalize((matrix * vec4(dir, 0.0)).xyz);
    117: }
    118: vec3 inverseTransformDirection(in vec3 dir, in mat4 matrix) {
    119: return normalize((vec4(dir, 0.0) * matrix).xyz);
    120: }
    121: vec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal) {
    122: float distance = dot(planeNormal, point - pointOnPlane);
    123: return - distance * planeNormal + point;
    124: }
    125: float sideOfPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal) {
    126: return sign(dot(point - pointOnPlane, planeNormal));
    127: }
    128: vec3 linePlaneIntersect(in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal) {
    129: return lineDirection * (dot(planeNormal, pointOnPlane - pointOnLine) / dot(planeNormal, lineDirection)) + pointOnLine;
    130: }
    131: mat3 transposeMat3(const in mat3 m) {
    132: mat3 tmp;
    133: tmp[0] = vec3(m[0].x, m[1].x, m[2].x);
    134: tmp[1] = vec3(m[0].y, m[1].y, m[2].y);
    135: tmp[2] = vec3(m[0].z, m[1].z, m[2].z);
    136: return tmp;
    137: }
    138: float linearToRelativeLuminance(const in vec3 color) {
    139: vec3 weights = vec3(0.2126, 0.7152, 0.0722);
    140: return dot(weights, color.rgb);
    141: }
    142: bool isPerspectiveMatrix(mat4 m) {
    143: return m[2][3] == - 1.0;
    144: }
    145: highp vec3 rand3(const in vec3 v) {
    146: const highp float c = 43758.5453;
    147: const highp mat3 coeffs = mat3(
    148: 165.15, 253.34, 323.22,
    149: 241.49, 329.07, 147.79,
    150: 376.31, 14 v3d.WebGLShader: gl.getShaderInfoLog() fragment
    ERROR: 0:589: 'vViewPosition' : redefinition
     1: #version 300 es
    2: 
    3: #define varying in
    4: out highp vec4 pc_fragColor;
    5: #define gl_FragColor pc_fragColor
    6: #define gl_FragDepthEXT gl_FragDepth
    7: #define texture2D texture
    8: #define textureCube texture
    9: #define texture2DProj textureProj
    10: #define texture2DLodEXT textureLod
    11: #define texture2DProjLodEXT textureProjLod
    12: #define textureCubeLodEXT textureLod
    13: #define texture2DGradEXT textureGrad
    14: #define texture2DProjGradEXT textureProjGrad
    15: #define textureCubeGradEXT textureGrad
    16: precision highp float;
    17: precision highp int;
    18: #define HIGH_PRECISION
    19: #define SHADER_NAME MeshMaskMaterial
    20: #define COMPAT_USE_SPEC_ENV_BLENDER_APPROX
    21: #define GAMMA_FACTOR 2
    22: #define DOUBLE_SIDED
    23: #define PHYSICALLY_CORRECT_LIGHTS
    24: #define UNITS_SCALE_FACTOR 1.0
    25: uniform mat4 viewMatrix;
    26: uniform vec3 cameraPosition;
    27: uniform bool isOrthographic;
    28: #define TONE_MAPPING
    29: #ifndef saturate
    30: #define saturate(a) clamp(a, 0.0, 1.0)
    31: #endif
    32: #ifndef PI
    33: #define PI 3.14159265359
    34: #endif
    35: uniform float toneMappingExposure;
    36: uniform float toneMappingMidTones;
    37: uniform float toneMappingPhysicalScale;
    38: uniform float toneMappingWhitePoint;
    39: uniform float toneMappingBrightness;
    40: uniform float toneMappingContrast;
    41: uniform bool toneMappingChromaticAdaptation;
    42: uniform vec3 toneMappingWhiteColor;
    43: uniform bool toneMappingColorDifferentiation;
    44: uniform bool toneMappingExteriorDaylight;
    45: uniform vec3 toneMappingWhiteBalance;
    46: uniform float toneMappingHighlights;
    47: uniform float toneMappingShadows;
    48: uniform float toneMappingSaturation;
    49: uniform float toneMappingAperture;
    50: uniform float toneMappingShutter;
    51: uniform float toneMappingISO;
    52: uniform float toneMappingVignetting;
    53: uniform vec2 toneMappingResolution;
    54: const float FILMIC_BLENDER_LOG_MIN = -12.473931188;
    55: const float FILMIC_BLENDER_LOG_MAX = 12.526068812;
    56: const float FILMIC_BLENDER_EXPOSURE_LATITUDE_RATIO = 0.66;
    57: vec3 LinearToneMapping(vec3 color) {
    58: return toneMappingExposure * color;
    59: }
    60: vec3 ReinhardToneMapping(vec3 color) {
    61: color *= toneMappingExposure;
    62: return saturate(color / (vec3(1.0) + color));
    63: }
    64: #define Uncharted2Helper(x) max(((x * (0.15 * x + 0.10 * 0.50) + 0.20 * 0.02) / (x * (0.15 * x + 0.50) + 0.20 * 0.30)) - 0.02 / 0.30, vec3(0.0))
    65: vec3 Uncharted2ToneMapping(vec3 color) {
    66: color *= toneMappingExposure;
    67: return saturate(Uncharted2Helper(color) / Uncharted2Helper(vec3(toneMappingWhitePoint)));
    68: }
    69: vec3 OptimizedCineonToneMapping(vec3 color) {
    70: color *= toneMappingExposure;
    71: color = max(vec3(0.0), color - 0.004);
    72: return pow((color * (6.2 * color + 0.5)) / (color * (6.2 * color + 1.7) + 0.06), vec3(2.2));
    73: }
    74: vec3 ACESFilmicToneMapping(vec3 color) {
    75: color *= toneMappingExposure;
    76: return saturate((color * (2.51 * color + 0.03)) / (color * (2.43 * color + 0.59) + 0.14));
    77: }
    78: #define ORDERS_OF_MAG 5.0
    79: float toneCalcBrightness(in vec3 color)
    80: {
    81: return (abs(color.r) * 0.263 + abs(color.g) * 0.655 + abs(color.b) * 0.082);
    82: }
    83: float toneApproximateScotopicLuminance(vec3 color)
    84: {
    85: return (0.062 * color.r + 0.608 * color.g + 0.330 * color.b);
    86: }
    87: vec3 LogarithmicMaxToneMapping(vec3 color) {
    88: float inputScaleFactor = toneMappingPhysicalScale / PI;
    89: float brightness = (toneMappingBrightness < 0.0) ? 0.0 : (toneMappingBrightness * 0.7);
    90: float powerBot = toneMappingExteriorDaylight ? 4.0 : 2.0;
    91: float res = 100.0 / ORDERS_OF_MAG;
    92: float mag = floor((50.0 / res));
    93: float power = ((brightness / 20.0 - ORDERS_OF_MAG) - powerBot) + mag;
    94: float stepsize = 9.0 / res;
    95: float step = 50.0 - (mag * res);
    96: float param_c = (0.02 * toneMappingContrast) * 2.0;
    97: float param_b = pow(10.0, power) * (1.0 + (stepsize * step));
    98: float param_a = param_b * (1.0 + param_c);
    99: param_c /= pow(2.0, toneMappingMidTones - 1.0);
    100: param_b *= PI;
    101: vec3 whiteConstancyFactor = toneMappingWhiteColor;
    102: if (toneMappingChromaticAdaptation) {
    103: float luminance = toneCalcBrightness(whiteConstancyFactor);
    104: whiteConstancyFactor.r = (whiteConstancyFactor.r > 0.001) ? luminance / whiteConstancyFactor.r : luminance / 0.001;
    105: whiteConstancyFactor.g = (whiteConstancyFactor.g > 0.001) ? luminance / whiteConstancyFactor.g : luminance / 0.001;
    106: whiteConstancyFactor.b = (whiteConstancyFactor.b > 0.001) ? luminance / whiteConstancyFactor.b : luminance / 0.001;
    107: }
    108: vec3 outColor = inputScaleFactor * color;
    109: if (toneMappingChromaticAdaptation) {
    110: outColor *= whiteConstancyFactor.rgb;
    111: }
    112: float luminance = toneCalcBrightness(outColor);
    113: if (toneMappingColorDifferentiation && (luminance < 5.62)) {
    114: float sLuminance = toneApproximateScotopicLuminance(outColor);
    115: if (luminance <= 5.62e-3) {
    116: outColor = vec3(sLuminance);
    117: } else {
    118: float w = (luminance - 5.62e-3) / 5.61438;
    119: outColor = outColor * w + sLuminance * (1.0 - w);
    120: }
    121: }
    122: outColor = outColor * (param_a / (param_b * outColor + param_c));
    123: return outColor;
    124: }
    125: float maxExposurePhotographic(in vec4 color1, in vec4 color2)
    126: {
    127: return ((color1.r * color2.r) + (color1.g * color2.g)) + (color1.b * color2.b);
    128: }
    129: vec3 PhysicalMaxToneMapping(vec3 color) {
    130: float vignettingInfluence = 1.0;
    131: if (toneMappingVignetting > 0.0) {
    132: vec3 vignettingCoords = vec3(0.0, 0.0, 0.0);
    133: float aspect = toneMappingResolution.x / toneMappingResolution.y;
    134: vignettingCoords.x = gl_FragCoord.x / toneMappingResolution.x - 0.5;
    135: vignettingCoords.y = (gl_FragCoord.y / toneMappingResolution.y - 0.5) / aspect;
    136: vignettingCoords.z = 1.0;
    137: vignettingCoords = normalize(vignettingCoords);
    138: vignettingInfluence = pow(vignettingCoords.z, toneMappingVignetting);
    139: }
    140: float inputScaleFactor = toneMappingPhysicalScale / PI;
    141: float filmISO = toneMappingISO;
    142: float camShutter = 1.0 / toneMappingShutter;
    143: float fNumber = toneMappingAperture;
    144: float cm2 = 1.0;
    145: float burnHighlights = toneMappingHighlights;
    146: float crushBlacks = toneMappingShadows;
    147: float saturation = toneMappingSaturation;
    148: vec3 whitePointInfluence = toneMappingWhiteBalance;
    149: if (whitePointInfluence.r > 0.0) {
    150: whitePointInfluence.r = 1.0 / whitePointInfluence.r;
    151: } else {
    152: whitePointInfluence.r = 1.0;
    153: }
    154: if (whitePointInfluence.g > 0.0) {
    155: whitePointInfluence.g = 1.0 / whitePointInfluence.g;
    156: } else {
    157: whitePointInfluence.g = 1.0;
    158: }
    159: if (whitePointInfluence.b > 0.0) {
    160: whitePointInfluence.b = 1.0 / whitePointInfluence.b;
    161: } else {
    162: whitePointInfluence.b = 1.0;
    163: }
    164: vec4 lumFactor = vec4(0.212671, 0.715160, 0.072169, 0.0);
    165: float whiteLumFactor = maxExposurePhotographic(lumFactor, vec4(whitePointInfluence, 0.0));
    166: whitePointInfluence.r /= whiteLumFactor;
    167: whitePointInfluence.g /= whiteLumFactor;
    168: whitePointInfluence.b /= whiteLumFactor;
    169: float isoInfluence = 0.0;
    170: float camShutterInv = 1.0 / camShutter;
    171: if (filmISO > 0.0) {
    172: isoInfluence = ((cm2 * 0.169811) * (filmISO * camShutterInv)) / ((15.4 * fNumber) * fNumber);
    173: } else {
    174: isoInfluence = cm2;
    175: }
    176: vec3 outColor = inputScaleFactor * color;
    177: outColor.r = outColor.r * whitePointInfluence.r * isoInfluence * vignettingInfluence;
    178: outColor.g = outColor.g * whitePointInfluence.g * isoInfluence * vignettingInfluence;
    179: outColor.b = outColor.b * whitePointInfluence.b * isoInfluence * vignettingInfluence;
    180: outColor.r = (outColor.r * (1.0 + (outColor.r * burnHighlights))) / (1.0 + outColor.r);
    181: outColor.g = (outColor.g * (1.0 + (outColor.g * burnHighlights))) / (1.0 + outColor.g);
    182: outColor.b = (outColor.b * (1.0 + (outColor.b * burnHighlights))) / (1.0 + outColor.b);
    183: float lumFactor2 = maxExposurePhotographic(lumFactor, vec4(outColor, 0.0));
    184: float tmpFloat = 1.0 - saturation;
    185: outColor.r = outColor.r * saturation + lumFactor2 * tmpFloat;
    186: outColor.g = outColor.g * saturation + lumFactor2 * tmpFloat;
    187: outColor.b = outColor.b * saturation + lumFactor2 * tmpFloat;
    188: outColor = max(vec3(0.0), outColor);
    189: float crushBlacksFac = crushBlacks * 2.0 + 1.0;
    190: float crushBlacksFac2 = pow(maxExposurePhotographic(lumFactor, vec4(outColor, 0.0)), 0.5);
    191: tmpFloat = (1.0 - crushBlacksFac2);
    192: if (crushBlacksFac2 < 1.0) {
    193: outColor.r = outColor.r * crushBlacksFac2 + pow(outColor.r, crushBlacksFac) * tmpFloat;
    194: outColor.g = outColor.g * crushBlacksFac2 + pow(outColor.g, crushBlacksFac) * tmpFloat;
    195: outColor.b = outColor.b * crushBlacksFac2 + pow(outColor.b, crushBlacksFac) * tmpFloat;
    196: }
    197: return outColor;
    198: }
    199: float filmicBlenderDesaturationMinIntensity(vec3 color) {
    200: float maxChannel = max(color.r, max(color.g, color.b));
    201: float x = max(maxChannel, 0.6251);
    202: return (1.2192868 * x - 0.63221059)
    203: * ((x - 0.65069831) / (abs(x - 0.65069831) + 0.00952982) + 0.73015231);
    204: }
    205: vec3 filmicBlenderDesaturationTransform(vec3 color) {
    206: const float CURVE_SMOOTHNESS = 0.03;
    207: float minIntensity = filmicBlenderDesaturationMinIntensity(color);
    208: vec4 x = vec4(color, 1.0) - minIntensity;
    209: x = pow(x, vec4(2.0)) / (abs(x) + CURVE_SMOOTHNESS);
    210: return (x.rgb - x.a + color + 1.0) / 2.0;
    211: }
    212: vec3 filmicBlenderDynamicRangeTransform(vec3 color) {
    213: return pow(
    214: (0.28882259 * color - 0.15880336)
    215: / (pow(color - 0.6229693, vec3(2.0)) + 0.16965022)
    216: + 0.20453365 * color + 0.37847142,
    217: vec3(3.0)
    218: );
    219: }
    220: vec3 FilmicBlenderToneMapping(vec3 color) {
    221: color *= toneMappingExposure;
    222: color = max(color, 0.000175);
    223: color = clamp((log2(color) - FILMIC_BLENDER_LOG_MIN)
    224: / (FILMIC_BLENDER_LOG_MAX - FILMIC_BLENDER_LOG_MIN), 0.0, 1.0);
    225: color = filmicBlenderDesaturationTransform(color);
    226: color = clamp(color / FILMIC_BLENDER_EXPOSURE_LATITUDE_RATIO, 0.0, 1.0);
    227: color = filmicBlenderDynamicRangeTransform(color);
    228: return color;
    229: }
    230: vec3 toneMapping(vec3 color) { return LinearToneMapping(color); }
    231: 
    232: vec4 LinearToLinear(in vec4 value) {
    233: return value;
    234: }
    235: vec4 GammaToLinear(in vec4 value, in float gammaFactor) {
    236: value = max(value, vec4(0.0));
    237: return vec4(pow(value.rgb, vec3(gammaFactor)), value.a);
    238: }
    239: vec4 LinearToGamma(in vec4 value, in float gammaFactor) {
    240: value = max(value, vec4(0.0));
    241: return vec4(pow(value.rgb, vec3(1.0 / gammaFactor)), value.a);
    242: }
    243: vec4 sRGBToLinear(in vec4 value) {
    244: value = max(value, vec4(0.0));
    245: return vec4(mix(pow(value.rgb * 0.9478672986 + vec3(0.0521327014), vec3(2.4)), value.rgb * 0.0773993808, vec3(lessThanEqual(value.rgb, vec3(0.04045)))), value.a);
    246: }
    247: vec4 LinearTosRGB(in vec4 value) {
    248: value = max(value, vec4(0.0));
    249: return vec4(mix(pow(value.rgb, vec3(0.41666)) * 1.055 - vec3(0.055), value.rgb * 12.92, vec3(lessThanEqual(value.rgb, vec3(0.0031308)))), value.a);
    250: }
    251: vec4 RGBEToLinear(in vec4 value) {
    252: return vec4(value.rgb * exp2(value.a * 255.0 - 128.0), 1.0);
    253: }
    254: vec4 LinearToRGBE(in vec4 value) {
    255: float maxComponent = max(max(value.r, value.g), value.b);
    256: float fExp = clamp(ceil(log2(maxComponent)), -128.0, 127.0);
    257: return vec4(value.rgb / exp2(fExp), (fExp + 128.0) / 255.0);
    258: }
    259: vec4 RGBMToLinear(in vec4 value, in float maxRange) {
    260: return vec4(value.rgb * value.a * maxRange, 1.0);
    261: }
    262: vec4 LinearToRGBM(in vec4 value, in float maxRange) {
    263: float maxRGB = max(value.r, max(value.g, value.b));
    264: float M = clamp(maxRGB / maxRange, 0.0, 1.0);
    265: M = ceil(M * 255.0) / 255.0;
    266: return vec4(value.rgb / (M * maxRange), M);
    267: }
    268: vec4 RGBDToLinear(in vec4 value, in float maxRange) {
    269: return vec4(value.rgb * ((maxRange / 255.0) / value.a), 1.0);
    270: }
    271: vec4 LinearToRGBD(in vec4 value, in float maxRange) {
    272: float maxRGB = max(value.r, max(value.g, value.b));
    273: float D = max(maxRange / maxRGB, 1.0);
    274: D = clamp(floor(D) / 255.0, 0.0, 1.0);
    275: return vec4(value.rgb * (D * (255.0 / maxRange)), D);
    276: }
    277: const mat3 cLogLuvM = mat3(0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969);
    278: vec4 LinearToLogLuv(in vec4 value)  {
    279: vec3 Xp_Y_XYZp = cLogLuvM * value.rgb;
    280: Xp_Y_XYZp = max(Xp_Y_XYZp, vec3(1e-6, 1e-6, 1e-6));
    281: vec4 vResult;
    282: vResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;
    283: float Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;
    284: vResult.w = fract(Le);
    285: vResult.z = (Le - (floor(vResult.w * 255.0)) / 255.0) / 255.0;
    286: return vResult;
    287: }
    288: const mat3 cLogLuvInverseM = mat3(6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268);
    289: vec4 LogLuvToLinear(in vec4 value) {
    290: float Le = value.z * 255.0 + value.w;
    291: vec3 Xp_Y_XYZp;
    292: Xp_Y_XYZp.y = exp2((Le - 127.0) / 2.0);
    293: Xp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;
    294: Xp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;
    295: vec3 vRGB = cLogLuvInverseM * Xp_Y_XYZp.rgb;
    296: return vec4(max(vRGB, 0.0), 1.0);
    297: }
    298: vec4 mapTexelToLinear(vec4 value) { return LinearToLinear(value); }
    299: vec4 matcapTexelToLinear(vec4 value) { return LinearToLinear(value); }
    300: vec4 envMapTexelToLinear(vec4 value) { return LinearToLinear(value); }
    301: vec4 emissiveMapTexelToLinear(vec4 value) { return LinearToLinear(value); }
    302: vec4 lightMapTexelToLinear(vec4 value) { return LinearToLinear(value); }
    303: vec4 linearToOutputTexel(vec4 value) { return LinearToLinear(value); }
    304: 
    305: #define MASK
    306: #define PI 3.14159265359
    307: #define PI2 6.28318530718
    308: #define PI_HALF 1.5707963267949
    309: #define RECIPROCAL_PI 0.31830988618
    310: #define RECIPROCAL_PI2 0.15915494
    311: #define LOG2 1.442695
    312: #define EPSILON 1e-6
    313: #ifndef saturate
    314: #define saturate(a) clamp(a, 0.0, 1.0)
    315: #endif
    316: #define whiteComplement(a) (1.0 - saturate(a))
    317: #define RECIPROCAL_3 0.333333333333
    318: float pow2(const in float x) { return x*x; }
    319: float pow3(const in float x) { return x*x*x; }
    320: float pow4(const in float x) { float x2 = x*x; return x2*x2; }
    321: float average(const in vec3 color) { return dot(color, vec3(0.3333)); }
    322: highp float rand(const in vec2 uv) {
    323: const highp float a = 12.9898, b = 78.233, c = 43758.5453;
    324: highp float dt = dot(uv.xy, vec2(a,b)), sn = mod(dt, PI);
    325: return fract(sin(sn) * c);
    326: }
    327: #ifdef HIGH_PRECISION
    328: float precisionSafeLength(vec3 v) { return length(v); }
    329: #else
    330: float max3(vec3 v) { return max(max(v.x, v.y), v.z); }
    331: float precisionSafeLength(vec3 v) {
    332: float maxComponent = max3(abs(v));
    333: return length(v / maxComponent) * maxComponent;
    334: }
    335: #endif
    336: struct IncidentLight {
    337: vec3 color;
    338: vec3 direction;
    339: bool visible;
    340: };
    341: struct ReflectedLight {
    342: vec3 directDiffuse;
    343: vec3 directSpecular;
    344: vec3 indirectDiffuse;
    345: vec3 indirectSpecular;
    346: };
    347: struct GeometricContext {
    348: vec3 position;
    349: vec3 normal;
    350: vec3 viewDir;
    351: #ifdef CLEARCOAT
    352: vec3 clearcoatNormal;
    353: #endif
    354: };
    355: vec3 transformDirection(in vec3 dir, in mat4 matrix) {
    356: return normalize((matrix * vec4(dir, 0.0)).xyz);
    357: }
    358: vec3 inverseTransformDirection(in vec3 dir, in mat4 matrix) {
    359: return normalize((vec4(dir, 0.0) * matrix).xyz);
    360: }
    361: vec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal) {
    362: float distance = dot(planeNormal, point - pointOnPlane);
    363: return - distance * planeNormal + point;
    364: }
    365: float sideOfPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal) {
    366: return sign(dot(point - pointOnPlane, planeNormal));
    367: }
    368: vec3 linePlaneIntersect(in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal) {
    369: return lineDirection * (dot(planeNormal, pointOnPlane - pointOnLine) / dot(planeNormal, lineDirection)) + pointOnLine;
    370: }
    371: mat3 transposeMat3(const in mat3 m) {
    372: mat3 tmp;
    373: tmp[0] = vec3(m[0].x, m[1].x, m[2].x);
    374: tmp[1] = vec3(m[0].y, m[1].y, m[2].y);
    375: tmp[2] = vec3(m[0].z, m[1].z, m[2].z);
    376: return tmp;
    377: }
    378: float linearToRelativeLuminance(const in vec3 color) {
    379: vec3 weights = vec3(0.2126, 0.7152, 0.0722);
    380: return dot(weights, color.rgb);
    381: }
    382: bool isPerspectiveMatrix(mat4 m) {
    383: return m[2][3] == - 1.0;
    384: }
    385: highp vec3 rand3(const in vec3 v) {
    386: const highp float c = 43758.5453;
    387: const highp mat3 coeffs = mat3(
    388: 165.15, 253.34, 323.22,
    389: 241.49, 329.07, 147.79,
    390: 376.31, 143.45, 281.63
    391: );
    392: highp vec3 sn = mod(coeffs * v, PI);
    393: return fract(sin(sn) * c);
    394: }
    395: float powCompat(const in float val, const in float power) {
    396: if (power == 0.0)
    397: return 1.0;
    398: else if (val < 0.0) {
    399: if (mod(-power, 2.0) == 0.0)
    400: return pow(abs(val), power);
    401: else
    402: return -pow(abs(val), power);
    403: } else if (val == 0.0)
    404: return 0.0;
    405: return pow(abs(val), power);
    406: }
    407: float maxFromRGB(vec3 rgb) {
    408: return max(max(rgb.r, rgb.g), rgb.b);
    409: }
    410: bool isOrtho(const in mat4 m) {
    411: if (m[3][3] != 0.0)
    412: return true;
    413: else
    414: return false;
    415: }
    416: vec3 swizzleUpZ(const vec3 vec) {
    417: return vec3(vec[0], -vec[2], vec[1]);
    418: }
    419: vec3 swizzleUpY(const vec3 vec) {
    420: return vec3(vec[0], vec[2], -vec[1]);
    421: }
    422: vec3 xyz_to_sRGB(vec3 xyz) {
    423: mat3 convMat = mat3(
    424: 3.2406, -0.9689, 0.0557,
    425: -1.5372, 1.8758, -0.2040,
    426: -0.4986, 0.0415, 1.0570
    427: );
    428: return convMat * xyz;
    429: }
    430: vec3 xyY_to_XYZ(float x, float y, float Y) {
    431: float X = 0.0;
    432: float Z = 0.0;
    433: if (y != 0.0) {
    434: X = (Y / y) * x;
    435: Z = (Y / y) * (1.0 - x - y);
    436: }
    437: return vec3(X, Y, Z);
    438: }
    439: vec3 octUVToCubeVec(vec2 octUV, vec2 texelSize) {
    440: octUV = (1.0 + 2.0 * texelSize) * octUV - texelSize;
    441: octUV = octUV * 2.0 - 1.0;
    442: float x = octUV.x;
    443: float z = -octUV.y;
    444: float absX = abs(x);
    445: float absZ = abs(z);
    446: vec3 cubeVec = vec3(x, 1.0 - absX - absZ, z);
    447: if (absX + absZ > 1.0) {
    448: cubeVec.xz = -(vec2(absZ, absX) - 1.0) * sign(vec2(x, z));
    449: }
    450: return cubeVec;
    451: }
    452: vec2 cubeVecToOctUV(vec3 cubeVec, vec2 texelSize) {
    453: cubeVec /= dot(vec3(1.0), abs(cubeVec));
    454: vec2 octUV = vec2(cubeVec.x, -cubeVec.z);
    455: if (cubeVec.y < 0.0) {
    456: octUV = sign(octUV) * (1.0 - abs(octUV.ts));
    457: }
    458: octUV = (octUV + 1.0) / 2.0;
    459: octUV = (1.0 - 2.0 * texelSize) * octUV + texelSize;
    460: return octUV;
    461: }
    462: #if __VERSION__ == 100
    463: float cosh(float x) {
    464: return (exp(x) + exp(-x)) / 2.0;
    465: }
    466: vec2 cosh(vec2 x) {
    467: return (exp(x) + exp(-x)) / 2.0;
    468: }
    469: vec3 cosh(vec3 x) {
    470: return (exp(x) + exp(-x)) / 2.0;
    471: }
    472: vec4 cosh(vec4 x) {
    473: return (exp(x) + exp(-x)) / 2.0;
    474: }
    475: float sinh(float x) {
    476: return (exp(x) - exp(-x)) / 2.0;
    477: }
    478: vec2 sinh(vec2 x) {
    479: return (exp(x) - exp(-x)) / 2.0;
    480: }
    481: vec3 sinh(vec3 x) {
    482: return (exp(x) - exp(-x)) / 2.0;
    483: }
    484: vec4 sinh(vec4 x) {
    485: return (exp(x) - exp(-x)) / 2.0;
    486: }
    487: float tanh(float x) {
    488: float exp2x = exp(2.0 * x);
    489: return (exp2x - 1.0) / (exp2x + 1.0);
    490: }
    491: vec2 tanh(vec2 x) {
    492: vec2 exp2x = exp(2.0 * x);
    493: return (exp2x - 1.0) / (exp2x + 1.0);
    494: }
    495: vec3 tanh(vec3 x) {
    496: vec3 exp2x = exp(2.0 * x);
    497: return (exp2x - 1.0) / (exp2x + 1.0);
    498: }
    499: vec4 tanh(vec4 x) {
    500: vec4 exp2x = exp(2.0 * x);
    501: return (exp2x - 1.0) / (exp2x + 1.0);
    502: }
    503: float trunc(float x) {
    504: return floor(abs(x)) * sign(x);
    505: }
    506: vec2 trunc(vec2 x) {
    507: return floor(abs(x)) * sign(x);
    508: }
    509: vec3 trunc(vec3 x) {
    510: return floor(abs(x)) * sign(x);
    511: }
    512: vec4 trunc(vec4 x) {
    513: return floor(abs(x)) * sign(x);
    514: }
    515: #endif
    516: float getSmoothFactor(float a, float b, float smoothness) {
    517: return max(smoothness - abs(a - b), 0.0) / smoothness;
    518: }
    519: float smoothMin(float a, float b, float smoothness) {
    520: float smoothFac = getSmoothFactor(a, b, smoothness);
    521: return min(a, b) - smoothFac * smoothFac * smoothFac * smoothness * (1.0 / 6.0);
    522: }
    523: float smoothMax(float a, float b, float smoothness) {
    524: float smoothFac = getSmoothFactor(a, b, smoothness);
    525: return max(a, b) + smoothFac * smoothFac * smoothFac * smoothness * (1.0 / 6.0);
    526: }
    527: vec3 packNormalToRGB(const in vec3 normal) {
    528: return normalize(normal) * 0.5 + 0.5;
    529: }
    530: vec3 unpackRGBToNormal(const in vec3 rgb) {
    531: return 2.0 * rgb.xyz - 1.0;
    532: }
    533: const float PackUpscale = 256. / 255.;
    534: const float UnpackDownscale = 255. / 256.;
    535: const vec3 PackFactors = vec3(256. * 256. * 256., 256. * 256.,  256.);
    536: const vec4 UnpackFactors = UnpackDownscale / vec4(PackFactors, 1.);
    537: const float ShiftRight8 = 1. / 256.;
    538: vec4 packDepthToRGBA(const in float v) {
    539: vec4 r = vec4(fract(v * PackFactors), v);
    540: r.yzw -= r.xyz * ShiftRight8;
    541: return r * PackUpscale;
    542: }
    543: float unpackRGBAToDepth(const in vec4 v) {
    544: return dot(v, UnpackFactors);
    545: }
    546: vec4 pack2HalfToRGBA(vec2 v) {
    547: vec4 r = vec4(v.x, fract(v.x * 255.0), v.y, fract(v.y * 255.0));
    548: return vec4(r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w);
    549: }
    550: vec2 unpackRGBATo2Half(vec4 v) {
    551: return vec2(v.x + (v.y / 255.0), v.z + (v.w / 255.0));
    552: }
    553: float viewZToOrthographicDepth(const in float viewZ, const in float near, const in float far) {
    554: return (viewZ + near) / (near - far);
    555: }
    556: float orthographicDepthToViewZ(const in float linearClipZ, const in float near, const in float far) {
    557: return linearClipZ * (near - far) - near;
    558: }
    559: float viewZToPerspectiveDepth(const in float viewZ, const in float near, const in float far) {
    560: return ((near + viewZ) * far) / ((far - near) * viewZ);
    561: }
    562: float perspectiveDepthToViewZ(const in float invClipZ, const in float near, const in float far) {
    563: return (near * far) / ((far - near) * invClipZ - far);
    564: }
    565: #if (defined(USE_UV) && !defined(UVS_VERTEX_ONLY))
    566: varying vec2 vUv;
    567: #endif
    568: #ifdef USE_MAP
    569: uniform sampler2D map;
    570: #endif
    571: #ifdef USE_ALPHAMAP
    572: uniform sampler2D alphaMap;
    573: #endif
    574: #if defined(USE_LOGDEPTHBUF) && defined(USE_LOGDEPTHBUF_EXT)
    575: uniform float logDepthBufFC;
    576: varying float vFragDepth;
    577: varying float vIsPerspective;
    578: #endif
    579: #if 1 > 0
    580: #if !defined(STANDARD) && !defined(PHONG) && !defined(MATCAP)&& !defined(NODE) && !defined(LAMBERT) && !defined(DEPTH)
    581: varying vec3 vViewPosition;
    582: #endif
    583: uniform vec4 clippingPlanes[1];
    584: #endif
    585: uniform mat4 projectionMatrix;
    586: uniform float opacity;
    587: uniform sampler2D depthTexture;
    588: uniform vec2 cameraNearFar;
    589: varying vec3 vViewPosition;
    590: varying vec4 projTexCoord;
    591: void main() {
    592: #if 1 > 0
    593: vec4 plane;
    594: {
    595: plane = clippingPlanes[0];
    596: if (dot(vViewPosition, plane.xyz) > plane.w) discard;
    597: }
    598: #if 1 < 1
    599: bool clipped = true;
    600: 
    601: if (clipped) discard;
    602: #endif
    603: #endif
    604: vec4 diffuseColor = vec4(1.0);
    605: diffuseColor.a = opacity;
    606: #ifdef USE_MAP
    607: vec4 texelColor = texture2D(map, vUv);
    608: texelColor = mapTexelToLinear(texelColor);
    609: diffuseColor *= texelColor;
    610: #endif
    611: #ifdef USE_ALPHAMAP
    612: diffuseColor.a *= texture2D(alphaMap, vUv).g;
    613: #endif
    614: #ifdef ALPHATEST
    615: if (diffuseColor.a < ALPHATEST)
    616: discard;
    617: else
    618: diffuseColor.a = 1.0;
    619: #endif
    620: #if defined(USE_LOGDEPTHBUF) && defined(USE_LOGDEPTHBUF_EXT)
    621: gl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2(vFragDepth) * logDepthBufFC * 0.5;
    622: #endif
    623: float depth = unpackRGBAToDepth(texture2DProj(depthTexture, projTexCoord));
    624: float viewZ;
    625: if (isOrtho(projectionMatrix))
    626: viewZ = -orthographicDepthToViewZ(depth,
    627: cameraNearFar.x, cameraNearFar.y);
    628: else
    629: viewZ = -perspectiveDepthToViewZ(depth,
    630: cameraNearFar.x, cameraNearFar.y);
    631: float depthTest = (vViewPosition.z > viewZ) ? 1.0 : 0.0;
    632: gl_FragColor = vec4(0.0, depthTest, 1.0, 0.0);
    633: }
    

    Do you have any idea why?

    • This reply was modified 1 year, 4 months ago by origgin.
    #30984

    Hi,
    looks like some shader bug. Can you isolate crashing material and send us the minimal Blend file with it?

    Verge3D’s Tech Chief
    FB | Twitter | VK

    #30996
    origgin
    Participant

    Hi, looks like some shader bug. Can you isolate crashing material and send us the minimal Blend file with it?

    If you need something else, let me know. Thank you ;)

    PS: I am using more than one material because the plane was clipping only one object, so I added another material to the other object, which had to be clipped in order to work. But the problem exists since it was only one material and it clipped only one object.

    • This reply was modified 1 year, 4 months ago by origgin.
    Attachments:
    You must be logged in to view attached files.
    #31016

    Hi origgin,
    Thanks for the test example! We are able to reproduce this error. It’ll be fixed in the next 3.3.1 update, which is planned next monday.

    Co-founder and lead developer at Soft8Soft.

    #31021
    origgin
    Participant

    Hi origgin, Thanks for the test example! We are able to reproduce this error. It’ll be fixed in the next 3.3.1 update, which is planned next monday.

    Hi. Nice, I will test it again after the update and let you know if it worked, thanks for the nice support ;)

    #31027
    GLiFTeK
    Customer

    That’s great foreknowldge about the API having y-up coords! :good:

    #31094
    origgin
    Participant

    Just to give my feedback: everything is working fine after the update. Thanks again ;)

    #31114

    excellent! :good:

    3D Verger, the CEO
    LinkedIn | FB | Twitter | VK | 新浪微博

Viewing 14 posts - 1 through 14 (of 14 total)
  • You must be logged in to reply to this topic.