tor-browser

test_shaders.rs (6072B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use webrender::ShaderKind;
use webrender_build::shader::{ShaderFeatureFlags, ShaderVersion, build_shader_strings};
use webrender_build::shader::get_shader_features;
use glsl_lang::ast::{InterpolationQualifierData, NodeContent, SingleDeclaration};
use glsl_lang::ast::{StorageQualifierData, TranslationUnit, TypeSpecifierNonArrayData};
use glsl_lang::ast::TypeQualifierSpecData;
use glsl_lang::parse::DefaultParse as _;
use glsl_lang::visitor::{Host, Visit, Visitor};

/// Tests that a shader contains no flat scalar varyings.
/// These must be avoided on Adreno 3xx devices due to bug 1630356.
fn test_no_flat_scalar_varyings(
   name: &str,
   shader: &mut TranslationUnit,
   _shader_kind: ShaderKind,
) {
   struct FlatScalarVaryingsVisitor {
       shader_name: String,
   }

   impl Visitor for FlatScalarVaryingsVisitor {
       fn visit_single_declaration(&mut self, declaration: &SingleDeclaration) -> Visit {
           let is_scalar = matches!(
               declaration.ty.ty.ty.content,
               TypeSpecifierNonArrayData::Bool
                   | TypeSpecifierNonArrayData::Int
                   | TypeSpecifierNonArrayData::UInt
                   | TypeSpecifierNonArrayData::Float
                   | TypeSpecifierNonArrayData::Double
           );

           let qualifiers = declaration
               .ty
               .qualifier
               .as_ref()
               .map(|q| q.qualifiers.as_slice())
               .unwrap_or(&[]);

           let is_flat = qualifiers.contains(
               &TypeQualifierSpecData::Interpolation(InterpolationQualifierData::Flat.into_node())
                   .into_node(),
           );

           assert!(
               !(is_scalar && is_flat),
               "{}: {} is a flat scalar varying",
               self.shader_name,
               &declaration.name.as_ref().unwrap()
           );

           Visit::Parent
       }
   }

   let mut visitor = FlatScalarVaryingsVisitor {
       shader_name: name.to_string(),
   };
   shader.visit(&mut visitor);
}

/// Tests that a shader's varyings have an explicit precision specifier.
/// Mali vendor tooling shows us that we are often varying-iterpolation bound, so using mediump
/// where possible helps alleviate this. By enforcing that varyings are given explicit precisions,
/// we ensure that highp is only used when necessary rather than just by default.
fn test_varying_explicit_precision(
   name: &str,
   shader: &mut TranslationUnit,
   shader_kind: ShaderKind,
) {
   struct VaryingExplicitPrecisionVisitor {
       shader_name: String,
       shader_kind: ShaderKind,
   }

   impl Visitor for VaryingExplicitPrecisionVisitor {
       fn visit_single_declaration(&mut self, declaration: &SingleDeclaration) -> Visit {
           let qualifiers = declaration
               .ty
               .qualifier
               .as_ref()
               .map(|q| q.qualifiers.as_slice())
               .unwrap_or(&[]);

           let is_varying = qualifiers.iter().any(|qualifier| {
               match &qualifier.content {
                   TypeQualifierSpecData::Storage(storage) => match self.shader_kind {
                       ShaderKind::Vertex => storage.content == StorageQualifierData::Out,
                       ShaderKind::Fragment => storage.content == StorageQualifierData::In,
                   }
                   _ => false,
               }
           });

           let has_explicit_precision = qualifiers
               .iter()
               .any(|qualifier| matches!(qualifier.content, TypeQualifierSpecData::Precision(_)));

           assert!(
               !is_varying || has_explicit_precision,
               "{}: {} is a varying without an explicit precision declared",
               self.shader_name,
               &declaration.name.as_ref().unwrap()
           );

           Visit::Parent
       }
   }

   let mut visitor = VaryingExplicitPrecisionVisitor {
       shader_name: name.to_string(),
       shader_kind,
   };
   shader.visit(&mut visitor);
}

pub fn test_shaders() {
   let mut flags = ShaderFeatureFlags::all();
   if cfg!(any(target_os = "windows", target_os = "android")) {
       flags.remove(ShaderFeatureFlags::GL);
   } else {
       flags.remove(ShaderFeatureFlags::GLES);
   }
   // glsl-lang crate fails to parse advanced blend shaders
   flags.remove(ShaderFeatureFlags::ADVANCED_BLEND_EQUATION);
   // glsl-lang crate fails to parse texture external BT709 shaders
   flags.remove(ShaderFeatureFlags::TEXTURE_EXTERNAL_BT709);

   for (shader, configs) in get_shader_features(flags) {
       for config in configs {
           let name = if config.is_empty() {
               shader.to_string()
           } else {
               format!("{}_{}", shader, config.replace(",", "_"))
           };
           let vert_name = format!("{}.vert", name);
           let frag_name = format!("{}.frag", name);


           let features = config
               .split(",")
               .filter(|f| !f.is_empty())
               .collect::<Vec<_>>();

           let (vert_src, frag_src) =
               build_shader_strings(ShaderVersion::Gles, &features, shader, &|f| {
                   webrender::get_unoptimized_shader_source(f, None)
               });

           let mut vert = TranslationUnit::parse(&vert_src).unwrap();
           let mut frag = TranslationUnit::parse(&frag_src).unwrap();


           test_no_flat_scalar_varyings(&vert_name, &mut vert, ShaderKind::Vertex);
           test_no_flat_scalar_varyings(&frag_name, &mut frag, ShaderKind::Fragment);
           test_varying_explicit_precision(&vert_name, &mut vert, ShaderKind::Vertex);
           test_varying_explicit_precision(&frag_name, &mut frag, ShaderKind::Fragment);
       }
   }
}