Personal tools
You are here: Home Forum Install & build Fail to initialize Paravis (Salome 9.3.0, Windows 10)

Fail to initialize Paravis (Salome 9.3.0, Windows 10)

Up to Install & build

Fail to initialize Paravis (Salome 9.3.0, Windows 10)

Posted by Sergio Pluchinsky at August 24. 2019

Hi, from one day to another and without doing anything on my installation, Paravis module refuse to start, with an ACCESS VIOLATION error during load. Geom and Mesh are working normally. Not only that, but also Paraview 5.6 standalone from Code Aster for Windows doesn´t start at all. I trie several reinstallations of both programs, but the same message appear, and even re-installing Windows 10, and in the same laptop (Lenovo Thinkpad T420), again I have the same errors! On a fresh Windows 10 installation I can´t use Paravis/Paraview.

 

This is the errors that appear in the message window of Paravis after closing the error prompt, and the viewport gets black and no result file can be visualized (lools like it load the result file, but not display at all)  

 

ERROR: In E:\SALOME-9.1.0\products\tmp\ParaView-5.6.0p1-7bafc2be_SRC\VTK\Rendering\OpenGL2\vtkShaderProgram.cxx, line 461 vtkShaderProgram (000001A8CE8FE9D0): 1: #version 140 2: #ifdef GL_ES 3: #ifdef GL_FRAGMENT_PRECISION_HIGH 4: precision highp float; 5: precision highp sampler2D; 6: precision highp sampler3D; 7: #else 8: precision mediump float; 9: precision mediump sampler2D; 10: precision mediump sampler3D; 11: #endif 12: #define texelFetchBuffer texelFetch 13: #define texture1D texture 14: #define texture2D texture 15: #define texture3D texture 16: #else // GL_ES 17: #define highp 18: #define mediump 19: #define lowp 20: #if __VERSION__ == 150 21: #define texelFetchBuffer texelFetch 22: #define texture1D texture 23: #define texture2D texture 24: #define texture3D texture 25: #endif 26: #endif // GL_ES 27: #define varying in 28: 29: 30: /*========================================================================= 31: 32: Program: Visualization Toolkit 33: Module: vtkFXAAFilterFS.glsl 34: 35: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen 36: All rights reserved. 37: See Copyright.txt or http://www.kitware.com/Copyright.htm for details. 38: 39: This software is distributed WITHOUT ANY WARRANTY; without even 40: the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 41: PURPOSE. See the above copyright notice for more information. 42: 43: =========================================================================*/ 44: // Fragment shader for vtkOpenGLFXAAFilter. 45: // 46: // Based on the following implementation and description: 47: // 48: // Whitepaper: 49: // http://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf 50: // 51: // Sample implementation: 52: // https://github.com/NVIDIAGameWorks/GraphicsSamples/blob/master/samples/es3-kepler/FXAA/FXAA3_11.h 53: 54: out vec4 fragOutput0; 55: 56: 57: //======================== Debugging Options: ================================== 58: 59: // Output a greyscale image showing the detected amount of subpixel aliasing. 60: //#define FXAA_DEBUG_SUBPIXEL_ALIASING 61: 62: // Output vertical edges in red, and horizontal edges in blue. 63: //#define FXAA_DEBUG_EDGE_DIRECTION 64: 65: // Output (number of steps taken) / (EndpointSearchIterations). Negative steps 66: // in the red channel, positive steps in the blue. 67: //#define FXAA_DEBUG_EDGE_NUM_STEPS 68: 69: // Output degrees of red if the edge is near the negative edge endpoint, or 70: // shades of blue if near the positive edge endpoint. Pixels near an edge but 71: // not eligible for edgeAA (e.g. they are on the unaliased side of an edge) 72: // are shown in yellow. 73: //#define FXAA_DEBUG_EDGE_DISTANCE 74: 75: // Output the length of the edge anti-aliasing offset vector in the red channel. 76: //#define FXAA_DEBUG_EDGE_SAMPLE_OFFSET 77: 78: // Only apply a single form of anti-aliasing: 79: // 1 - Only apply sub-pixel anti-aliasing. 80: // 2 - Only apply edge anti-aliasing. 81: // Other / undefined - Apply both sub-pixel and edge anti-aliasing. 82: //#define FXAA_DEBUG_ONLY_SUBPIX_AA 83: //#define FXAA_DEBUG_ONLY_EDGE_AA 84: 85: // Replacement stub for vtkShaderProgram::Substitute: 86: //VTK::DebugOptions::Def 87: 88: //========================== Tuning Define: ==================================== 89: 90: // Which edge search implementation to use. If defined, use VTK's endpoint 91: // algorithm, otherwise use NVIDIA's. 92: // 93: // NVIDIA is faster, but gives poor results on single pixel lines (e.g. 94: // vtkPolyDataMapper's wireframe/edges). VTK is slower, but gives nicer results 95: // on single pixel lines. 96: //#define FXAA_USE_HIGH_QUALITY_ENDPOINTS; 97: 98: // Replacement stub for vtkShaderProgram::Substitute: 99: #define FXAA_USE_HIGH_QUALITY_ENDPOINTS 100: 101: //========================= Input Parameters: ================================== 102: 103: // Current fragment texture coordinate: 104: in vec2 texCoord; 105: 106: // Aliased color buffer (should be sRGB, ideally) 107: uniform sampler2D Input; 108: 109: // 1.f/Input.width, 1.f/Input.height: 110: uniform vec2 InvTexSize; 111: 112: //======================== Tuning Parameters: ================================== 113: 114: // See the vtkOpenGLFXAAFilter class documentation for details on these. 115: 116: // Minimum change in luminosity (relative to maxLum) to use FXAA: 117: uniform float RelativeContrastThreshold; 118: 119: // Absolute minimum lum change required for FXAA (overrides 120: // RelativeContrastThreshold value, not scaled): 121: uniform float HardContrastThreshold; 122: 123: // Maximum amount of lowpass blending for subpixel anti-aliasing: 124: uniform float SubpixelBlendLimit; 125: 126: // Ignore subpixel anti-aliasing that contributes less than this amount to the 127: // total contrast: 128: uniform float SubpixelContrastThreshold; 129: 130: // Maximum number of steps to take when searching for line edges: 131: uniform int EndpointSearchIterations; 132: 133: //============================ Helper Methods ================================== 134: // Converts rgb to luminosity: 135: const vec3 LUMINOSITY_VEC = vec3(0.299, 0.587, 0.114); 136: float luminosity(vec3 rgb) 137: { 138: return dot(rgb, LUMINOSITY_VEC); 139: } 140: 141: //======================= Endpoint Search Routines ============================= 142: // Identify the endpoints of a detected edge and compute a sampling offset to 143: // correct for aliasing. The computed offset accounts for distance from edge 144: // to create a gradient of antialiased values. 145: // 146: // Input parameters: 147: // - posC: The texture coordinate position of the current pixel. 148: // - lumC: The luminosity of the current pixel. 149: // - lumHC: The luminosity of the highest contrast pixel to HC that is 150: // perpendicular to the detected edge. 151: // - lengthSign: Single component magnitude and direction (in texture 152: // coordinates) from the center of C pointing to HC. 153: // - tcPixel: (Width, Height) of a single pixel in texture coordinate units. 154: // - horzSpan: True if the detected edge is horizontal. 155: // - posEdgeAA: Output parameter with the position to resample the input texture 156: // to get an edge anti-aliased rgb value for the current pixel. 157: // 158: // Implementations: 159: // - nvidiaEndpointSearch: The algorithm proposed by nVidia in their whitepaper 160: // and sample implementations. Faster, but poorly handles single-pixel lines. 161: // - vtkEndpointSearch: Modified endpoint search that does more texture lookups, 162: // but does better detection of single pixel line endpoints. 163: // 164: // Return values for endpoint searches: 165: const int FXAA_NO_EDGE_AA = 0; // Edge AA not required. 166: const int FXAA_NEED_EDGE_AA = 1; // Edge AA required. 167: const int FXAA_ABORT_EDGE_AA = 2; // Instruct to return. Used for debugging. 168: 169: //================ nVidia's Endpoint Search Implementation ===================== 170: 171: int nvidiaEndpointSearch(vec2 posC, float lumC, float lumHC, float lengthSign, 172: vec2 tcPixel, bool horzSpan, out vec2 posEdgeAA) 173: { 174: /***************************************************************************** 175: * End of Edge Search * 176: *===========================================================================* 177: * Search along the direction of the detected edge to find both endpoints. * 178: * * 179: * We define HC as the Highest Contrast neighbor perpendicular to the edge * 180: * direction (i.e. the pixel on the other side of the edge). * 181: * * 182: * The luminosity of HC is lumHC, the contrast between C and HC is * 183: * contrastCHC, and the average luminosity of HC and C is lumAveCHC. * 184: * * 185: * We'll walk along the edge boundary in both direction, sampling the average* 186: * luminosity of the pixels on both sides of the edge: lumAveN for the * 187: * negative direction, lumAveP for the positive direction. We determine the * 188: * end of the edge to be where: * 189: * * 190: * abs(lumAve[NP] - lumCHC) >= contrastHC / 4. * 191: * * 192: * which indicates that the average luminosities have diverged enough to no * 193: * longer be considered part of the edge. * 194: ****************************************************************************/ 195: 196: float contrastCHC = abs(lumC - lumHC); 197: 198: // Point on the boundary of C and HC: 199: vec2 boundaryCHC = posC; // Will be shifted later. 200: 201: // Direction of the edge 202: vec2 edgeDir = vec2(0.f); // Component is set below: 203: 204: if (horzSpan) 205: { 206: boundaryCHC.y += lengthSign * 0.5f; 207: edgeDir.x = tcPixel.x; 208: } 209: else 210: { 211: boundaryCHC.x += lengthSign * 0.5f; 212: edgeDir.y = tcPixel.y; 213: } 214: 215: // Prepare for the search loop: 216: float contrastThreshold = contrastCHC / 4.f; 217: float lumAveCHC = 0.5f * (lumC + lumHC); 218: float lumAveN; 219: float lumAveP; 220: bool doneN = false; 221: bool doneP = false; 222: vec2 posN = boundaryCHC - edgeDir; 223: vec2 posP = boundaryCHC + edgeDir; 224: 225: #ifdef FXAA_DEBUG_EDGE_NUM_STEPS 226: int stepsN = 0; 227: int stepsP = 0; 228: #endif // FXAA_DEBUG_EDGE_NUM_STEPS 229: 230: for (int i = 0; i = contrastThreshold); 243: doneP = doneP || (abs(lumAveP - lumAveCHC) >= contrastThreshold); 244: if (doneN && doneP) break; 245: 246: // Step to next pixel: 247: if (!doneN) posN -= edgeDir; 248: if (!doneP) posP += edgeDir; 249: } 250: 251: #ifdef FXAA_DEBUG_EDGE_NUM_STEPS 252: fragOutput0 = vec4(float(stepsN) / float(EndpointSearchIterations), 0.f, 253: float(stepsP) / float(EndpointSearchIterations), 1.f); 254: return FXAA_ABORT_EDGE_AA; 255: #endif // FXAA_DEBUG_EDGE_NUM_STEPS 256: 257: /***************************************************************************** 258: * Edge Search Analysis * 259: *===========================================================================* 260: * We've located the ends of the edge at this point. Next we figure out how * 261: * to interpolate the edge. * 262: * * 263: * First we need to find out which end of the edge (N or P) is changing * 264: * contrast relative to boundaryCHC. This is best explained visually: * 265: * * 266: * +------------+ * 267: * |XX E | * 268: * |NXXXHXXP | * 269: * |N C PXXXX| * 270: * | X| * 271: * +------------+ * 272: * * 273: * In the above, an X represents a dark pixel, and a blank space is a light * 274: * pixel. C is the current pixel, and H is pixel HC. The negative endpoint N* 275: * of the edge is the midpoint between the first set of blank pixels to the * 276: * left of C and H, while the positive endpoint P is the first set of dark * 277: * pixels to the right. The pixels under the "N" are light, while the pixels* 278: * under "P" are dark. The "P" side of the edge is changing contrast * 279: * relative to C. We compute this condition as: * 280: * * 281: * bool lumCLessThanAve = lumC abs(lumHCN - lumC) || * 401: * abs(lumCN - lumC) > abs(lumCN - lumHC) * 402: * * 403: * where lumHCN is the luminosity of the sample in HC's row in the negative * 404: * direction, lumCN is the luminosity of the sample in C's row in the * 405: * negative direction, lumHC is the luminosity of HC, and lumC is the * 406: * luminosity of C. Thus, the endpoint is where a sampled luminosity in C's * 407: * row is closer to HC, or vice-versa. The positive endpoint is determined * 408: * similarly. * 409: * * 410: * After the endpoints has been determined, we decide whether or not the * 411: * current pixel needs resampling. This is similar to nVidia's algorithm. * 412: * We determine if the luminosity of the nearest endpoint's C sample is * 413: * closer to C or HC. If it's closer to HC, it gets shaded. The resampling * 414: * offset is computed identically to nVidia's algorithm. * 415: ****************************************************************************/ 416: 417: // Point on the boundary of C and HC: 418: vec2 posHC = posC; // Will be shifted later. 419: 420: // Direction of the edge 421: vec2 edgeDir = vec2(0.f); // Component is set below: 422: 423: if (horzSpan) 424: { 425: posHC.y += lengthSign; 426: edgeDir.x = tcPixel.x; 427: } 428: else 429: { 430: posHC.x += lengthSign; 431: edgeDir.y = tcPixel.y; 432: } 433: 434: // Prepare for the search loop: 435: float lumHCN; 436: float lumHCP; 437: float lumCN; 438: float lumCP; 439: bool doneN = false; 440: bool doneP = false; 441: vec2 posHCN = posHC - edgeDir; 442: vec2 posHCP = posHC + edgeDir; 443: vec2 posCN = posC - edgeDir; 444: vec2 posCP = posC + edgeDir; 445: 446: #ifdef FXAA_DEBUG_EDGE_NUM_STEPS 447: int stepsN = 0; 448: int stepsP = 0; 449: #endif // FXAA_DEBUG_EDGE_NUM_STEPS 450: 451: for (int i = 0; i abs(lumHCN - lumC) 472: || abs(lumCN - lumC) > abs(lumCN - lumHC); 473: doneP = doneP || abs(lumHCP - lumHC) > abs(lumHCP - lumC) 474: || abs(lumCP - lumC) > abs(lumCP - lumHC); 475: 476: if (doneN && doneP) 477: { 478: break; 479: } 480: 481: // Take next step. 482: if (!doneN) 483: { 484: posHCN -= edgeDir; 485: posCN -= edgeDir; 486: } 487: if (!doneP) 488: { 489: posHCP += edgeDir; 490: posCP += edgeDir; 491: } 492: } 493: 494: #ifdef FXAA_DEBUG_EDGE_NUM_STEPS 495: fragOutput0 = vec4(float(stepsN) / float(EndpointSearchIterations), 0.f, 496: float(stepsP) / float(EndpointSearchIterations), 1.f); 497: return FXAA_ABORT_EDGE_AA; 498: #endif // FXAA_DEBUG_EDGE_NUM_STEPS 499: 500: // Identify the closest point: 501: float dstN; 502: float dstP; 503: 504: if (horzSpan) 505: { 506: dstN = posC.x - posCN.x; 507: dstP = posCP.x - posC.x; 508: } 509: else 510: { 511: dstN = posC.y - posCN.y; 512: dstP = posCP.y - posC.y; 513: } 514: 515: bool nearestEndpointIsN = dstN 0.f) 684: { 685: fragOutput0 = vec4(vec3(blendSub / SubpixelBlendLimit), 1.f); 686: } 687: else 688: { 689: fragOutput0 = vec4(rgbC, 1.f); 690: } 691: return; 692: #endif // FXAA_DEBUG_SUBPIXEL_ALIASING 693: 694: // Compute the subpixel blend color. Average the 3x3 neighborhood: 695: vec3 rgbSub = (1.f/9.f) * 696: (rgbNW + rgbN + rgbNE + 697: rgbW + rgbC + rgbE + 698: rgbSW + rgbS + rgbSE); 699: 700: /**************************************************************************** 701: * Edge Testing * 702: *==========================================================================* 703: * Apply vertical and horizontal edge detection techniques to determine the * 704: * direction of any edges in the 3x3 neighborhood. * 705: ****************************************************************************/ 706: 707: // Check for vertical edge. Pixel coeffecients are: 708: // 1 -2 1 709: // 2 -4 2 710: // 1 -2 1 711: // The absolute value of each row is taken, summed, and divided by 12. 712: // Operations are decomposed here to take advantage of FMA ops. 713: float edgeVertRow1 = abs(-2.f * lumN + lumNWNE); 714: float edgeVertRow2 = abs(-2.f * lumC + lumWE); 715: float edgeVertRow3 = abs(-2.f * lumS + lumSWSE); 716: float edgeVert = ((2.f * edgeVertRow2 + edgeVertRow1) + edgeVertRow3) / 12.f; 717: 718: // Check for horizontal edge. Pixel coeffecients are: 719: // 1 2 1 720: // -2 -4 -2 721: // 1 2 1 722: // The absolute value of each column is taken, summed, and divided by 12. 723: // Operations are decomposed here to take advantage of FMA ops. 724: float edgeHorzCol1 = abs(-2.f * lumW + lumNWSW); 725: float edgeHorzCol2 = abs(-2.f * lumC + lumNS); 726: float edgeHorzCol3 = abs(-2.f * lumE + lumNESE); 727: float edgeHorz = ((2.f * edgeHorzCol2 + edgeHorzCol1) + edgeHorzCol3) / 12.f; 728: 729: // Indicates that the edge span is horizontal: 730: bool horzSpan = edgeHorz >= edgeVert; 731: 732: #ifdef FXAA_DEBUG_EDGE_DIRECTION 733: fragOutput0 = horzSpan ? vec4(0.f, 0.f, 1.f, 1.f) 734: : vec4(1.f, 0.f, 0.f, 1.f); 735: return; 736: #endif // FXAA_DEBUG_EDGE_DIRECTION 737: 738: /**************************************************************************** 739: * Endpoint Search Preparation * 740: *==========================================================================* 741: * Compute inputs for an endpoint detection algorithm. Mainly concerned * 742: * locating HC -- the Highest Contrast pixel (relative to C) that's on the * 743: * opposite side of the detected edge from C. * 744: ****************************************************************************/ 745: 746: // The two neighbor pixels perpendicular to the edge: 747: float lumHC1; 748: float lumHC2; 749: 750: // Single-pixel texture coordinate offset that points from C to HC. 751: float lengthSign; 752: 753: if (horzSpan) 754: { 755: lumHC1 = lumN; 756: lumHC2 = lumS; 757: lengthSign = -tcPixel.y; // Assume N for now. 758: } 759: else 760: { 761: lumHC1 = lumW; 762: lumHC2 = lumE; 763: lengthSign = -tcPixel.x; // Assume W for now. 764: } 765: 766: // Luminosity of the NSWE pixel perpendicular to the edge with the highest 767: // contrast to C: 768: float lumHC; 769: if (abs(lumC - lumHC1) >= abs(lumC - lumHC2)) 770: { 771: lumHC = lumHC1; 772: } 773: else 774: { 775: lumHC = lumHC2; 776: // Also reverse the offset direction in this case: 777: lengthSign = -lengthSign; 778: } 779: 780: vec2 posEdgeAA; // Position to resample C at to get edge-antialiasing. 781: 782: #ifdef FXAA_USE_HIGH_QUALITY_ENDPOINTS 783: int endpointResult = vtkEndpointSearch(tcC, lumC, lumHC, lengthSign, 784: tcPixel, horzSpan, posEdgeAA); 785: #else // FXAA_USE_HIGH_QUALITY_ENDPOINTS 786: int endpointResult = nvidiaEndpointSearch(tcC, lumC, lumHC, lengthSign, 787: tcPixel, horzSpan, posEdgeAA); 788: #endif // FXAA_USE_HIGH_QUALITY_ENDPOINTS 789: 790: // Only sample texture if needed. Reuse rgbC otherwise. 791: vec3 rgbEdgeAA = rgbC; 792: 793: switch (endpointResult) 794: { 795: case FXAA_ABORT_EDGE_AA: // Used for debugging (endpoint search set colors) 796: return; 797: 798: case FXAA_NEED_EDGE_AA: // Resample the texture at the requested position. 799: rgbEdgeAA = texture2D(Input, posEdgeAA).rgb; 800: break; 801: 802: case FXAA_NO_EDGE_AA: // Current pixel does not need edge anti-aliasing. 803: default: 804: break; 805: } 806: 807: #ifdef FXAA_DEBUG_ONLY_SUBPIX_AA 808: rgbEdgeAA = rgbC; 809: #endif // FXAA_DEBUG_ONLY_SUBPIX_AA 810: #ifdef FXAA_DEBUG_ONLY_EDGE_AA 811: blendSub = 0.f; 812: #endif // FXAA_DEBUG_ONLY_EDGE_AA 813: 814: // Blend the edgeAA and subpixelAA results together: 815: fragOutput0 = vec4(mix(rgbEdgeAA, rgbSub, blendSub), 1.f); 816: }

ERROR: In E:\SALOME-9.1.0\products\tmp\ParaView-5.6.0p1-7bafc2be_SRC\VTK\Rendering\OpenGL2\vtkShaderProgram.cxx, line 462 vtkShaderProgram (000001A8CE8FE9D0): ERROR: 0:238: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:238: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:238: 'luminosity' : no matching overloaded function found (using implicit conversion) ERROR: 0:239: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:239: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:239: 'luminosity' : no matching overloaded function found (using implicit conversion) ERROR: 0:461: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:461: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:461: 'luminosity' : no matching overloaded function found (using implicit conversion) ERROR: 0:462: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:462: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:462: 'luminosity' : no matching overloaded function found (using implicit conversion) ERROR: 0:466: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:466: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:466: 'luminosity' : no matching overloaded function found (using implicit conversion) ERROR: 0:467: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:467: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:467: 'luminosity' : no matching overloaded function found (using implicit conversion) ERROR: 0:599: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:599: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:599: '=' : cannot convert from 'const float' to '3-component vector of float' ERROR: 0:600: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:600: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:600: '=' : cannot convert from 'const float' to '3-component vector of float' ERROR: 0:601: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:601: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:601: '=' : cannot convert from 'const float' to '3-component vector of float' ERROR: 0:602: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:602: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:602: '=' : cannot convert from 'const float' to '3-component vector of float' ERROR: 0:603: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:603: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:603: '=' : cannot convert from 'const float' to '3-component vector of float' ERROR: 0:636: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:636: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:636: '=' : cannot convert from 'const float' to '3-component vector of float' ERROR: 0:637: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:637: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:637: '=' : cannot convert from 'const float' to '3-component vector of float' ERROR: 0:638: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:638: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:638: '=' : cannot convert from 'const float' to '3-component vector of float' ERROR: 0:639: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:639: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:639: '=' : cannot convert from 'const float' to '3-component vector of float' ERROR: 0:799: 'texture2D' : no matching overloaded function found (using implicit conversion) ERROR: 0:799: 'rgb' : field selection requires structure, vector, or matrix on left hand side ERROR: 0:799: 'assign' : cannot convert from 'const float' to '3-component vector of float'

ERROR: In E:\SALOME-9.1.0\products\tmp\ParaView-5.6.0p1-7bafc2be_SRC\VTK\Rendering\OpenGL2\vtkOpenGLVertexArrayObject.cxx, line 280 vtkOpenGLVertexArrayObject (000001A8DC14C8A0): attempt to add attribute without a program for attribute ndCoordIn

 

Generic Warning: In E:\SALOME-9.1.0\products\tmp\ParaView-5.6.0p1-7bafc2be_SRC\VTK\Rendering\OpenGL2\vtkOpenGLQuadHelper.cxx, line 60 Error binding ndCoords to VAO. 

 

Attachments

Re: Fail to initialize Paravis (Salome 9.3.0, Windows 10)

Posted by Sergio Pluchinsky at August 24. 2019

Update, with the Salome 9.2 version the error remains :(

 

Have installed the Microsoft Visual C 2015 runtimes, but is necessary install Python also????

Re: Fail to initialize Paravis (Salome 9.3.0, Windows 10)

Posted by Christophe Bourcier at August 26. 2019

Hi,

It seems there is an issue with the 3d view. Which graphic card do you have? You can try to install its drivers again.

Christophe

Re: Fail to initialize Paravis (Salome 9.3.0, Windows 10)

Posted by Sergio Pluchinsky at August 26. 2019

Thnaks for the support. The lalptop has has a basic Intel HD Graphics 3000, with the default drivers that came with Windows. Will try to install others to see if it works again. 

Re: Fail to initialize Paravis (Salome 9.3.0, Windows 10)

Posted by Christophe Bourcier at August 26. 2019

You can try this workaround for intel cards: https://www.salome-platform.org/forum/forum_9/150542777#337431061

Re: Fail to initialize Paravis (Salome 9.3.0, Windows 10)

Posted by Sergio Pluchinsky at August 27. 2019

Yesterday has tried using drivers from Intel site (that in fact were older than those included in Windows 10), but still the problem appear. Will try tonight with this workaround, otherwise will dwongrade my installation to Windows 7.

Re: Fail to initialize Paravis (Salome 9.3.0, Windows 10)

Posted by Sergio Pluchinsky at August 28. 2019

Thanks!!!! This last workaround (copy the dll from the Mesa3d to the Salome installation) fix the issue on my old laptop!

Re: Fail to initialize Paravis (Salome 9.3.0, Windows 10)

Posted by Christophe Bourcier at August 28. 2019

Thank you for the feedback. The performance of the 3d views should be almost the same.

Christophe

Powered by Ploneboard
Document Actions