Example #1
0
        public void Run(ShaderData sd)
        {
            Texture outtex = sd.GetOutputTexture (0);
            float wq = 1f / (float)outtex.Width;
            float hq = 1f / (float)outtex.Height;
            if (Tracing.Enabled) Console.WriteLine ("wq {0} hq {1}", wq, hq);

            ShaderContext ctx = new ShaderContext (sd);
            EvalVisitor visitor = new EvalVisitor (ctx);

            float acc_w = wq / 2;
            for (int i = 0; i < outtex.Width; ++i) {

                float acc_h = hq / 2;
                for (int j = 0; j < outtex.Height; ++j) {
                    if (Tracing.Enabled) Console.WriteLine ("----processing x {0} y {1}", i, j);
                    ctx.ResetState ();

                    ctx.SetTextureValue (0, acc_w, acc_h);
                    acc_h += hq;

                    foreach (var ins in shader)
                        ins.Visit (visitor);

                    ctx.WriteColor (0, i, j, outtex);
                }
                acc_w += wq;
            }
        }
Example #2
0
 internal ShaderContext(ShaderData shaderData)
 {
     this.shaderData = shaderData;
 }
Example #3
0
        public static int Main(string[] args)
        {
            ShaderData sd = new ShaderData ();

            bool dump = false, trace = false, interpreter = false, help = false;
            OptionSet opts = new OptionSet () {
                { "d|dump", "Decompile the shader to stdout.", v => dump = true },
                { "t|trace", "Enable tracing of execution (best used with --interpreter).", v => trace = true },
                { "i|interpreter", "Use the interpreter instead of the JIT.", v => interpreter = true },
                { "h|help", "Show this message and exit.", v => help = true },
                { "c:", "Set the value of a constant register", (k, v) =>  sd.SetConstant (int.Parse (k), float.Parse (v)) }
            };

            List<string> extra;
            try {
                extra = opts.Parse (args);
            } catch (OptionException e) {
                Console.WriteLine ("{0}\nTry 'shader --help' for more information.", e.Message);
                return 1;
            }

            if (extra.Count != 3)
                help = true;

            if (help) {
                Console.WriteLine ("Usage: shader [options] shader input-image output-image");
                Console.WriteLine ("Apply the given shader to input-image and save it to output-image");
                opts.WriteOptionDescriptions (Console.Out);
                return 2;
            }

            if (trace)
                TracingConfig.Enable ();

            Parser parser = new Parser (extra [0]);
            var insList = parser.Parse ();
            if (dump) {
                foreach (var i in insList)
                    Console.WriteLine (i);
                return 0;
            }

            var srcImg = new CairoImageSurface (extra [1]);
            var dstImg = srcImg.CreateSimilar ();

            Texture intex = new CairoTexture (srcImg);
            Texture outtex =  new CairoTexture (dstImg);

            sd.SetSampler (0, new Sampler (intex));
            sd.SetOutputTexture (0, outtex);

            if (interpreter) {
                Interpreter interp = new Interpreter (insList);
                interp.Run (sd);
            } else {
                CodeGenContext ctx = new CodeGenContext (insList);
                CompiledShader shader = ctx.Compile ();
                shader (sd);
            }
            dstImg.SaveToPng (extra [2]);
            return 0;
        }