Example #1
0
		public QuadRenderer(Renderer renderer, IShader shader)
		{
			this.renderer = renderer;
			this.shader = shader;
			vertices = new Vertex[renderer.TempBufferSize];
			renderAction = () => renderer.DrawBatch(vertices, nv, PrimitiveType.QuadList);
		}
Example #2
0
        /// <summary>
        /// This can only be created after an opengl context has been created.
        /// </summary>
        public GL33Renderable()
        {
            GL.GenVertexArrays(1, out VertexArrayObject);
            GL.BindVertexArray(VertexArrayObject);
            if(!GL.IsVertexArray(VertexArrayObject))
                throw new OpenGLException("Vertex array object could not be created!");
            VertexBufferObject = new int[3];
            GL.GenBuffers(3, VertexBufferObject);
            GL.BindBuffer(BufferTarget.ArrayBuffer, VertexBufferObject[0]);
            GL.BindBuffer(BufferTarget.ArrayBuffer, VertexBufferObject[1]);
            GL.BindBuffer(BufferTarget.ArrayBuffer, VertexBufferObject[2]);
            GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
            GL.BindVertexArray(0);

            if (!GL.IsBuffer(VertexBufferObject[0]) || !GL.IsBuffer(VertexBufferObject[1]) || !GL.IsBuffer(VertexBufferObject[2]))
                throw new OpenGLException("Vertex buffer object was not created!");

            Textures = new List<ITexture>();
            Uniform_To_Texture = new Dictionary<int, ITexture>();
            Position = new Vector3(0.0f, 0.0f, 0.0f);
            Rotation = new Quaternion();
            Scale = new Vector3(1.0f, 1.0f, 1.0f);
            TransformationMatrix = Matrix4.Identity;
            ModelViewMatrix = Matrix4.Identity;
            ProjectionMatrix = Matrix4.Identity;
            Shader = null;
        }
Example #3
0
		public void Stop()
		{
			_shakeShader = null;
			setActiveShader(_previousShader);
			var tcs = _taskCompletionSource;
			if (tcs != null) tcs.TrySetResult(null);
		}
 /// <summary>
 /// Initializes a new instance of the <see cref="ForwardMaterial"/> class.
 /// </summary>
 /// <param name="shader">The shader.</param>
 public ForwardMaterial(IShader shader)
 {
     System.Diagnostics.Debug.Assert(shader.MaterialType == Material.MaterialType.FORWARD);
     this.Shader = shader;
     CanAppearOfReflectionRefraction = true;
     CanCreateShadow = true;
     IsVisible = true;
 }
Example #5
0
		public void Start()
		{
			_previousShader = getActiveShader();
			_taskCompletionSource = new TaskCompletionSource<object> (null);
			_shakeShader = GLShader.FromText(VERTEX_SHADER_SHAKE, FRAGMENT_SHADER_STANDARD, _graphics);
			AGSGame.Game.Events.OnBeforeRender.Subscribe(onBeforeRender);
			setActiveShader(_shakeShader);
		}
Example #6
0
        public SpriteRenderer(Renderer renderer, bool allowAlpha, IShader shader)
        {
            this.renderer = renderer;
            this.shader = shader;

            vertexBuffer = renderer.Device.CreateVertexBuffer( vertices.Length );
            indexBuffer = renderer.Device.CreateIndexBuffer( indices.Length );
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="ForwardMaterial"/> class.
 /// </summary>
 /// <param name="shader">The shader.</param>
 public DeferredMaterial(IShader shader)
 {
     System.Diagnostics.Debug.Assert(shader != null);            
     System.Diagnostics.Debug.Assert(shader.MaterialType == Material.MaterialType.DEFERRED);
     this.Shader = shader;
     CanAppearOfReflectionRefraction = true;
     CanCreateShadow = true;
     IsVisible = true;
 }
Example #8
0
        public VoxelRenderer(Renderer renderer, IShader shader)
        {
            this.renderer = renderer;
            this.shader = shader;

            mappedBuffers = new Dictionary<Sheet, IFrameBuffer>();
            unmappedBuffers = new Stack<KeyValuePair<Sheet, IFrameBuffer>>();
            doRender = new List<Pair<Sheet, Action>>();
        }
Example #9
0
 /// <summary>
 /// Creates an environment object.
 /// </summary>
 public Environment()
 {
     fogStartDistance = -1;
     fogEndDistance = -1;
     fogEnabled = false;
     fogColor = Color.White.ToVector4();
     tmpMat1 = Matrix.Identity;
     shader = new SimpleEffectShader();
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="ForwardMaterial"/> class.
 /// </summary>
 /// <param name="shader">The shader.</param>
 public ClothMaterial(IShader shader)
 {
     this.Shader = shader;
     CanAppearOfReflectionRefraction = true;
     CanCreateShadow = true;
     IsVisible = true;
     rasterizerState = new RasterizerState();
     rasterizerState.CullMode = CullMode.None;
 }
Example #11
0
		public LineRenderer(Renderer renderer, IShader shader)
		{
			this.renderer = renderer;
			this.shader = shader;
			vertices = new Vertex[renderer.TempBufferSize];
			renderAction = () =>
			{
				renderer.SetLineWidth(LineWidth);
				renderer.DrawBatch(vertices, nv, PrimitiveType.LineList);
			};
		}
 /// <summary>
 /// Initializes a new instance of the <see cref="ForwardMaterial"/> class.
 /// </summary>
 /// <param name="shader">The shader.</param>
 public FluidMaterial(IShader shader, int maxParticles, Microsoft.Xna.Framework.Vector2 scale)
 {
     this.Shader = shader;
     CanAppearOfReflectionRefraction = false;
     CanCreateShadow = false;
     IsVisible = true;
     BilboardInstance = new BilboardInstance[maxParticles];
     for (int i = 0; i < maxParticles; i++)
     {
         BilboardInstance[i] = new BilboardInstance();
         BilboardInstance[i].Scale = scale;
     }
 }
Example #13
0
        public IResultSet Compile(IShader shader, IBackendOptions options)
        {
            if ( !(shader is GLSLShader ) )
                return null;

            GLSLShader sh = (GLSLShader)shader;
            IGLSLOptions glOpts = sh.CompileOptions;
            if (glOpts.OptimizerOptions == null)
                return null;

            GLSLOptimizer.IOptimizer optimizer = m_Optimizers[glOpts.OptimizerTarget];
            return new GLSLOptimizerResultSet( optimizer.Optimize(sh.Code, glOpts.OptimizerOptions) );
        }
Example #14
0
        public IResultSet Compile(IShader shaderObj, IBackendOptions options)
        {
            if ( !(shaderObj is HLSLShader ) )
                return null;

            HLSLShader shaderHLSL = shaderObj as HLSLShader;
            IHLSLOptions hlslOpts = shaderHLSL.CompileOptions;
            AMDDriverBackendOptions backendOptions = options as AMDDriverBackendOptions;
            string shader = shaderObj.Code;

            if (shaderHLSL.WasCompiledWithErrors)
                return null;

            try
            {
                // compile here if we must.  Recycle existing blob if we can
                IDXShaderBlob blob = shaderHLSL.CompiledBlob;
                if ( blob == null )
                {
                    if (!shaderHLSL.Compile(m_FXC))
                        return null;
                    blob = shaderHLSL.CompiledBlob;
                }

                IDXShaderReflection reflect = blob.Reflect();

                IDXShaderBlob exe = blob.GetExecutableBlob();
                if (exe == null)
                    return null;

                byte[] bytes = exe.ReadBytes();

                AMDDriverResultSet rs = new AMDDriverResultSet(reflect );

                foreach (IAMDAsic a in m_Driver.Asics)
                {
                    if (CompileForAsic(backendOptions.Asics, a.Name))
                    {
                        IAMDShader sh = m_Driver.CompileDXBlob(a, bytes, reflect);
                        rs.Add(sh);
                    }
                }

                return rs;
            }
            catch( System.Exception ex )
            {
                MessageBox.Show(ex.Message);
                return null;
            }
        }
Example #15
0
        public void Add(IShader shader)
        {
            /*if (_shaders.Any())
            {
                shader.Content = _shaders.Last();
            }
            else
            {
                shader.Content = this;
            }*/

            _shaders.Add(shader);
            shader.Load();
        }
Example #16
0
        public IResultSet Compile(IShader shader, IBackendOptions options)
        {
            if (!(shader is GLSLShader) )
                return null;

            GLSLShader sh = (GLSLShader)shader;
            IGLSLOptions glOpts = sh.CompileOptions;

            GLSlangOptions slangOpts = new GLSlangOptions();
            slangOpts.ShaderType = glOpts.ShaderType;
            slangOpts.Config = m_Config;
            GLSlang.IShader result = m_Compiler.Compile(sh.Code, slangOpts);
            return new GLSLangResultSet(result);
        }
Example #17
0
 public static Instance createTemporary(PrimitiveList primitives, Matrix4 transform, IShader shader)
 {
     Instance i = new Instance();
     i.o2w = new MovingMatrix4(transform);
     i.w2o = i.o2w.inverse();
     if (i.w2o == null) {
         UI.printError(UI.Module.GEOM, "Unable to compute transform inverse");
         return null;
     }
     i.geometry = new Geometry(primitives);
     i.shaders = new IShader[] { shader };
     i.updateBounds();
     return i;
 }
Example #18
0
        public IResultSet Compile(IShader shader, IBackendOptions options)
        {
            if (!(shader is HLSLShader ) )
                return null;

            HLSLShader hlsl       = (HLSLShader)shader;
            IHLSLOptions hlslOpts = hlsl.CompileOptions;
            string text = hlsl.Code;

            if (!hlsl.WasCompiled)
                hlsl.Compile(m_Compiler);

            return new FXCResultSet(hlsl.Messages, hlsl.CompiledBlob);
        }
Example #19
0
        public BufferLayout(IDisposableResource parent, IShader shader, IBufferLayoutDesc desc)
            : base(parent)
        {
            video = parent.FindParentOrSelfWithException<Video>();
            this.shader = (Shader)shader;
            enabledStreamIndices = new bool[2];

            streamBytesSizes = desc.StreamBytesSizes;
            layout = ((BufferLayoutDesc)desc).desc;
            attribLocations = new int[layout.Length];
            for (int i = 0; i != layout.Length; ++i)
            {
                attribLocations[i] = GL.GetAttribLocation(this.shader.program, layout[i].Name);
                Video.checkForError();
            }
        }
Example #20
0
        public LightServer(Scene scene)
        {
            this.scene = scene;
            lights = new LightSource[0];
            causticPhotonMap = null;

            shaderOverride = null;
            shaderOverridePhotons = false;

            maxDiffuseDepth = 1;
            maxReflectionDepth = 4;
            maxRefractionDepth = 4;

            causticPhotonMap = null;
            giEngine = null;
        }
Example #21
0
        public BufferLayout(IDisposableResource parent, IShader shader, IBufferLayoutDesc desc)
            : base(parent)
        {
            try
            {
                var video = parent.FindParentOrSelfWithException<Video>();
                com = new BufferLayoutCom();
                var error = com.Init(video.com, ((Shader)shader).vertex.com, ((BufferLayoutDesc)desc).com);

                if (error == BufferLayoutErrors.InputLayout) Debug.ThrowError("BufferLayout", "Failed to create InputLayout");
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Example #22
0
        /// <summary>
        /// Initializes the render object</summary>
        /// <returns>true, iff initialization was successful</returns>
        public override bool Init(SceneNode node)
        {
            IMesh mesh = TryGetMesh();

            if (mesh != null)
            {
                m_bindingCount = m_primitives.BindingCount;

                // determine primitive type
                if (m_primitives.PrimitiveType == "POLYGONS")
                {
                    m_drawMode = Gl.GL_POLYGON;
                }
                else if (m_primitives.PrimitiveType == "TRIANGLES")
                {
                    m_drawMode = Gl.GL_TRIANGLES;
                }
                else if (m_primitives.PrimitiveType == "TRISTRIPS")
                {
                    m_drawMode = Gl.GL_TRIANGLE_STRIP;
                }

                // add draw commands
                AddCommand(NormalsTag, Function.glNormal3fv);
                AddCommand(TextureCoordinatesTag, Function.glTexCoord2fv);
                AddCommand(ColorsTag, Function.glColor3fv);
                AddCommand(VerticesTag, Function.glVertex3fv);

                // get the shader
                IShader             shader             = m_primitives.Shader;
                IRenderStateCreator renderStateCreator = null;
                if (shader != null)
                {
                    renderStateCreator = shader.As <IRenderStateCreator>();
                }

                if (renderStateCreator != null)
                {
                    RenderState renderState = renderStateCreator.CreateRenderState();
                    node.StateStack.Push(renderState);
                }
            }

            return(true);
        }
Example #23
0
        public static IShader New(VideoTypes videoType, IDisposableResource parent, string filename, ShaderVersions shaderVersion, ShaderFloatingPointQuality vsQuality, ShaderFloatingPointQuality psQuality, Loader.LoadedCallbackMethod loadedCallback)
        {
            IShader api = null;

                        #if WIN32
            if (videoType == VideoTypes.D3D9)
            {
                api = new D3D9.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback);
            }
                        #endif

                        #if WIN32 || WINRT || WP8
            if (videoType == VideoTypes.D3D11)
            {
                api = new D3D11.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback);
            }
                        #endif

                        #if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl
            if (videoType == VideoTypes.OpenGL)
            {
                api = new OpenGL.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback);
            }
            #endif

            #if XNA
            if (videoType == VideoTypes.XNA)
            {
                api = new XNA.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback);
            }
            #endif

            #if VITA
            if (videoType == VideoTypes.Vita)
            {
                api = new Vita.Shader(parent, filename, shaderVersion, vsQuality, psQuality, loadedCallback);
            }
            #endif

            if (api == null)
            {
                Debug.ThrowError("ShaderAPI", "Unsuported InputType: " + videoType);
            }
            return(api);
        }
Example #24
0
        public TerrainShader(IOpenGL33 gl)
        {
            vertexShader = new VertexShader(gl, GetEmbeddedResourceAsString("VertexShader.vs"));
            fragmentShader = new FragmentShader(gl, GetEmbeddedResourceAsString("FragmentShader.fs"));
            var p = new ModGL.ObjectModel.Shaders.Program(gl, vertexShader, fragmentShader);

            p.BindVertexAttributeLocations(PositionNormalTexCoord.Descriptor);
            // Bind output fragment to the specified nme
            gl.BindFragDataLocation(p.Handle, 0, "Color");
            // Compile program and shaders
            p.Compile();
            program = p;
            // Get the uniforms used by the shader program.
            diffuseUniform = p.GetUniform<Vector4fUniform, Vector4f>("DiffuseColor");
            modelViewProjection = p.GetUniform<MatrixUniform, Matrix4f>("ModelViewProjection");
            viewProjection = p.GetUniform<MatrixUniform, Matrix4f>("ViewProjection");
            textureUnitUniform = p.GetUniform<IntUniform, int>("Texture");
        }
Example #25
0
 GLSlang.IShader CompileShader(IShader shader)
 {
     if (shader is HLSLShader)
     {
         // pass the shader through GLSLang's hlsl front end
         HLSLShader hlsl = shader as HLSLShader;
         return(m_GLSLang.CompileHLSL(shader.Code, hlsl.CompileOptions, m_GLSLangConfig, shader.SourceFilePath));
     }
     else if (shader is GLSLShader)
     {
         GLSLShader glsl = shader as GLSLShader;
         return(m_GLSLang.Compile(shader.Code, glsl.CompileOptions.ShaderType, m_GLSLangConfig, glsl.SourceFilePath));
     }
     else
     {
         throw new System.Exception("Bad shader type?!?");
     }
 }
Example #26
0
 int iShaderCache.tryLoadShader(ref Guid guid, out IShader shader)
 {
     shader = null;
     try
     {
         Payload p = lookupInCache(guid);
         if (null == p)
         {
             return(1);                      // S_FALSE
         }
         shader = loadShader(ref guid, p);
         return(0);                  // S_OK
     }
     catch (Exception ex)
     {
         return(ex.HResult);
     }
 }
Example #27
0
 public Font(IDisposableResource parent, IShader shader, ITexture2D texture, string metricsFileName, Loader.LoadedCallbackMethod loadedCallback)
     : base(parent)
 {
     new StreamLoader(metricsFileName,
     delegate(object sender, bool succeeded)
     {
         if (succeeded)
         {
             init(shader, texture, ((StreamLoader)sender).LoadedStream, metricsFileName, loadedCallback);
         }
         else
         {
             FailedToLoad = true;
             Dispose();
             if (loadedCallback != null) loadedCallback(this, false);
         }
     });
 }
Example #28
0
        private void onBeforeRender()
        {
            var shader = _shader;

            if (shader != null)
            {
                shader = shader.Compile();
            }
            if (shader == null || shader != getActiveShader())
            {
                _shader = null;
                AGSGame.Game.Events.OnBeforeRender.Unsubscribe(onBeforeRender);
                return;
            }
            shader.Bind();
            shader.SetVariable("adjustment", Saturation);
            shader.Unbind();
        }
Example #29
0
        public IResultSet Compile(IShader shader, IBackendOptions options)
        {
            if (!(shader is HLSLShader))
            {
                return(null);
            }

            HLSLShader   hlsl     = (HLSLShader)shader;
            IHLSLOptions hlslOpts = hlsl.CompileOptions;
            string       text     = hlsl.Code;

            if (!hlsl.WasCompiled)
            {
                hlsl.Compile(m_Compiler);
            }

            return(new FXCResultSet(hlsl.Messages, hlsl.CompiledBlob));
        }
Example #30
0
        public IResultSet Compile(IShader shader, IBackendOptions options)
        {
            if (!(shader is GLSLShader))
            {
                return(null);
            }

            GLSLShader   sh     = (GLSLShader)shader;
            IGLSLOptions glOpts = sh.CompileOptions;

            if (glOpts.OptimizerOptions == null)
            {
                return(null);
            }

            GLSLOptimizer.IOptimizer optimizer = m_Optimizers[glOpts.OptimizerTarget];
            return(new GLSLOptimizerResultSet(optimizer.Optimize(sh.Code, glOpts.OptimizerOptions)));
        }
Example #31
0
        public LightServer(Scene scene)
        {
            this.scene       = scene;
            lights           = new LightSource[0];
            causticPhotonMap = null;

            shaderOverride        = null;
            shaderOverridePhotons = false;

            maxDiffuseDepth    = 1;
            maxReflectionDepth = 4;
            maxRefractionDepth = 4;

            causticPhotonMap = null;
            giEngine         = null;

            shadingCache(0);
        }
        private void load(ShaderManager shaders, IBindable <WorkingBeatmap> beatmap, SentakkiRulesetConfigManager settings)
        {
            this.beatmap.BindTo(beatmap);
            shader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);

            settings?.BindWith(SentakkiRulesetSettings.KiaiEffects, kiaiEffect);
            kiaiEffect.BindValueChanged(k =>
            {
                if (k.NewValue)
                {
                    this.FadeIn(200);
                }
                else
                {
                    this.FadeOut(500);
                }
            });
        }
            public override void ApplyState()
            {
                base.ApplyState();

                screenSpaceDrawRectangle = Source.ScreenSpaceDrawQuad.AABBFloat;
                filteringMode            = Source.PixelSnapping ? All.Nearest : All.Linear;

                updateVersion    = Source.updateVersion;
                backgroundColour = Source.BackgroundColour;

                BlendingParameters localEffectBlending = Source.EffectBlending;

                if (localEffectBlending.Mode == BlendingMode.Inherit)
                {
                    localEffectBlending.Mode = Source.Blending.Mode;
                }

                if (localEffectBlending.RGBEquation == BlendingEquation.Inherit)
                {
                    localEffectBlending.RGBEquation = Source.Blending.RGBEquation;
                }

                if (localEffectBlending.AlphaEquation == BlendingEquation.Inherit)
                {
                    localEffectBlending.AlphaEquation = Source.Blending.AlphaEquation;
                }

                effectColour    = Source.EffectColour;
                effectBlending  = localEffectBlending;
                effectPlacement = Source.EffectPlacement;

                drawOriginal = Source.DrawOriginal;
                blurSigma    = Source.BlurSigma;
                blurRadius   = new Vector2I(Blur.KernelSize(blurSigma.X), Blur.KernelSize(blurSigma.Y));
                blurRotation = Source.BlurRotation;

                formats.Clear();
                formats.AddRange(Source.attachedFormats);

                blurShader = Source.blurShader;

                // BufferedContainer overrides DrawColourInfo for children, but needs to be reset to draw ourselves
                DrawColourInfo = Source.baseDrawColourInfo;
            }
Example #34
0
        public override void Draw(Action <TexturedVertex2D> vertexAction)
        {
            base.Draw(vertexAction);

            if (Texture?.Available != true)
            {
                return;
            }

            IShader shader = needsRoundedShader ? RoundedTextureShader : TextureShader;

            shader.Bind();

            Texture.TextureGL.WrapMode = WrapTexture ? TextureWrapMode.Repeat : TextureWrapMode.ClampToEdge;

            Blit(vertexAction);

            shader.Unbind();
        }
Example #35
0
        public override void SetupShader(IShader shader)
        {
            base.SetupShader(shader);

            if (shader is ISourceRectShader sourceRectShader)
            {
                sourceRectShader.SourceRect.SetValue(Texture.SourceRectangle.ToVector());
            }

            if (shader is ITextureShader textureShader)
            {
                textureShader.Texture.SetValue(Texture.GLTexture);
            }

            if (shader is IOffsetShader offsetShader)
            {
                offsetShader.Offset.SetValue(Offset);
            }
        }
Example #36
0
        public void SetSampler(IShader shader, string name, ISampler sampler)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }
            if (sampler == null)
            {
                throw new ArgumentNullException("sampler");
            }
            if (shader == null)
            {
                throw new ArgumentNullException("shader");
            }

            var internalShader = graphicsDevice.Cast <Shader>(shader, "shader");

            graphicsDevice.BindManager.SetSampler(sampler, internalShader.GetTextureUnit(name));
        }
Example #37
0
 private void addShadingCache(ShadingState state, IShader shader, Color c)
 {
     lock (lockObj)
     {
         // don't cache samples with null normals
         if (state.getNormal() == null)
         {
             return;
         }
         cacheEntryAdditions++;
         int        cx = (int)(state.getRasterX() * shadingCacheResolution);
         int        cy = (int)(state.getRasterY() * shadingCacheResolution);
         int        h  = hashfunc(cx, cy) & (_shadingCache.Length - 1);
         CacheEntry e  = _shadingCache[h];
         // new entry ?
         if (e == null)
         {
             e = _shadingCache[h] = new CacheEntry();
         }
         Sample s = new Sample();
         s.i = state.getInstance();
         // s.prim = state.getPrimitiveID();
         s.s  = shader;
         s.c  = c;
         s.nx = state.getNormal().x;
         s.ny = state.getNormal().y;
         s.nz = state.getNormal().z;
         if (e.cx == cx && e.cy == cy)
         {
             // same pixel - just add to the front of the list
             s.next  = e.first;
             e.first = s;
         }
         else
         {
             // different pixel - new list
             e.cx    = cx;
             e.cy    = cy;
             s.next  = null;
             e.first = s;
         }
     }
 }
Example #38
0
        public void SetTexture(IShader shader, string name, ITexture2DArray texture)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }
            if (texture == null)
            {
                throw new ArgumentNullException("texture");
            }
            if (shader == null)
            {
                throw new ArgumentNullException("shader");
            }

            var internalShader = graphicsDevice.Cast <Shader>(shader, "shader");

            graphicsDevice.BindManager.SetTexture(texture, internalShader.GetTextureUnit(name));
        }
Example #39
0
        private void SetTexture(IShader shader, string name, ShaderResourceView view)
        {
            if (shader != currentState.Shader)
            {
                throw new ArgumentException("Shader does not match current set shader.", "shader");
            }

            var dxShader = graphicsDevice.Cast <Shader>(shader, "shader");
            int slot;

            if (dxShader.TryGetSlotVertex(name, out slot))
            {
                SetTexture(Context.VertexShader, vertexCache, slot, view);
            }
            if (dxShader.TryGetSlotPixel(name, out slot))
            {
                SetTexture(Context.PixelShader, pixelCache, slot, view);
            }
        }
Example #40
0
        public override void SetupShader(IShader shader)
        {
            base.SetupShader(shader);

            if (shader is ITextureIndexShader textureIndexShader)
            {
                textureIndexShader.TextureIndex.Setup(VertexBuffer, TextVertex.TextureIndexOffset);
            }

            if (shader is IPosition2Shader positionShader)
            {
                positionShader.Position.Setup(VertexBuffer, TextVertex.PositionOffset);
            }

            if (shader is ITexCoordShader texCoordShader)
            {
                texCoordShader.TexCoord.Setup(VertexBuffer, TextVertex.TexCoordOffset);
            }
        }
Example #41
0
        private void activateShader()
        {
            var shader = AGSGame.Shader;

            if (shader != null)
            {
                shader = shader.Compile();
            }
            if (shader == null)
            {
                if (_lastShaderUsed != null)
                {
                    _lastShaderUsed.Unbind();
                }
                return;
            }
            _lastShaderUsed = shader;
            shader.Bind();
        }
Example #42
0
        protected virtual void Initialize()
        {
            textureName                = null;
            duration                   = TimeSpan.FromSeconds(1);
            durationRandomness         = 0;
            emitterVelocitySensitivity = 1;
            minHorizontalVelocity      = 0;
            maxHorizontalVelocity      = 0;
            minVerticalVelocity        = 0;
            maxVerticalVelocity        = 0;
            gravity        = new Vector3();
            endVelocity    = 1;
            minColor       = Color.White;
            maxColor       = Color.White;
            minRotateSpeed = 0;
            maxRotateSpeed = 0;
            minStartSize   = 100;
            maxStartSize   = 100;
            minEndSize     = 100;
            maxEndSize     = 100;
            blendState     = BlendState.NonPremultiplied;
            currentTime    = 0;
            drawOrder      = 0;

            up      = Vector3.UnitY;
            right   = Vector3.UnitX;
            forward = Vector3.UnitZ;

            // Allocate the particle array, and fill in the corner fields (which never change).
            particles = new ParticleVertex[maxParticles * 4];

            for (int i = 0; i < maxParticles; i++)
            {
                particles[i * 4 + 0].Corner = new Short2(-1, -1);
                particles[i * 4 + 1].Corner = new Short2(1, -1);
                particles[i * 4 + 2].Corner = new Short2(1, 1);
                particles[i * 4 + 3].Corner = new Short2(-1, 1);
            }

            shader          = new ParticleShader();
            shaderTechnique = "Particles";
            enabled         = true;
        }
Example #43
0
        public static void Triangle(Image image, Vec4f [] pts, IShader shader, float [] zbuffer)
        {
            Vec2i pMin, pMax;

            Box(pts, out pMin, out pMax);

            Color color;

            for (int x = pMin.x; x <= pMax.x; x++)
            {
                for (int y = pMin.y; y <= pMax.y; y++)
                {
                    var pixelCenter = new Vec2f {
                        x = x + 0.5f, y = y + 0.5f
                    };
                    var bc = Barycentric(Project2D(pts [0] / pts [0].h),
                                         Project2D(pts [1] / pts [1].h),
                                         Project2D(pts [2] / pts [2].h),
                                         pixelCenter);

                    var z          = pts [0].z * bc.x + pts [1].z * bc.y + pts [2].z * bc.z;            // z [0..255]
                    var w          = pts [0].h * bc.x + pts [1].h * bc.y + pts [2].h * bc.z;
                    var frag_depth = z / w;

                    var idx = x + y * image.Width;
                    if (bc.x < 0 || bc.y < 0 || bc.z < 0 || zbuffer[idx] > frag_depth)
                    {
                        continue;
                    }


                    var discard = shader.Fragment(new Vec3f {
                        x = x, y = y, z = frag_depth
                    }, bc, out color);
                    if (!discard)
                    {
                        zbuffer [idx] = frag_depth;
                        image [x, y]  = color;
                    }
                }
            }
        }
Example #44
0
 public CubeShader(IOpenGL30 gl)
 {
     // Create the vertex shader
     vertexShader = new VertexShader(gl, GetEmbeddedResourceAsString("cube.vs"));
     // Create the fragmet shader
     fragmentShader = new FragmentShader(gl, GetEmbeddedResourceAsString("cube.fs"));
     // Create the program for both shaders
     var p = new ModGL.ObjectModel.Shaders.Program(gl, vertexShader, fragmentShader);
     // Tell the shader what field names to use (taken from the vertex Descriptor)
     p.BindVertexAttributeLocations(PositionNormalTexCoord.Descriptor);
     // Bind output fragment to the specified nme
     gl.BindFragDataLocation(p.Handle, 0, "Color");
     // Compile program and shaders
     p.Compile();
     program = p;
     // Get the uniforms used by the shader program.
     modelViewProjection = p.GetUniform<MatrixUniform, Matrix4f>("ModelViewProjection");
     viewProjection = p.GetUniform<MatrixUniform, Matrix4f>("ViewProjection");
     diffuseUniform = p.GetUniform<Vector4fUniform, Vector4f>("DiffuseColor");
 }
Example #45
0
        public BufferLayout(IDisposableResource parent, IShader shader, IBufferLayoutDesc desc)
            : base(parent)
        {
            try
            {
                var video = parent.FindParentOrSelfWithException <Video>();
                com = new BufferLayoutCom();
                var error = com.Init(video.com, ((Shader)shader).vertex.com, ((BufferLayoutDesc)desc).com);

                if (error == BufferLayoutErrors.InputLayout)
                {
                    Debug.ThrowError("BufferLayout", "Failed to create InputLayout");
                }
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Example #46
0
        static RenderResult Render(Model model, IShader shader)
        {
            var image         = new Image(width, height, Format.BGR);
            var zbuffer       = InitZBuffer(image);
            var screen_coords = new Vec4f [3];

            foreach (var face in model.Faces)
            {
                for (int i = 0; i < 3; i++)
                {
                    screen_coords [i] = shader.Vertex(face, i);
                }
                Triangle(image, screen_coords, shader, zbuffer);
            }

            return(new RenderResult {
                Image = image,
                ZBuffer = zbuffer
            });
        }
Example #47
0
            public override void ApplyState()
            {
                base.ApplyState();

                shader     = Source.shader;
                texture    = Source.texture;
                drawSize   = Source.DrawSize;
                points     = Source.ResampledWaveform?.GetPoints();
                channels   = Source.ResampledWaveform?.GetChannels() ?? 0;
                lowColour  = Source.lowColour ?? DrawColourInfo.Colour;
                midColour  = Source.midColour ?? DrawColourInfo.Colour;
                highColour = Source.highColour ?? DrawColourInfo.Colour;

                if (points?.Any() == true)
                {
                    highMax = points.Max(p => p.HighIntensity);
                    midMax  = points.Max(p => p.MidIntensity);
                    lowMax  = points.Max(p => p.LowIntensity);
                }
            }
Example #48
0
        /// <summary>
        /// Initializes the 2D rendering system
        /// </summary>
        internal static void Init()
        {
            ProfilerTimer.Profile(() =>
            {
                rendererData = new Renderer2DStorage
                {
                    QuadVertexArray = IVertexArray.Create()
                };

                float[] squareVertices =
                {
                    -0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
                    0.5f,  -0.5f, 0.0f, 1.0f, 0.0f,
                    0.5f,   0.5f, 0.0f, 1.0f, 1.0f,
                    -0.5f,  0.5f, 0.0f, 0.0f, 1.0f
                };

                IVertexBuffer squareVertexBuffer = IVertexBuffer.Create(squareVertices, squareVertices.GetBytes());

                BufferLayout squareBufferLayout = new BufferLayout(new[]
                {
                    new BufferElement("a_Position", ShaderDataType.Float3),
                    new BufferElement("a_TexCoord", ShaderDataType.Float2)
                });
                squareVertexBuffer.SetLayout(squareBufferLayout);
                rendererData.QuadVertexArray.AddVertexBuffer(squareVertexBuffer);

                uint[] squareIndices           = { 0, 1, 2, 2, 3, 0 };
                IIndexBuffer squareIndexBuffer =
                    IIndexBuffer.Create(squareIndices, squareIndices.GetBytes() / sizeof(uint));
                rendererData.QuadVertexArray.SetIndexBuffer(squareIndexBuffer);

                rendererData.WhiteTexture = I2DTexture.Create(1, 1);
                uint whiteTextureData     = 0xffffffff;
                rendererData.WhiteTexture.SetData(whiteTextureData, sizeof(uint));

                rendererData.TextureShader = IShader.Create("Shaders/Texture.glsl");
                rendererData.TextureShader.Bind();
                rendererData.TextureShader.SetInt("u_Texture", 0);
            });
        }
Example #49
0
        public BufferLayout(IDisposableResource parent, IShader shader, IBufferLayoutDesc desc)
            : base(parent)
        {
            try
            {
                var video = parent.FindParentOrSelfWithException<Video>();

                com = new BufferLayoutCom();
                var error = com.Init(video.com, ((BufferLayoutDesc)desc).com);

                switch (error)
                {
                    case BufferLayoutErrors.VertexDeclaration: Debug.ThrowError("BufferLayout", "Failed to create vertex declaration"); break;
                }
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Example #50
0
        private void onBeforeRender()
        {
            var shader = _shakeShader;

            if (shader != null)
            {
                shader = shader.Compile();
            }
            if (shader == null || shader != getActiveShader())
            {
                _shakeShader = null;
                AGSGame.Game.Events.OnBeforeRender.Unsubscribe(onBeforeRender);
                return;
            }
            shader.Bind();
            shader.SetVariable("time", (float)Repeat.Do("ShakeEffect"));
            var currentStrength = _strength + MathUtils.Random().Next(1000) / 1000000f;             //Adding a little jerkiness

            shader.SetVariable("strength", currentStrength);
            _strength = _strength * _decay;
        }
Example #51
0
        /// <summary>Construct the object and create the required GPU resources</summary>
        public CursorRenderer(Context context, IRenderDevice device)
        {
            this.context = context;
            vertexBuffer = createVertexBuffer(device);

            iShaderFactory shaderFactory = device.GetShaderFactory();
            iStorageFolder assets        = StorageFolder.embeddedResources(Assembly.GetExecutingAssembly(), resourceFolder);
            IShader        vs            = shaderFactory.compileHlslFile(assets, "CursorVS.hlsl", ShaderType.Vertex);

            using (iPipelineStateFactory stateFactory = device.CreatePipelineStateFactory())
            {
                staticCursor     = new StaticCursor(context, device, stateFactory, shaderFactory, assets, vs);
                animatedCursor   = new AnimatedCursor(context, device, stateFactory, shaderFactory, assets);
                monochromeCursor = new MonoCursor(context, device, stateFactory, shaderFactory, assets, vs);
            }

            cursorPosition.setWindowSize(context.swapChainSize);

            // Subscribe to the resized event
            context.swapChainResized.add(this, onSwapChainResized);
        }
Example #52
0
        public void LoadContent(ContentState state)
        {
            this.texture = state.Load<Texture2D>("skydome/cloudMap");
            this.model.ModelData = state.Load<ModelData>("skydome/dome");

            MaterialShader material = new MaterialShader();

            material.SpecularColour = new Vector3(1, 1, 1);
            material.DiffuseColour = new Vector3(0.6f, 0.6f, 0.6f);
            material.SpecularPower = 64;

            MaterialTextures textures = new MaterialTextures();
            textures.TextureMap = state.Load<Texture2D>("skydome/cloudMap");
            textures.TextureMapSampler = TextureSamplerState.AnisotropicHighFiltering;
            textures.EmissiveTextureMapSampler = TextureSamplerState.AnisotropicHighFiltering;
            textures.NormalMapSampler = TextureSamplerState.AnisotropicHighFiltering;

            material.Textures = textures;

            this.shader = material;
        }
Example #53
0
 public void set(ShadingState state)
 {
     if (state == null)
     {
         c = Color.BLACK;
     }
     else
     {
         c = state.getResult();
         checkNanInf();
         shader   = state.getShader();
         instance = state.getInstance();
         if (state.getNormal() != null)
         {
             nx = state.getNormal().x;
             ny = state.getNormal().y;
             nz = state.getNormal().z;
         }
     }
     n = 1;
 }
Example #54
0
        public BufferLayout(IDisposableResource parent, IShader shader, IBufferLayoutDesc desc)
            : base(parent)
        {
            try
            {
                var video = parent.FindParentOrSelfWithException <Video>();

                com = new BufferLayoutCom();
                var error = com.Init(video.com, ((BufferLayoutDesc)desc).com);

                switch (error)
                {
                case BufferLayoutErrors.VertexDeclaration: Debug.ThrowError("BufferLayout", "Failed to create vertex declaration"); break;
                }
            }
            catch (Exception e)
            {
                Dispose();
                throw e;
            }
        }
Example #55
0
 public Font(IDisposableResource parent, IShader shader, ITexture2D texture, string metricsFileName, Loader.LoadedCallbackMethod loadedCallback)
     : base(parent)
 {
     new StreamLoader(metricsFileName,
                      delegate(object sender, bool succeeded)
     {
         if (succeeded)
         {
             init(shader, texture, ((StreamLoader)sender).LoadedStream, metricsFileName, loadedCallback);
         }
         else
         {
             FailedToLoad = true;
             Dispose();
             if (loadedCallback != null)
             {
                 loadedCallback(this, false);
             }
         }
     });
 }
Example #56
0
        public void add(ShadingState state, IShader shader, Color c)
        {
            if (state.getNormal() == null)
            {
                return;
            }
            depth++;
            Sample s = new Sample();

            s.i    = state.getInstance();
            s.s    = shader;
            s.c    = c;
            s.dx   = state.getRay().dx;
            s.dy   = state.getRay().dy;
            s.dz   = state.getRay().dz;
            s.nx   = state.getNormal().x;
            s.ny   = state.getNormal().y;
            s.nz   = state.getNormal().z;
            s.next = first;
            first  = s;
        }
Example #57
0
 public LineRenderer( Renderer renderer, IShader shader )
 {
     this.renderer = renderer;
     this.shader = shader;
 }
        public void Create()
        {
            _vertexShader = _openGlResourceFactory.CreateShader(ShaderType.VertexShader);
            _vertexShader.SetSource(VertexShaderSource);
            _vertexShader.Compile();

            _fragmentShader = _openGlResourceFactory.CreateShader(ShaderType.FragmentShader);
            _fragmentShader.SetSource(FragmentShaderSource);
            _fragmentShader.Compile();

            _geometryShader = _openGlResourceFactory.CreateShader(ShaderType.GeometryShader);
            _geometryShader.SetSource(GeometryShaderSource);
            _geometryShader.Compile();

            Program = _openGlResourceFactory.CreateProgram();
            Program.Create();
            Program.AttachShader(_vertexShader);
            Program.AttachShader(_geometryShader);
            Program.AttachShader(_fragmentShader);
            Program.Link();

            ProjectionMatrix = Program.GetUniform<Matrix4>("ProjectionMatrix");
            ViewMatrix = Program.GetUniform<Matrix4>("ViewMatrix");
            ModelMatrix = Program.GetUniform<Matrix4>("ModelMatrix");
            Color = Program.GetUniform<Vector4>("Color");
            WindowScale = Program.GetUniform<Vector2>("WindowScale");
        }
Example #59
0
 public QuadRenderer(Renderer renderer, IShader shader)
 {
     this.renderer = renderer;
     this.shader = shader;
 }
Example #60
0
 public void setShaderOverride(IShader shader, bool photonOverride)
 {
     shaderOverride = shader;
     shaderOverridePhotons = photonOverride;
 }