Beispiel #1
0
 public void ForEachMaterial <T> (RefMaterialAction <T> action, ref T userData)
 {
     foreach (var material in Values)
     {
         action(material, ref userData);
     }
 }
Beispiel #2
0
        public void ForEachMaterial <T> (RefMaterialAction <T> action, ref T userData)
        {
            if (IsDisposed)
            {
                return;
            }

            lock (Lock) {
                if (MaterialCache.Count == 0)
                {
                    BuildMaterialCache();
                }

                foreach (var m in MaterialCache)
                {
                    action(m, ref userData);
                }
            }
        }
Beispiel #3
0
        public void ForEachMaterial <T> (RefMaterialAction <T> action, ref T userData)
        {
            foreach (var field in AllMaterialFields)
            {
                var material = field();
                if (material != null)
                {
                    action(material, ref userData);
                }
            }

            foreach (var collection in AllMaterialCollections)
            {
                var coll = collection();
                if (coll == null)
                {
                    continue;
                }

                coll.ForEachMaterial(action, ref userData);
            }
        }
Beispiel #4
0
        public DefaultMaterialSet(IServiceProvider serviceProvider)
        {
            _ApplyViewTransformDelegate = ApplyViewTransformToMaterial;
            _ApplyTimeDelegate          = ApplyTimeToMaterial;

            TimeProvider = (ITimeProvider)serviceProvider.GetService(typeof(ITimeProvider))
                           ?? new DotNetTimeProvider();

#if SDL2 // `Content/SquaredRender/` folder -flibit
            BuiltInShaders = new ContentManager(serviceProvider, "Content/SquaredRender");
#else
            BuiltInShaders = new ResourceContentManager(serviceProvider, Shaders.ResourceManager);
#endif

            Clear = new Material(
                null, null,
                new Action <DeviceManager>[] { (dm) => ApplyShaderVariables() }
                );


            var bitmapShader   = BuiltInShaders.Load <Effect>("SquaredBitmapShader");
            var geometryShader = BuiltInShaders.Load <Effect>("SquaredGeometryShader");

            ScreenSpaceBitmap = new Material(
                bitmapShader,
                "ScreenSpaceBitmapTechnique"
                );

            WorldSpaceBitmap = new Material(
                bitmapShader,
                "WorldSpaceBitmapTechnique"
                );

            ScreenSpaceShadowedBitmap = new Material(
                bitmapShader,
                "ScreenSpaceShadowedBitmapTechnique"
                );
            ScreenSpaceShadowedBitmap.Parameters.ShadowColor.SetValue(new Vector4(0, 0, 0, 1));
            ScreenSpaceShadowedBitmap.Parameters.ShadowOffset.SetValue(new Vector2(2, 2));

            WorldSpaceShadowedBitmap = new Material(
                bitmapShader,
                "WorldSpaceShadowedBitmapTechnique"
                );
            WorldSpaceShadowedBitmap.Parameters.ShadowColor.SetValue(new Vector4(0, 0, 0, 1));
            WorldSpaceShadowedBitmap.Parameters.ShadowOffset.SetValue(new Vector2(2, 2));

            ScreenSpaceBitmapWithDiscard = new Material(
                bitmapShader,
                "ScreenSpaceBitmapWithDiscardTechnique"
                );

            WorldSpaceBitmapWithDiscard = new Material(
                bitmapShader,
                "WorldSpaceBitmapWithDiscardTechnique"
                );

            ScreenSpaceGeometry = new Material(
                geometryShader,
                "ScreenSpaceUntextured"
                );

            WorldSpaceGeometry = new Material(
                geometryShader,
                "WorldSpaceUntextured"
                );

            var lightmapShader = BuiltInShaders.Load <Effect>("Lightmap");

            ScreenSpaceLightmappedBitmap = new Material(
                lightmapShader,
                "ScreenSpaceLightmappedBitmap"
                );

            WorldSpaceLightmappedBitmap = new Material(
                lightmapShader,
                "WorldSpaceLightmappedBitmap"
                );

            var blurShader = BuiltInShaders.Load <Effect>("GaussianBlur");

            ScreenSpaceHorizontalGaussianBlur5Tap = new Material(
                blurShader,
                "ScreenSpaceHorizontalGaussianBlur5Tap"
                );

            ScreenSpaceVerticalGaussianBlur5Tap = new Material(
                blurShader,
                "ScreenSpaceVerticalGaussianBlur5Tap"
                );

            WorldSpaceHorizontalGaussianBlur5Tap = new Material(
                blurShader,
                "WorldSpaceHorizontalGaussianBlur5Tap"
                );

            WorldSpaceVerticalGaussianBlur5Tap = new Material(
                blurShader,
                "WorldSpaceVerticalGaussianBlur5Tap"
                );

            var gds = serviceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
            if (gds != null)
            {
                ViewTransformStack.Push(ViewTransform.CreateOrthographic(
                                            gds.GraphicsDevice.PresentationParameters.BackBufferWidth,
                                            gds.GraphicsDevice.PresentationParameters.BackBufferHeight
                                            ));
            }
            else
            {
                ViewTransformStack.Push(ViewTransform.Default);
            }

            PreallocateBindings();
        }
Beispiel #5
0
        public DefaultMaterialSet(IServiceProvider serviceProvider)
        {
            _ApplyViewTransformDelegate = ApplyViewTransformToMaterial;

#if SDL2
            BuiltInShaders = new ContentManager(serviceProvider, "Content/SquaredRender");
#elif !PSM
            BuiltInShaders = new ResourceContentManager(serviceProvider, Shaders.ResourceManager);
#else
            BuiltInShaders = new Squared.Render.PSM.PSMShaderManager(serviceProvider);
#endif

            Clear = new DelegateMaterial(
                new NullMaterial(),
                new Action <DeviceManager>[] { (dm) => ApplyShaderVariables() },
                null
                );


#if PSM
            ScreenSpaceBitmap   = new EffectMaterial(BuiltInShaders.Load <Effect>("ScreenSpaceBitmap"));
            WorldSpaceBitmap    = new EffectMaterial(BuiltInShaders.Load <Effect>("WorldSpaceBitmap"));
            ScreenSpaceGeometry = new EffectMaterial(BuiltInShaders.Load <Effect>("ScreenSpaceGeometry"));
            WorldSpaceGeometry  = new EffectMaterial(BuiltInShaders.Load <Effect>("WorldSpaceGeometry"));
#elif SDL2
            ScreenSpaceBitmap = new EffectMaterial(
                BuiltInShaders.Load <Effect>("ScreenSpaceBitmapTechnique"),
                "ScreenSpaceBitmapTechnique"
                );

            WorldSpaceBitmap = new EffectMaterial(
                BuiltInShaders.Load <Effect>("WorldSpaceBitmapTechnique"),
                "WorldSpaceBitmapTechnique"
                );

            ScreenSpaceGeometry = new EffectMaterial(
                BuiltInShaders.Load <Effect>("ScreenSpaceUntextured"),
                "ScreenSpaceUntextured"
                );

            WorldSpaceGeometry = new EffectMaterial(
                BuiltInShaders.Load <Effect>("WorldSpaceUntextured"),
                "WorldSpaceUntextured"
                );
#else
            var bitmapShader   = BuiltInShaders.Load <Effect>("SquaredBitmapShader");
            var geometryShader = BuiltInShaders.Load <Effect>("SquaredGeometryShader");

            ScreenSpaceBitmap = new EffectMaterial(
                bitmapShader,
                "ScreenSpaceBitmapTechnique"
                );

            WorldSpaceBitmap = new EffectMaterial(
                bitmapShader,
                "WorldSpaceBitmapTechnique"
                );

            ScreenSpaceBitmapWithDiscard = new EffectMaterial(
                bitmapShader,
                "ScreenSpaceBitmapWithDiscardTechnique"
                );

            WorldSpaceBitmapWithDiscard = new EffectMaterial(
                bitmapShader,
                "WorldSpaceBitmapWithDiscardTechnique"
                );

            ScreenSpaceGeometry = new EffectMaterial(
                geometryShader,
                "ScreenSpaceUntextured"
                );

            WorldSpaceGeometry = new EffectMaterial(
                geometryShader,
                "WorldSpaceUntextured"
                );
#endif

#if SDL2
            ScreenSpaceLightmappedBitmap = new EffectMaterial(
                BuiltInShaders.Load <Effect>("ScreenSpaceLightmappedBitmap"),
                "ScreenSpaceLightmappedBitmap"
                );

            WorldSpaceLightmappedBitmap = new EffectMaterial(
                BuiltInShaders.Load <Effect>("WorldSpaceLightmappedBitmap"),
                "WorldSpaceLightmappedBitmap"
                );
#elif !PSM
            var lightmapShader = BuiltInShaders.Load <Effect>("Lightmap");

            ScreenSpaceLightmappedBitmap = new EffectMaterial(
                lightmapShader,
                "ScreenSpaceLightmappedBitmap"
                );

            WorldSpaceLightmappedBitmap = new EffectMaterial(
                lightmapShader,
                "WorldSpaceLightmappedBitmap"
                );

            var blurShader = BuiltInShaders.Load <Effect>("GaussianBlur");

            ScreenSpaceHorizontalGaussianBlur5Tap = new EffectMaterial(
                blurShader,
                "ScreenSpaceHorizontalGaussianBlur5Tap"
                );

            ScreenSpaceVerticalGaussianBlur5Tap = new EffectMaterial(
                blurShader,
                "ScreenSpaceVerticalGaussianBlur5Tap"
                );

            WorldSpaceHorizontalGaussianBlur5Tap = new EffectMaterial(
                blurShader,
                "WorldSpaceHorizontalGaussianBlur5Tap"
                );

            WorldSpaceVerticalGaussianBlur5Tap = new EffectMaterial(
                blurShader,
                "WorldSpaceVerticalGaussianBlur5Tap"
                );
#endif

            var gds = serviceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
            if (gds != null)
            {
                ViewTransformStack.Push(ViewTransform.CreateOrthographic(
                                            gds.GraphicsDevice.PresentationParameters.BackBufferWidth,
                                            gds.GraphicsDevice.PresentationParameters.BackBufferHeight
                                            ));
            }
            else
            {
                ViewTransformStack.Push(ViewTransform.Default);
            }
        }