class WebGLMaterial { // implements Material {
 Material _material;

 var program;
 var _fragmentShader;
 var _vertexShader;
 var _uniforms;
 var uniformsList;

 num numSupportedMorphTargets = 0, numSupportedMorphNormals = 0;

 // Used by ShadowMapPlugin
 bool shadowPass = false;

 WebGLMaterial._internal(Material material) : _material = material;

 factory WebGLMaterial.from(Material material) {

   if (material["__webglMaterial"] == null) {
     var webglMaterial = new WebGLMaterial._internal(material);
     material["__webglMaterial"] = webglMaterial;
   }

   return material["__webglMaterial"];
 }

 Map<String, Attribute> get attributes => (isShaderMaterial)? (_material as ShaderMaterial).attributes : null;
 get defines => (isShaderMaterial)? (_material as ShaderMaterial).defines : {};
 get fragmentShader => (isShaderMaterial)? (_material as ShaderMaterial).fragmentShader : _fragmentShader;
 get vertexShader => (isShaderMaterial)? (_material as ShaderMaterial).vertexShader : _vertexShader;
 get uniforms => (isShaderMaterial)? (_material as ShaderMaterial).uniforms : _uniforms;
 set fragmentShader(v) => (isShaderMaterial)? (_material as ShaderMaterial).fragmentShader = v : _fragmentShader = v;
 set vertexShader(v) => (isShaderMaterial)? (_material as ShaderMaterial).vertexShader = v: _vertexShader = v;
 set uniforms(v) => (isShaderMaterial)? (_material as ShaderMaterial).uniforms = v : _uniforms = v;

 bool get needsSmoothNormals
   => (_material != null) && (shading != null) && (shading == SmoothShading);

 // only MeshBasicMaterial and MeshDepthMaterial don't need normals
 bool get needsNormals
   => ! (( _material is MeshBasicMaterial && (envMap == null) ) || _material is MeshDepthMaterial);

 String get name => _material.name;
 int get id => _material.id;
 int get side => _material.side;
 num get opacity => _material.opacity;
 int get blending => _material.blending;
 int get blendSrc => _material.blendSrc;
 int get blendDst => _material.blendDst;
 int get blendEquation => _material.blendEquation;
 num get alphaTest => _material.alphaTest;
 int get polygonOffsetFactor => _material.polygonOffsetFactor;
 int get polygonOffsetUnits => _material.polygonOffsetUnits;
 bool get transparent => _material.transparent;
 bool get depthTest => _material.depthTest;
 bool get depthWrite => _material.depthWrite;
 bool get polygonOffset => _material.polygonOffset;
 bool get overdraw => _material.overdraw;
 bool get visible => _material.visible;
 bool get needsUpdate => _material.needsUpdate;
 set needsUpdate(bool flag) => _material.needsUpdate = flag;


 // TODO - Define proper interfaces to remove use of Dynamic
 get vertexColors => _hasVertexColors ? (_material as dynamic).vertexColors : NoColors;
 get color => (_material as dynamic).color;
 get ambient => (_material as dynamic).ambient;
 get emissive => (_material as dynamic).emissive;

 get shininess => (isMeshPhongMaterial) ? (_material as dynamic).shininess : null;
 get specular => (isMeshPhongMaterial) ? (_material as dynamic).specular : null;

 get lights => isShaderMaterial ? (_material as ShaderMaterial).lights : false;

 get morphTargets => _hasMorhTargets ?  (_material as dynamic).morphTargets : false;
 get morphNormals => _hasMorphNormals ?  (_material as dynamic).morphNormals : false;

 bool get metal => isMeshPhongMaterial ? (_material as MeshPhongMaterial).metal : false; //null;

 bool get perPixel => isMeshPhongMaterial ? (_material as MeshPhongMaterial).perPixel : false; //null;

 get wrapAround => _hasWrapAround ?  (_material as dynamic).wrapAround : false;

 get fog => _hasFog ? (_material as dynamic).fog : false;
 get shading => (_material as dynamic).shading;
 get map => _hasTextureMap ? (_material as dynamic).map : null;
 get envMap => _hasEnvMap ? (_material as dynamic).envMap : null;
 get lightMap => _hasLightMap ? (_material as dynamic).lightMap : null;
 get bumpMap => isMeshPhongMaterial ? (_material as MeshPhongMaterial).bumpMap : null;
 get normalMap => _hasNormalMap ? (_material as dynamic).normalMap : null;
 get specularMap => _hasSpecularMap ? (_material as dynamic).specularMap : null;

 get wireframe => !isLineBasicMaterial && !isParticleBasicMaterial && (_material as dynamic).wireframe;
 get wireframeLinewidth => (wireframe) ? (_material as dynamic).wireframeLinewidth : null;
 get wireframeLinecap => (wireframe) ? (_material as dynamic).wireframeLinecap : null;
 get wireframeLinejoin => (wireframe) ? (_material as dynamic).wireframeLinejoin : null;

 get linewidth => (isLineBasicMaterial) ? (_material as dynamic).linewidth : null;
 get reflectivity => (_material as dynamic).reflectivity;
 get refractionRatio => (_material as dynamic).refractionRatio;
 get combine => (_material as dynamic).combine;
 get skinning => _hasSkinning ?  (_material as dynamic).skinning : false;
 get sizeAttenuation => isParticleBasicMaterial ? (_material as ParticleBasicMaterial).sizeAttenuation : false; //null;
 get size => isParticleBasicMaterial ? (_material as ParticleBasicMaterial).size : null;

 bool get isShaderMaterial => _material is ShaderMaterial;
 bool get isMeshFaceMaterial => _material is MeshFaceMaterial;
 bool get isMeshDepthMaterial => _material is MeshDepthMaterial;
 bool get isMeshNormalMaterial => _material is MeshNormalMaterial;
 bool get isMeshBasicMaterial => _material is MeshBasicMaterial;
 bool get isMeshLambertMaterial => _material is MeshLambertMaterial;
 bool get isMeshPhongMaterial => _material is MeshPhongMaterial;
 bool get isLineBasicMaterial => _material is LineBasicMaterial;
 bool get isParticleBasicMaterial => _material is ParticleBasicMaterial;

 // TODO - Use this to identify proper interfaces
 bool get _hasAmbient => isMeshLambertMaterial || isMeshPhongMaterial;
 bool get _hasEmissive => isMeshLambertMaterial || isMeshPhongMaterial;
 bool get _hasWrapAround => isMeshLambertMaterial || isMeshPhongMaterial;

 bool get _hasLightMap => isMeshBasicMaterial || isMeshLambertMaterial || isMeshPhongMaterial;
 bool get _hasEnvMap => isMeshBasicMaterial || isMeshLambertMaterial || isMeshPhongMaterial;
 bool get _hasSpecularMap => isMeshBasicMaterial || isMeshLambertMaterial || isMeshPhongMaterial;
 bool get _hasNormalMap => isMeshPhongMaterial;

 bool get _hasTextureMap => isMeshBasicMaterial || isMeshLambertMaterial || isMeshPhongMaterial || isParticleBasicMaterial; //_material is ITextureMapMaterial;

 bool get _hasSkinning => isMeshBasicMaterial || isMeshLambertMaterial || isMeshPhongMaterial || isShaderMaterial;

 bool get _hasMorhTargets => isMeshBasicMaterial || isMeshLambertMaterial || isMeshPhongMaterial || isShaderMaterial;

 bool get _hasMorphNormals => isMeshLambertMaterial || isMeshPhongMaterial || isShaderMaterial;

 bool get _hasVertexColors => isLineBasicMaterial || isMeshBasicMaterial || isMeshLambertMaterial || isMeshPhongMaterial || isParticleBasicMaterial || isShaderMaterial;
 bool get _hasFog => isLineBasicMaterial || isMeshBasicMaterial || isMeshLambertMaterial || isMeshPhongMaterial || isParticleBasicMaterial || isShaderMaterial;
}