Attachment 63848 Details for Bug 51745 – output

output

array.txt (text/plain), 11.46 KB, created by lu hua on 2012-07-05 00:21:08 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: lu hua

Created: 2012-07-05 00:21:08 UTC

Size: 11.46 KB

patch

obsolete

>Intel OpenGL Conformance Test
>Version ENG (Jul  4 2012 14:16:47)
>
>CLI options echo:
>oglconform -z -suite all -v 2 -D 154 -test glsl-bif-tex-texture basic.textureLodOffset.sampler1DArray 
>
>Window will be recreated 1 times.
>  Window 0 will run 1 testcases on config with id 154.
>Total of 1 testcases will be executed.
>
>Setup Report.
>    Verbose level = 2.
>    Path inactive.
>
>Visual Report for ID 154 (32 bits).
>ID      |ACCELERA|DB      |REND_T  |SURF_T  |C_BUF_T |BUF_S   |RED_S   |
>     154|       1|       1|      gl|  wipbpx|    rgba|      32|       8|
>
>GREEN_S |BLUE_S  |ALPHA_S |DEPTH_S |STENC_S |ACCUM_S |SPL_BUF |SAMPLES |
>       8|       8|       8|      24|       8|      64|       0|       0|
>
>SRGB    |TEX_RGB |TEX_RGBA|CAVEAT  |SWAP    |M_PBUF_W|M_PBUF_H|M_PBUF_P
>      -1|       0|       0|    slow|   undef|       0|       0|       0
>
>OpenGL Report.
>    Vendor - 'Tungsten Graphics, Inc'
>    Renderer - 'Mesa DRI Intel(R) Sandybridge Desktop '
>    Version - '3.0 Mesa 8.0.3 (git-3bcddd5)' (3.0)
>    GLSL Version - '1.30'
>    Context Flags - None
>
>>> GLSL built-in functions, texture lookups (glsl-bif-tex-texture)  test:
>--> 2.4.14 - basic.textureLodOffset.sampler1DArray subcase:
>VS: Errors number: 72
>
>Vertex Shader:
>--- --- ---
>#version 130 
>precision highp float; 
>                                                                 
>#define VERTEX_SHADER                                              
>vec4 ColorToVec4(int color)          
>{                                    
> if (color == 0)                     
>   return vec4(255, 0, 0, 255);      
> if (color == 1)                     
>   return vec4(0, 255, 0, 255);      
> if (color == 2)                     
>   return vec4(0, 0, 255, 255);      
> if (color == 3)                     
>   return vec4(0, 0, 0, 255);        
> if (color == 4)                     
>   return vec4(255, 255, 255, 255);  
> if (color == 5)                     
>   return vec4(255, 255, 0, 255);    
> if (color == 6)                     
>   return vec4(0, 255, 255, 255);    
> return vec4(255, 0, 255, 255);      
>}                                    
>int mod(int a, int b)                
>{                                    
> int div = a / b;                    
> int res = a - b * div;              
> return (res >= 0) ? res : res + b;  
>}                                    
>                                                                 
>uniform sampler1DArray tex; 
>#define MIPS_ENABLED 
>#define _pos vec2(pos.x, floor(pos.x*dims.y)),1.f,offset.x
>#define _pos2 _pos 
>#define _pos3 _pos 
>#define _pos4 _pos 
>#define TEX_TARGET_1DArray
>#define LOD_FUNC_ON 
>#define texture textureLodOffset 
>                                                           
>const ivec3 offset = ivec3(3,0,0);                        
>vec4 GetDriverResults(vec4 pos, ivec3 dims)                   
>{                                                            
>#ifdef LOD_FUNC_ON                                           
>   return vec4(texture(tex, _pos3));                        
>#else                                                        
> #ifdef VERTEX_SHADER                                        
>   return vec4(texture(tex, _pos3));                        
> #else                                                       
>   #ifdef BIAS_FUNC_OFF                                      
>     return vec4(texture(tex, _pos));                       
>   #else                                                     
>     if (pos.x < 0.25f)                                      
>       return vec4(texture(tex, _pos));                     
>     if (pos.x < 0.5f)                                       
>       return vec4(texture(tex, _pos2, float(0x00)));       
>     if (pos.x < 0.75f)                                      
>       return vec4(texture(tex, _pos3, float(-0x100)));     
>     return vec4(texture(tex, _pos4, float(0100)));         
>   #endif                                                    
> #endif                                                      
>#endif                                                       
>}                                                            
>int GetColorsNumber(ivec3 dims, vec4 pos)                     
>{                                                            
> int res = 7;                                                
>#ifdef TEX_TARGET_Cube                                       
> #if defined(VERTEX_SHADER) || defined(LOD_FUNC_ON)          
>   res = 6;                                                  
> #else                                                       
> {                                                           
>   if (pos.x < 0.25f)                                        
>     res = 2;                                                
>   else if (pos.x < 0.5f)                                    
>     res = 5;                                                
>   else if (pos.x < 0.75f)                                   
>     res = 6;                                                
> }                                                           
> #endif                                                      
>#endif                                                       
> return res;                                                 
>}                                                            
>int GetElementsNumber(ivec3 dims)                             
>{                                                            
> int res;                                                    
> res = dims.x * (dims.y > 0 ? dims.y : 1);                   
> res *= (dims.z > 0 ? dims.z : 1);                           
> return res;                                                 
>}                                                            
>int GetTexelLinearPos(ivec3 dims, vec4 pos, bool shadow)            
>{                                                                  
> int colors = GetColorsNumber(dims, pos);                         
> ivec3 texel;                                                      
> int res;                                                         
> texel.x = int(pos.x*dims.x);                                     
> texel.y = int(pos.y*2*dims.y);                                  
> texel.z = int(pos.x*dims.z);                                     
>#ifdef TEX_TARGET_1DArray                                          
> texel.y = int(pos.x*dims.y);                                     
>#endif                                                             
> texel.x = mod(texel.x + mod(offset.x, dims.x), dims.x);      
> if (dims.y > 0)                                                  
>   texel.y = mod(texel.y + mod(offset.y, dims.y), dims.y);    
> if (dims.z > 0)                                                  
>   texel.z = mod(texel.z + mod(offset.z, dims.z), dims.z);    
> res = texel.x;                                                    
> res += texel.y * dims.x;                                          
> res += texel.z * dims.x * dims.y;                                 
> if (shadow)                                                       
>   return mod(res, 10);                                      
> return mod(mod(res, GetElementsNumber(dims)), colors);  
>}                                                                  
>void RecalculateData(inout ivec3 dims)                       
>{                                                            
>#ifdef TEX_TARGET_1DArray                                    
> dims.x /= 2;                                               
>#elif defined TEX_TARGET_2DArray                             
> dims.xy /= ivec2(2);                                       
> dims.y = dims.x < 1 ? 1 : dims.y;                         
>#else                                                        
> dims /= ivec3(2);                                           
> dims.y = dims.x < 1 ? 1 : dims.y;                         
> dims.z = dims.z < 1 ? 1 : dims.z;                         
>#endif                                                       
> dims.x = dims.x < 1 ? 1 : dims.x;                         
>}                                                            
>vec4 GetShadowCmp(ivec3 dims, vec4 pos, float d_ref)                  
>{                                                                    
> if (d_ref <= mod(GetTexelLinearPos(dims, pos, true)*7, 10))  
>   return vec4(1);                                                   
> return vec4(0);                                                     
>}                                                                    
>vec4 testFunction(vec4 pos)                                  
>{                                                            
> ivec3 dims = ivec3(16,5,0);                               
> vec4 dark = vec4(0);                                        
> if (pos.y >= 0.5f)                                          
>   return GetDriverResults(pos, dims);                       
>#ifdef LOD_FUNC_ON                                           
> RecalculateData(dims);                                      
>   dark = vec4(50);                                          
>#elif !defined VERTEX_SHADER                                 
> #ifdef MIPS_ENABLED                                         
> if (pos.x >= 0.75f)                                         
> {                                                           
>   RecalculateData(dims);                                    
>   dark = vec4(50);                                          
> }                                                           
> #endif                                                      
>#endif                                                       
>#ifdef SHADOW_FORM                                           
> vec4 res = GetShadowCmp(dims, pos, SHADOW_FORM);            
> if (res != GetShadowCmp(dims, pos-vec4(1e-5f), SHADOW_FORM))
>   return ColorToVec4(100);                                  
> if (res != GetShadowCmp(dims, pos+vec4(1e-5f), SHADOW_FORM))
>   return ColorToVec4(100);                                  
> return res;                                                 
>#else                                                        
> vec4 res = ColorToVec4(GetTexelLinearPos(dims,pos,false));  
> if (res != ColorToVec4(GetTexelLinearPos(dims,pos-vec4(1e-5f),false))) 
>   return ColorToVec4(100);                                  
> if (res != ColorToVec4(GetTexelLinearPos(dims,pos+vec4(1e-5f),false))) 
>   return ColorToVec4(100);                                  
> return res-dark;                                            
>#endif                                                       
>}                                                            
>                                                                 
>void main()                                                        
>{                                                                  
> gl_Position = gl_Vertex;                                          
> gl_FrontColor = testFunction((gl_Vertex + vec4(1.0f))/vec4(2.0f))/vec4(255);
>}                                                                  
>
>
>Fragment Shader:
>--- --- ---
>#version 130               
>void main()                
>{                          
> gl_FragColor = gl_Color*vec4(255);  
>}                          
>
>
>
>--< 2.4.14 - basic.textureLodOffset.sampler1DArray subcase failed.
><< GLSL built-in functions, texture lookups (glsl-bif-tex-texture)  test failed. (1 of 1 subcases)
>
>Intel Conformance failed.
>Total Passed : 0
>Total Failed : 1
>Total Not run: 0

Actions: View

Attachments on bug 51745: 63848

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.