Exemple #1
0
 public PointvizUniform(IMaterial <BitmapTag> material, MaterialBindings bindings, Matrix4x4 transform, Matrix4x4 inverted)
 {
     ModelMatrix  = transform;
     NormalMatrix = Matrix4x4.Transpose(inverted);
     DiffuseColor = material.DiffuseColor;
     AlphaAmount  = 1f;
 }
Exemple #2
0
 public SkyboxUniform(IMaterial <BitmapTag> material, MaterialBindings bindings)
 {
     DiffuseColor  = material.DiffuseColor;
     UseDiffuse    = bindings.DiffuseHandle != default;
     DiffuseHandle = bindings.DiffuseHandle;
     DiffuseAmount = 1f;
 }
        public MaterialBindings SetupTextures(IMaterial <BitmapTag> material)
        {
            if (boundMaterials.TryGetValue(material, out var bindings))
            {
                return(bindings);
            }

            bindings = new MaterialBindings();

            if (material.DiffuseMap != null)
            {
                textureBinder.GetOrBind(material.DiffuseMap, out var diffuseHandle);
                bindings.DiffuseHandle = diffuseHandle;
            }

            if (material.DetailMap1 != null)
            {
                textureBinder.GetOrBind(material.DetailMap1, out var handle);
                bindings.Detail1Handle = handle;
            }

            if (material.DetailMap2 != null)
            {
                textureBinder.GetOrBind(material.DetailMap2, out var handle);
                bindings.Detail2Handle = handle;
            }

            if (material.ColorChangeMask != null)
            {
                textureBinder.GetOrBind(material.ColorChangeMask, out var handle);
                bindings.ColorChangeHandle = handle;
            }

            if (material.AlphaMap != null)
            {
                textureBinder.GetOrBind(material.AlphaMap, out var alphaHandle);
                bindings.AlphaHandle = alphaHandle;
            }

            if (material.EmissiveMap != null)
            {
                textureBinder.GetOrBind(material.EmissiveMap, out var emissiveHandle);
                bindings.EmissiveHandle = emissiveHandle;
            }

            if (material.NormalMap != null)
            {
                textureBinder.GetOrBind(material.NormalMap, out var handle);
                bindings.NormalHandle = handle;
            }

            boundMaterials.Add(material, bindings);

            return(bindings);
        }
Exemple #4
0
        public GenericUniform(Mesh <BitmapTag> mesh, Vector4 colorChangeData, MaterialBindings bindings)
        {
            var material = mesh.Material;

            DiffuseColor  = material.DiffuseColor;
            UseDiffuse    = bindings.DiffuseHandle != default;
            DiffuseHandle = bindings.DiffuseHandle;
            DiffuseAmount = 1f;

            UseDetailMap1    = bindings.Detail1Handle != default;
            DetailMap1Amount = 1f;
            DetailMap1Handle = bindings.Detail1Handle;
            DetailMap1Scale  = material.Detail1Scale;

            UseDetailMap2    = bindings.Detail2Handle != default;
            DetailMap2Amount = 1f;
            DetailMap2Handle = bindings.Detail2Handle;
            DetailMap2Scale  = material.Detail2Scale;

            AlphaHandle  = bindings.AlphaHandle;
            UseAlpha     = bindings.AlphaHandle != default;
            AlphaChannel = new Vector4(material.AlphaFromRed ? 1f : 0f, 0, 0, material.AlphaFromRed ? 0f : 1f);
            AlphaAmount  = 1f;

            UseEmissiveMap    = bindings.EmissiveHandle != default;
            EmissiveMap       = bindings.EmissiveHandle;
            EmissiveType      = (int)material.EmissiveType;
            EmissiveArguments = material.EmissiveArguments;

            UseNormalMap    = bindings.NormalHandle != default;
            NormalMap       = bindings.NormalHandle;
            NormalMapAmount = 1f;
            NormalMapScale  = material.NormalMapScale;

            ChangeColor           = bindings.ColorChangeHandle != default;
            ColorChangeMaskHandle = bindings.ColorChangeHandle;
            ColorChangeAmount     = 1f;
            ColorChangeColor      = colorChangeData;

            // Currently unused
            UseSpecular    = false;
            SpecularAmount = 0f;
            SpecularColor  = Vector4.Zero;
            SpecularHandle = 0;
        }
        private int GenerateShaderUniform(DrawCommand command, MaterialBindings bindings)
        {
            var mesh = command.Mesh;
            var existingUniformHandle = 0;

            switch (activeShader)
            {
            case Shader.Skybox:
                BindAndBufferShaderUniform(
                    activeShader,
                    new SkyboxUniform(mesh.Material, bindings),
                    SkyboxUniform.Size,
                    out existingUniformHandle);
                break;

            case Shader.Generic:
                BindAndBufferShaderUniform(
                    activeShader,
                    new GenericUniform(mesh, command.ColorChangeData, bindings),
                    GenericUniform.Size,
                    out existingUniformHandle);

                break;

            case Shader.Wireframe:
                BindAndBufferShaderUniform(
                    activeShader,
                    new WireframeUniform(mesh.Material),
                    WireframeUniform.Size,
                    out existingUniformHandle);
                break;

            case Shader.Pointviz:
            case Shader.TextureViewer:
                break;
            }

            return(existingUniformHandle);
        }