コード例 #1
0
ファイル: ShaderCode.cs プロジェクト: zigaosolin/SharpMedia
 /// <summary>
 /// Compiles using a device and fixed parameters.
 /// </summary>
 /// <param name="device">The device.</param>
 public IShader Compile(GraphicsDevice device, FixedShaderParameters parameters)
 {
     using (ShaderCompiler compiler = device.CreateShaderCompiler())
     {
         return(Compile(compiler, parameters));
     }
 }
コード例 #2
0
        public IShader CompileFromFile(BindingStage stage, String filename, FixedShaderParameters parameters)
        {
            Driver.IShaderBase b = compiler.Compile(stage, filename);

            // We now terminate it.
            switch (stage)
            {
            case BindingStage.VertexShader:
                return(new VShader(parameters, (Driver.IVShader)b));

            case BindingStage.PixelShader:
                return(new PShader(parameters, (Driver.IPShader)b));

            case BindingStage.GeometryShader:
            default:
                throw new NotImplementedException();
            }
        }
コード例 #3
0
 /// <summary>
 /// Constructor from device.
 /// </summary>
 /// <param name="d">The ShaderCode.</param>
 /// <param name="s">The shader.</param>
 internal VShader(FixedShaderParameters f, Driver.IVShader s)
 {
     driverPart  = s;
     fixedParams = f;
 }
コード例 #4
0
 public SharpMedia.Graphics.Shaders.ShaderCompiler.Operand[] Compile(SharpMedia.Graphics.Shaders.ShaderCompiler compiler, SharpMedia.Graphics.Shaders.ShaderCompiler.Operand[] operands, SharpMedia.Graphics.Shaders.FixedShaderParameters parameters, ref SharpMedia.Graphics.Shaders.Operations.DualShareContext shareContext)
 {
     throw new Exception("The method or operation is not implemented.");
 }
コード例 #5
0
ファイル: ShaderCode.cs プロジェクト: zigaosolin/SharpMedia
        /// <summary>
        /// Compiles using a given shader compiler.
        /// </summary>
        /// <param name="compiler">The compiler.</param>
        /// <param name="parameters">Shader parameters.</param>
        public IShader Compile(ShaderCompiler compiler, FixedShaderParameters parameters)
        {
            if (immutable == false || parameters == null || parameters.ShaderCode != this)
            {
                throw new ArgumentNullException("Argument is invalid (null) or is not part of this ShaderCode.");
            }

            lock (cacheSyncRoot)
            {
                ICacheable shader = cache.FindAndTouch(parameters);
                if (shader != null)
                {
                    return(shader as IShader);
                }
            }

            // We make validation of parameters and layouts.
            parameters.IsDefinedThrow();

            // ShaderCode must be immutable here if parameters were sucessfully created, operations must be cached.
            List <KeyValuePair <Pin, ShaderCompiler.Operand> > operands = new List <KeyValuePair <Pin, ShaderCompiler.Operand> >();

            cachedOps = (cachedOps == null) ? GraphHelper.GetSortedOperations(output) : cachedOps;

            List <DualShareContext> shareData = new List <DualShareContext>();

            // Begin compilation process.
            compiler.Begin(stage);

            // We go through all operations in right order
            for (int i = cachedOps.Count - 1; i >= 0; i--)
            {
                IOperation operation = cachedOps[i];

                // First prepare all inputs.
                Pin[] pins = operation.Inputs;
                ShaderCompiler.Operand[] inputs = new ShaderCompiler.Operand[pins.Length];
                for (uint j = 0; j < pins.Length; j++)
                {
                    // We extract it.
                    for (int z = 0; z < operands.Count; z++)
                    {
                        if (object.ReferenceEquals(operands[z].Key, pins[j]))
                        {
                            inputs[j] = operands[z].Value;
                            continue;
                        }
                    }
                }

                // Find if sharing context exists.
                int idx = shareData.FindIndex(delegate(DualShareContext c) { return(c.DestinationOperation == operation); });
                DualShareContext shareContext = null;
                if (idx >= 0)
                {
                    shareContext = shareData[idx];
                    shareData.RemoveAt(idx);
                }

                // Compile the operation.
                ShaderCompiler.Operand[] outputs = operation.Compile(compiler, inputs,
                                                                     parameters, ref shareContext);

                // We add it if it is not the same as "this" and notn-null.
                if (shareContext != null && shareContext.DestinationOperation != operation)
                {
                    shareData.Add(shareContext);
                }

                // Add all outputs.
                for (uint z = 0; z < outputs.Length; z++)
                {
                    operands.Add(new KeyValuePair <Pin, ShaderCompiler.Operand>(operation.Outputs[z], outputs[z]));
                }
            }

            // We do the compile process.
            IShader shader1 = compiler.End(parameters);

            // We add it to cache.
            lock (cacheSyncRoot)
            {
                try
                {
                    cache.Add(parameters, shader1);
                } catch (Exception)
                {
                    // This is the case when cache probably re-inserted shader.
                    IShader shader2 = cache.FindAndTouch(parameters) as IShader;
                    if (shader2 != null)
                    {
                        Common.Warning(typeof(ShaderCode), "Recompiled the same shader two times in a row.");

                        shader1.Dispose();
                        return(shader2);
                    }

                    // If not, we rethrow.
                    throw;
                }
            }

            return(shader1);
        }
コード例 #6
0
 /// <summary>
 /// Device constructor.
 /// </summary>
 internal GShader(Driver.IGShader s, FixedShaderParameters p, ShaderCode d)
 {
     dag         = d;
     fixedParams = p;
     driverPart  = s;
 }
コード例 #7
0
 /// <summary>
 /// Creates pixel shader based on driver.
 /// </summary>
 /// <param name="d">The ShaderCode operations.</param>
 /// <param name="s"></param>
 internal PShader(FixedShaderParameters p, Driver.IPShader s)
 {
     driverPart  = s;
     fixedParams = p;
 }