Esempio n. 1
0
        private void CompileExpressionContext(IEnumerable <VFXContext> contexts,
                                              VFXExpressionContextOption options,
                                              VFXDeviceTarget target,
                                              VFXExpression.Flags forbiddenFlags = VFXExpression.Flags.None)
        {
            var expressionContext = new VFXExpression.Context(options, m_GlobalEventAttributes);

            var contextsToExpressions = target == VFXDeviceTarget.GPU ? m_ContextsToGPUExpressions : m_ContextsToCPUExpressions;
            var expressionsToReduced  = target == VFXDeviceTarget.GPU ? m_GPUExpressionsToReduced : m_CPUExpressionsToReduced;

            foreach (var context in contexts)
            {
                var mapper = context.GetExpressionMapper(target);
                if (mapper != null)
                {
                    foreach (var exp in mapper.expressions)
                    {
                        expressionContext.RegisterExpression(exp);
                    }
                    contextsToExpressions.Add(context, mapper);
                }
            }

            expressionContext.Compile();

            foreach (var exp in expressionContext.RegisteredExpressions)
            {
                var reduced = expressionContext.GetReduced(exp);
                if (expressionsToReduced.ContainsKey(exp))
                {
                    if (reduced != expressionsToReduced[exp])
                    {
                        throw new InvalidOperationException("Unexpected diverging expression reduction");
                    }
                    continue;
                }
                expressionsToReduced.Add(exp, reduced);
            }

            var allReduced = expressionContext.BuildAllReduced();

            if (forbiddenFlags != VFXExpression.Flags.None)
            {
                var check = allReduced.Any(e => e.IsAny(forbiddenFlags));
                if (check)
                {
                    //TODO: Provide an error in GUI when feedback is possible
                    throw new InvalidOperationException("Invalid expression usage while compiling");
                }
            }

            m_Expressions.UnionWith(allReduced);

            foreach (var exp in expressionsToReduced.Values)
            {
                AddExpressionDataRecursively(m_ExpressionsData, exp);
            }
        }
        private void CompileExpressionContext(IEnumerable <VFXContext> contexts, VFXExpressionContextOption options, VFXDeviceTarget target)
        {
            HashSet <VFXExpression> expressions = new HashSet <VFXExpression>();
            var expressionContext = new VFXExpression.Context(options);

            var contextsToExpressions = target == VFXDeviceTarget.GPU ? m_ContextsToGPUExpressions : m_ContextsToCPUExpressions;
            var expressionsToReduced  = target == VFXDeviceTarget.GPU ? m_GPUExpressionsToReduced : m_CPUExpressionsToReduced;

            contextsToExpressions.Clear();
            expressionsToReduced.Clear();

            foreach (var context in contexts)
            {
                var mapper = context.GetExpressionMapper(target);
                if (mapper != null)
                {
                    foreach (var exp in mapper.expressions)
                    {
                        expressionContext.RegisterExpression(exp);
                    }
                    expressions.UnionWith(mapper.expressions);
                    contextsToExpressions.Add(context, mapper);
                }
            }

            expressionContext.Compile();

            foreach (var exp in expressionContext.RegisteredExpressions)
            {
                expressionsToReduced.Add(exp, expressionContext.GetReduced(exp));
            }

            m_Expressions.UnionWith(expressionContext.BuildAllReduced());

            foreach (var exp in expressionsToReduced.Values)
            {
                AddExpressionDataRecursively(m_ExpressionsData, exp);
            }
        }
Esempio n. 3
0
        private void CompileExpressionContext(IEnumerable <VFXContext> contexts,
                                              VFXExpressionContextOption options,
                                              VFXDeviceTarget target,
                                              VFXExpression.Flags forbiddenFlags = VFXExpression.Flags.None)
        {
            var expressionContext = new VFXExpression.Context(options, m_GlobalEventAttributes);

            var contextsToExpressions = target == VFXDeviceTarget.GPU ? m_ContextsToGPUExpressions : m_ContextsToCPUExpressions;
            var expressionsToReduced  = target == VFXDeviceTarget.GPU ? m_GPUExpressionsToReduced : m_CPUExpressionsToReduced;

            foreach (var context in contexts)
            {
                var mapper = context.GetExpressionMapper(target);
                if (mapper != null)
                {
                    foreach (var exp in mapper.expressions)
                    {
                        expressionContext.RegisterExpression(exp);
                    }
                    contextsToExpressions.Add(context, mapper);
                }
            }

            expressionContext.Compile();

            foreach (var exp in expressionContext.RegisteredExpressions)
            {
                var reduced = expressionContext.GetReduced(exp);
                if (expressionsToReduced.ContainsKey(exp))
                {
                    if (reduced != expressionsToReduced[exp])
                    {
                        throw new InvalidOperationException("Unexpected diverging expression reduction");
                    }
                    continue;
                }
                expressionsToReduced.Add(exp, reduced);
            }

            var allReduced = expressionContext.BuildAllReduced();

            m_Expressions.UnionWith(allReduced);

            foreach (var exp in expressionsToReduced.Values)
            {
                AddExpressionDataRecursively(m_ExpressionsData, exp);
            }

            var graphicsBufferUsageType = m_GraphicsBufferUsageType
                                          .Concat(expressionContext.GraphicsBufferUsageType)
                                          .GroupBy(o => o.Key).ToArray();

            m_GraphicsBufferUsageType.Clear();
            foreach (var expression in graphicsBufferUsageType)
            {
                var types = expression.Select(o => o.Value);
                if (types.Count() != 1)
                {
                    throw new InvalidOperationException("Diverging type usage for GraphicsBuffer : " + types.Select(o => o.ToString()).Aggregate((a, b) => a + b));
                }
                m_GraphicsBufferUsageType.Add(expression.Key, types.First());
            }
        }