Exemplo n.º 1
0
        /// <summary>
        ///    Create the specified type of GpuProgram.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        protected override Resource _create(string name, ulong handle, string group, bool isManual,
                                            IManualResourceLoader loader, NameValuePairList createParams)
        {
            if (createParams == null ||
                (createParams.ContainsKey("syntax") == false || createParams.ContainsKey("type") == false))
            {
                throw new Exception("You must supply 'syntax' and 'type' parameters");
            }

            string syntaxCode = createParams["syntax"];
            string type       = createParams["type"];

            // if there is none, this syntax code must not be supported
            // just return the base GL program since it won't be doing anything anyway
            if (this.factories[syntaxCode] == null)
            {
                return(new GLGpuProgram(this, name, handle, group, isManual, loader));
            }

            GpuProgramType gpt;

            if (type == "vertex_program")
            {
                gpt = GpuProgramType.Vertex;
            }
            else
            {
                gpt = GpuProgramType.Fragment;
            }

            return(((IOpenGLGpuProgramFactory)this.factories[syntaxCode]).Create(this, name, handle, group, isManual, loader,
                                                                                 gpt,
                                                                                 syntaxCode));
        }
Exemplo n.º 2
0
		public NvparseFragmentProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader )
			: base( parent, name, handle, group, isManual, loader )
		{

			// create a display list
			programId = Gl.glGenLists( 1 );
		}
Exemplo n.º 3
0
        public virtual RequestID Prepare(string resType, string name, string group, bool isManual,
                                         IManualResourceLoader loader, NameValuePairList loadParams,
                                         OnOperationCompleted listener)
#endif
        {
#if AXIOM_THREAD_SUPPORT
            // queue a request
            ResourceRequest req = new ResourceRequest();
            req.Type         = RequestType.PrepareResource;
            req.ResourceType = resType;
            req.ResourceName = name;
            req.GroupName    = group;
            req.IsManual     = isManual;
            req.Loader       = loader;
            // Make instance copy of loadParams for thread independence
            req.LoadParams = (loadParams != null ? new NameValuePairList(loadParams) : null);
            req.Listener   = listener;
            return(AddRequest(req));
#else
            // synchronous
            ResourceManager rm = ResourceGroupManager.Instance.ResourceManagers[resType];
            rm.Prepare(name, group, isManual, loader, loadParams);
            return(0);
#endif
        }
Exemplo n.º 4
0
		public ARBGpuProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
		                      IManualResourceLoader loader )
			: base( parent, name, handle, group, isManual, loader )
		{
			// generate a new program
			Gl.glGenProgramsARB( 1, out programId );
		}
Exemplo n.º 5
0
		/// <summary>
		///    Create the specified type of GpuProgram.
		/// </summary>
		/// <param name="name"></param>
		/// <param name="type"></param>
		/// <returns></returns>
		protected override Resource _create( string name, ulong handle, string group, bool isManual,
		                                     IManualResourceLoader loader, NameValuePairList createParams )
		{
			if ( createParams == null ||
			     ( createParams.ContainsKey( "syntax" ) == false || createParams.ContainsKey( "type" ) == false ) )
			{
				throw new Exception( "You must supply 'syntax' and 'type' parameters" );
			}

			string syntaxCode = createParams[ "syntax" ];
			string type = createParams[ "type" ];

			// if there is none, this syntax code must not be supported
			// just return the base GL program since it won't be doing anything anyway
			if ( this.factories[ syntaxCode ] == null )
			{
				return new GLGpuProgram( this, name, handle, group, isManual, loader );
			}

			GpuProgramType gpt;
			if ( type == "vertex_program" )
			{
				gpt = GpuProgramType.Vertex;
			}
			else
			{
				gpt = GpuProgramType.Fragment;
			}

			return ( (IOpenGLGpuProgramFactory)this.factories[ syntaxCode ] ).Create( this, name, handle, group, isManual, loader,
			                                                                          gpt,
			                                                                          syntaxCode );
		}
Exemplo n.º 6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="name"></param>
        /// <param name="handle"></param>
        /// <param name="group"></param>
        /// <param name="isManual"></param>
        /// <param name="loader"></param>
        /// <param name="createParams"></param>
        /// <returns></returns>
        protected override Resource _create(string name, ulong handle, string group, bool isManual,
                                            IManualResourceLoader loader, NameValuePairList createParams)
        {
            var s = new Quake3Shader(this, name, handle, ResourceGroupManager.Instance.WorldResourceGroupName);

            return(s);
        }
		public ATIFragmentShaderGpuProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader )
			: base( parent, name, handle, group, isManual, loader )
		{
            throw new AxiomException("This needs upgrading");
			programType = Gl.GL_FRAGMENT_SHADER_ATI;
			programId = Gl.glGenFragmentShadersATI( 1 );
		}
Exemplo n.º 8
0
 public Texture CreateManual(string name, string group, TextureType type, int width, int height, int numMipmaps,
                             PixelFormat format, TextureUsage usage, IManualResourceLoader loader,
                             bool hwGammaCorrection, int fsaa, string fsaaHint)
 {
     return(CreateManual(name, group, type, width, height, 1, numMipmaps, format, usage, loader, hwGammaCorrection, fsaa,
                         string.Empty));
 }
Exemplo n.º 9
0
		private List<Image> loadedImages; //Used to hold images between calls to prepare and load.

		public GLES2Texture( ResourceManager creator, string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, GLES2Support support )
			: base( creator, name, handle, group, isManual, loader )
		{
			this.textureID = 0;
			this.glSupport = support;
			this.surfaceList = new List<HardwarePixelBuffer>();
		}
Exemplo n.º 10
0
 public NvparseFragmentProgram(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                               IManualResourceLoader loader)
     : base(parent, name, handle, group, isManual, loader)
 {
     // create a display list
     programId = Gl.glGenLists(1);
 }
Exemplo n.º 11
0
 public ARBGpuProgram(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                      IManualResourceLoader loader)
     : base(parent, name, handle, group, isManual, loader)
 {
     // generate a new program
     Gl.glGenProgramsARB(1, out programId);
 }
		public ATIFragmentShaderGpuProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader )
			: base( parent, name, handle, group, isManual, loader )
		{

			programType = Gl.GL_FRAGMENT_SHADER_ATI;
			programId = Gl.glGenFragmentShadersATI( 1 );
		}
Exemplo n.º 13
0
        /*
		public D3DTextureManager(D3D.Direct3D manager, D3D.Device device)
		{
           
		}
         */
         

		protected override Resource _create( string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, NameValuePairList createParams )
		{
            // temporary hack
            manager = D3DRenderSystem.Direct3D9;
            device = D3DRenderSystem.ActiveD3D9Device;
			return new D3DTexture( this, name, handle, group, isManual, loader, this.device, this.manager );
		}
Exemplo n.º 14
0
        public Axiom.Math.Tuple <Resource, bool> CreateOrRetrieve(string name, string group, bool isManual,
                                                                  IManualResourceLoader loader, NameValuePairList paramaters)
        {
            var hashCode = (ResourceHandle)name.ToLower().GetHashCode();

            var res     = this[hashCode];
            var created = false;

            if (res == null)
            {
                res = _create(name, hashCode, group, isManual, loader, paramaters);
                if (paramaters != null)
                {
                    res.SetParameters(paramaters);
                }

                _add(res);

                // Tell resource group manager
                ResourceGroupManager.Instance.notifyResourceCreated(res);

                created = true;
            }

            return(new Axiom.Math.Tuple <Resource, bool>(res, created));
        }
Exemplo n.º 15
0
 public ATIFragmentShaderGpuProgram(ResourceManager parent, string name, ResourceHandle handle, string group,
                                    bool isManual, IManualResourceLoader loader)
     : base(parent, name, handle, group, isManual, loader)
 {
     throw new AxiomException("This needs upgrading");
     programType = Gl.GL_FRAGMENT_SHADER_ATI;
     programId   = Gl.glGenFragmentShadersATI(1);
 }
Exemplo n.º 16
0
        //TODO : Look at generics method for implementing this.

        /// <summary>
        /// Generic load method, used to create a Resource specific to this
        /// ResourceManager without using one of the specialised 'load' methods
        /// (containing per-Resource-type parameters).
        /// </summary>
        /// <param name="name">The name of the Resource</param>
        /// <param name="group">The resource group to which this resource will belong</param>
        /// <param name="isManual">Is the resource to be manually loaded? If so, you should
        /// provide a value for the loader parameter</param>
        /// <param name="loader">The manual loader which is to perform the required actions
        /// when this resource is loaded; only applicable when you specify true
        /// for the previous parameter</param>
        /// <param name="loadParams">Optional pointer to a list of name/value pairs
        /// containing loading parameters for this type of resource.</param>
        /// <param name="backgroundThread">Optional boolean which lets the load routine know if it
        /// is being run on the background resource loading thread</param>
        //[OgreVersion(1, 7, 2)]
        public virtual Resource Load(string name, string group, bool isManual, IManualResourceLoader loader, NameValuePairList loadParams, bool backgroundThread)
        {
            var r = CreateOrRetrieve(name, group, isManual, loader, loadParams).First;

            // ensure loaded
            r.Load(backgroundThread);
            return(r);
        }
Exemplo n.º 17
0
 /// <summary>
 ///	Protected unnamed constructor to prevent default construction.
 /// </summary>
 protected Resource()
 {
     _creator          = null;
     _handle           = 0;
     _size             = 0;
     _isManuallyLoaded = false;
     _loader           = null;
 }
Exemplo n.º 18
0
        public GLGpuProgram Create(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                                   IManualResourceLoader loader, GpuProgramType type, string syntaxCode)
        {
            GLGpuProgram ret = new NvparseFragmentProgram(parent, name, handle, group, isManual, loader);

            ret.SyntaxCode = syntaxCode;
            ret.Type       = type;
            return(ret);
        }
Exemplo n.º 19
0
		public GLSLESCgProgram( ResourceManager creator, string name, ulong handle, string group, bool isManual, IManualResourceLoader loader )
			: base( creator, name, handle, group, isManual, loader )
		{
			/*Port notes
			 * Ogre does something odd with a dictionary here, it looks like it has to do with Material serialization 
			 */

			syntaxCode = "cg";
		}
Exemplo n.º 20
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="parent"></param>
        /// <param name="name"></param>
        /// <param name="handle"></param>
        /// <param name="group"></param>
        /// <param name="isManual"></param>
        /// <param name="loader"></param>
        /// <param name="device"></param>
        public XnaTexture(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                          IManualResourceLoader loader, GraphicsDevice device)
            : base(parent, name, handle, group, isManual, loader)
        {
            Debug.Assert(device != null, "Cannot create a texture without a valid Xna Device.");
            _device = device;

            InitDevice();
        }
Exemplo n.º 21
0
 protected override Resource _create(string name, ResourceHandle handle, string group, bool isManual,
                                     IManualResourceLoader loader, NameValuePairList createParams)
 {
     if (createParams == null || !createParams.ContainsKey("language"))
     {
         throw new Exception("You must supply a 'language' parameter");
     }
     return(GetFactory(createParams["language"]).CreateInstance(this, name, handle, group, isManual, loader));
 }
Exemplo n.º 22
0
		public NV3xGpuProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader )
			: base( parent, name, handle, group, isManual, loader )
		{

			// generate the program and store the unique name
			Gl.glGenProgramsNV( 1, out programId );

			// find the GL enum for the type of program this is
			programType = ( Type == GpuProgramType.Vertex ) ? Gl.GL_VERTEX_PROGRAM_NV : Gl.GL_FRAGMENT_PROGRAM_NV;
		}
Exemplo n.º 23
0
        public GLGpuProgram Create(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                                   IManualResourceLoader loader, GpuProgramType type, string syntaxCode)
        {
            // creates and returns a new ATI fragment shader implementation
            GLGpuProgram ret = new ATIFragmentShaderGpuProgram(parent, name, handle, group, isManual, loader);

            ret.Type       = type;
            ret.SyntaxCode = syntaxCode;
            return(ret);
        }
Exemplo n.º 24
0
		protected override Resource _create( string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader, GpuProgramType type, string syntaxCode )
		{
			if ( type == GpuProgramType.Vertex )
			{
				return new D3DVertexProgram( this, name, handle, group, isManual, loader, device );
			}
			else
			{
				return new D3DFragmentProgram( this, name, handle, group, isManual, loader, device );
			}
		}
Exemplo n.º 25
0
 /// <param name="isManual">
 ///     Is this resource manually loaded? If so, you should really
 ///     populate the loader parameter in order that the load process
 ///     can call the loader back when loading is required.
 /// </param>
 /// <param name="loader">
 ///     An IManualResourceLoader implementation which will be called
 ///     when the Resource wishes to load (should be supplied if you set
 ///     isManual to true). You can in fact leave this parameter null
 ///     if you wish, but the Resource will never be able to reload if
 ///     anything ever causes it to unload. Therefore provision of a proper
 ///     IManualResourceLoader instance is strongly recommended.
 /// </param>
 protected Resource(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader)
     : this()
 {
     _creator          = parent;
     _name             = name;
     _handle           = handle;
     _group            = group;
     _size             = 0;
     _isManuallyLoaded = isManual;
     _loader           = loader;
 }
Exemplo n.º 26
0
        /// <summary>
        ///		Constructor.
        /// </summary>
        public GLSLProgram(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                           IManualResourceLoader loader)
            : base(parent, name, handle, group, isManual, loader)
        {
            InputOperationType  = OperationType.TriangleList;
            OutputOperationType = OperationType.TriangleList;
            MaxOutputVertices   = 3;

            // Manually assign language now since we use it immediately
            SyntaxCode = "glsl";
        }
Exemplo n.º 27
0
        public NV3xGpuProgram(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                              IManualResourceLoader loader)
            : base(parent, name, handle, group, isManual, loader)
        {
            throw new AxiomException("This needs upgrading");
            // generate the program and store the unique name
            Gl.glGenProgramsNV(1, out programId);

            // find the GL enum for the type of program this is
            programType = (Type == GpuProgramType.Vertex) ? Gl.GL_VERTEX_PROGRAM_NV : Gl.GL_FRAGMENT_PROGRAM_NV;
        }
Exemplo n.º 28
0
 public Compositor(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                   IManualResourceLoader loader)
     : base(parent, name, handle, group, isManual, loader)
 {
     this.techniques                  = new List <CompositionTechnique>();
     this.readOnlyTechniques          = new ReadOnlyCollection <CompositionTechnique>(this.techniques);
     this.supportedTechniques         = new List <CompositionTechnique>();
     this.readOnlySupportedTechniques = new ReadOnlyCollection <CompositionTechnique>(this.supportedTechniques);
     this.globalTextures              = new Dictionary <string, Texture>();
     this.globalMRTs                  = new Dictionary <string, MultiRenderTarget>();
     this.compilationRequired         = true;
 }
        /// <param name="isManual">
        ///     Is the resource to be manually loaded? If so, you should
        ///     provide a value for the loader parameter
        /// </param>
        /// <param name="loader">
        ///     The manual loader which is to perform the required actions
        ///     when this resource is loaded; only applicable when you specify true
        ///     for the previous parameter
        /// </param>
        /// <param name="loadParams">
        ///     Optional pointer to a list of name/value pairs
        ///     containing loading parameters for this type of resource.
        /// </param>
        virtual public Resource Load(string name, string group, bool isManual, IManualResourceLoader loader, NameValuePairList loadParams)
        {
            Resource ret = this[name];

            if (ret == null)
            {
                ret = Create(name, group, isManual, loader, loadParams);
            }
            // ensure loaded
            ret.Load();
            return(ret);
        }
Exemplo n.º 30
0
 protected override Resource _create(string name, ResourceHandle handle, string group, bool isManual,
                                     IManualResourceLoader loader, GpuProgramType type, string syntaxCode)
 {
     if (type == GpuProgramType.Vertex)
     {
         return(new D3D9GpuVertexProgram(this, name, handle, group, isManual, loader));
     }
     else
     {
         return(new D3D9GpuFragmentProgram(this, name, handle, group, isManual, loader));
     }
 }
Exemplo n.º 31
0
 /// <param name="group"></param>
 /// <param name="isManual">
 ///     Is this resource manually loaded? If so, you should really
 ///     populate the loader parameter in order that the load process
 ///     can call the loader back when loading is required.
 /// </param>
 /// <param name="loader">
 ///     An IManualResourceLoader implementation which will be called
 ///     when the Resource wishes to load (should be supplied if you set
 ///     isManual to true). You can in fact leave this parameter null
 ///     if you wish, but the Resource will never be able to reload if
 ///     anything ever causes it to unload. Therefore provision of a proper
 ///     IManualResourceLoader instance is strongly recommended.
 /// </param>
 /// <param name="parent"></param>
 /// <param name="name"></param>
 /// <param name="handle"></param>
 protected Resource(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                    IManualResourceLoader loader)
     : base()
 {
     this._creator          = parent;
     this._name             = name;
     Handle                 = handle;
     this._group            = group;
     this._size             = 0;
     this._isManuallyLoaded = isManual;
     this._loader           = loader;
 }
Exemplo n.º 32
0
        public virtual GpuProgram Create(string name, string group, GpuProgramType type, string syntaxCode, bool isManual,
                                         IManualResourceLoader loader)
#endif
        {
            // Call creation implementation
            var ret =
                (GpuProgram)_create(name, (ResourceHandle)name.ToLower().GetHashCode(), group, isManual, loader, type, syntaxCode);

            _add(ret);
            // Tell resource group manager
            ResourceGroupManager.Instance.notifyResourceCreated(ret);
            return(ret);
        }
Exemplo n.º 33
0
        protected override Resource _create(string name, ulong handle, string group, bool isManual,
                                            IManualResourceLoader loader, GpuProgramType type, string syntaxCode)
        {
            // if there is none, this syntax code must not be supported
            // just return the base GL program since it won't be doing anything anyway
            if (this.factories[syntaxCode] == null)
            {
                return(new GLGpuProgram(this, name, handle, group, isManual, loader));
            }

            // get a reference to the factory for this syntax code
            var factory = (IOpenGLGpuProgramFactory)this.factories[syntaxCode];

            // create the gpu program
            return(factory.Create(this, name, handle, group, isManual, loader, type, syntaxCode));
        }
Exemplo n.º 34
0
        protected GpuProgram(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                             IManualResourceLoader loader)
            : base(parent, name, handle, group, isManual, loader)
        {
            this.type    = GpuProgramType.Vertex;
            LoadFromFile = true;
            this.isSkeletalAnimationIncluded = false;
            this.morphAnimation             = false;
            this.poseAnimation              = 0;
            this.vertexTextureFetchRequired = false;
            this.needsAdjacencyInfo         = false;
            this.compileError = false;
            this._loadedManualNamedConstants = false;

            CreateParameterMappingStructures();
        }
Exemplo n.º 35
0
		protected override Resource _create( string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader, NameValuePairList createParams )
		{
			if ( !createParams.ContainsKey( "type" ) )
			{
				throw new Exception( "You must supply a 'type' parameter." );
			}

			if ( createParams[ "type" ] == "vertex_program" )
			{
				return new D3DVertexProgram( this, name, handle, group, isManual, loader, device );
			}
			else
			{
				return new D3DFragmentProgram( this, name, handle, group, isManual, loader, device );
			}
		}
        /// <param name="isManual">
        /// Is this resource manually loaded? If so, you should really
        /// populate the loader parameter in order that the load process
        /// can call the loader back when loading is required.
        /// </param>
        /// <param name="loader">
        /// Pointer to a ManualLoader implementation which will be called
        /// when the Resource wishes to load (should be supplied if you set
        /// isManual to true). You can in fact leave this parameter null
        /// if you wish, but the Resource will never be able to reload if
        /// anything ever causes it to unload. Therefore provision of a proper
        /// ManualLoader instance is strongly recommended.
        /// </param>
        /// <param name="createParams">If any parameters are required to create an instance, they should be supplied here as name / value pairs</param>
        virtual public Resource Create(string name, string group, bool isManual, IManualResourceLoader loader, NameValuePairList createParams)
        {
            // Call creation implementation
            Resource ret = _create(name, nextHandle, group, isManual, loader, createParams);

            if (createParams != null)
            {
                ret.SetParameters(createParams);
            }

            _add(ret);

            // Tell resource group manager
            ResourceGroupManager.Instance.notifyResourceCreated(ret);

            return(ret);
        }
Exemplo n.º 37
0
        public GLGpuProgram Create(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                                   IManualResourceLoader loader, GpuProgramType type, string syntaxCode)
        {
            GLGpuProgram ret;

            if (type == GpuProgramType.Vertex)
            {
                ret = new VP30GpuProgram(parent, name, handle, group, isManual, loader);
            }
            else
            {
                ret = new FP30GpuProgram(parent, name, handle, group, isManual, loader);
            }
            ret.Type       = type;
            ret.SyntaxCode = syntaxCode;
            return(ret);
        }
Exemplo n.º 38
0
        protected override Resource _create(string name, ResourceHandle handle, string group, bool isManual,
                                            IManualResourceLoader loader, NameValuePairList createParams)
        {
            if (createParams == null || !createParams.ContainsKey("type"))
            {
                throw new AxiomException("You must supply a 'type' parameter.");
            }

            if (createParams["type"] == "vertex_program")
            {
                return(new D3D9GpuVertexProgram(this, name, handle, group, isManual, loader));
            }
            else
            {
                return(new D3D9GpuFragmentProgram(this, name, handle, group, isManual, loader));
            }
        }
Exemplo n.º 39
0
        public HLSLProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                            IManualResourceLoader loader )
            : base( parent, name, handle, group, isManual, loader )
        {
            //var device = ( (XnaRenderWindow)Root.Instance.AutoWindow ).Driver.XnaDevice;
            //switch(type)
            //{
            //    case GpuProgramType.Fragment:
            //        assemblerProgram = new XnaFragmentProgram(parent, name, handle, group, isManual, loader, device);
            //        break;
            //    case GpuProgramType.Vertex:
            //        assemblerProgram = new XnaVertexProgram( parent, name, handle, group, isManual, loader, device );
            //        break;
            //    case GpuProgramType.Geometry:
            //        break;
            //}

            preprocessorDefines = string.Empty;
        }
Exemplo n.º 40
0
        public HLSLProgram(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                           IManualResourceLoader loader)
            : base(parent, name, handle, group, isManual, loader)
        {
            //var device = ( (XnaRenderWindow)Root.Instance.AutoWindow ).Driver.XnaDevice;
            //switch(type)
            //{
            //    case GpuProgramType.Fragment:
            //        assemblerProgram = new XnaFragmentProgram(parent, name, handle, group, isManual, loader, device);
            //        break;
            //    case GpuProgramType.Vertex:
            //        assemblerProgram = new XnaVertexProgram( parent, name, handle, group, isManual, loader, device );
            //        break;
            //    case GpuProgramType.Geometry:
            //        break;
            //}

            preprocessorDefines = string.Empty;
        }
Exemplo n.º 41
0
        public Texture(ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
                       IManualResourceLoader loader)
#endif
            : base(parent, name, handle, group, isManual, loader)
        {
            //if ( createParamDictionary( "Texture" ) )
            //{
            //    // Define the parameters that have to be present to load
            //    // from a generic source; actually there are none, since when
            //    // predeclaring, you use a texture file which includes all the
            //    // information required.
            //}

            if (TextureManager.Instance != null)
            {
                var mgr = TextureManager.Instance;
                MipmapCount = mgr.DefaultMipmapCount;
                SetDesiredBitDepths(mgr.PreferredIntegerBitDepth, mgr.PreferredFloatBitDepth);
            }
        }
Exemplo n.º 42
0
		protected override Resource _create( string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, Collections.NameValuePairList createParams )
		{
			string paramSyntax = string.Empty;
			string paramType = string.Empty;

			if ( createParams == null || createParams.ContainsKey( "syntax" ) == false || createParams.ContainsKey( "type" ) == false )
			{
				throw new AxiomException( "You must supply 'syntax' and 'type' parameters" );
			}
			else
			{
				paramSyntax = createParams[ "syntax" ];
				paramType = createParams[ "type" ];
			}
			CreateGpuProgramDelegate iter = null;
			if ( this._programMap.ContainsKey( paramSyntax ) )
			{
				iter = this._programMap[ paramSyntax ];
			}
			else
			{
				// No factory, this is an unsupported syntax code, probably for another rendersystem
				// Create a basic one, it doesn't matter what it is since it won't be used
				return new GLES2GpuProgram( this, name, handle, group, isManual, loader );
			}
			GpuProgramType gpt;
			if ( paramType == "vertex_program" )
			{
				gpt = GpuProgramType.Vertex;
			}
			else
			{
				gpt = GpuProgramType.Fragment;
			}

			return iter( this, name, handle, group, isManual, loader, gpt, paramSyntax );
		}
Exemplo n.º 43
0
		protected override Resource _create( string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, Axiom.Collections.NameValuePairList createParams )
		{
			return new Mesh( this, name, handle, group, isManual, loader );
		}
Exemplo n.º 44
0
		/// <summary>
		/// 
		/// </summary>
		/// <param name="name"></param>
		/// <param name="handle"></param>
		/// <param name="group"></param>
		/// <param name="isManual"></param>
		/// <param name="loader"></param>
		/// <param name="createParams"></param>
		/// <returns></returns>
		protected override Resource _create( string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, Collections.NameValuePairList createParams )
		{
			if ( createParams == null || !createParams.ContainsKey( "syntax" )
				|| !createParams.ContainsKey( "type" ) )
			{
				throw new NotImplementedException( "You must supply 'syntax' and 'type' parameters" );
			}

			GpuProgramType gpt = 0;
			CreateGpuProgramDelegate iter = _programMap[ createParams[ "syntax" ] ];
			if ( iter == null )
			{
				return null;
			}
			string syntaxcode = string.Empty;
			foreach ( KeyValuePair<string, CreateGpuProgramDelegate> pair in _programMap )
				if ( pair.Value == iter )
				{
					syntaxcode = pair.Key;
					break;
				}
			if ( createParams[ "type" ] == "vertex_program" )
			{
				gpt = GpuProgramType.Vertex;
			}
			else if ( createParams[ "type" ] == "fragment_program" )
			{
				gpt = GpuProgramType.Fragment;
			}
			else
			{
				throw new AxiomException( "Unknown GpuProgramType : " + createParams[ "type" ] );
			}
			return iter( this, name, handle, group, isManual, loader, gpt, syntaxcode );
		}
Exemplo n.º 45
0
		protected override Resource _create( string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, GpuProgramType type, string syntaxCode )
		{
			CreateGpuProgramDelegate iter = null;

			if ( this._programMap.ContainsKey( syntaxCode ) == false )
			{
				//No factory, this is an unsupported syntax code, probably for another rendersystem
				//Create a basic one, it doens't matter what it is since it won't be used
				return new GLES2GpuProgram( this, name, handle, group, isManual, loader );
			}
			else
			{
				iter = this._programMap[ syntaxCode ];
			}
			return iter( this, name, handle, group, isManual, loader, type, syntaxCode );
		}
Exemplo n.º 46
0
 protected override Resource _create(string name, ulong handle, string group, bool isManual,
                                     IManualResourceLoader loader, NameValuePairList createParams)
 {
     return(new XnaMaterial(this, name, handle, group, isManual, loader));
 }
Exemplo n.º 47
0
		/// <summary>
		/// 
		/// </summary>
		/// <param name="name"></param>
		/// <param name="handle"></param>
		/// <param name="group"></param>
		/// <param name="isManual"></param>
		/// <param name="loader"></param>
		/// <param name="type"></param>
		/// <param name="syntaxCode"></param>
		/// <returns></returns>
		protected override Resource _create( string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, GpuProgramType type, string syntaxCode )
		{
			return new DummyGpuProgram( this, name, handle, group, isManual, loader );
		}
Exemplo n.º 48
0
        /// <summary>
        ///    Create the specified type of GpuProgram.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        protected override Resource _create( string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader, GpuProgramType type, string syntaxCode )
        {
            switch ( type )
            {
                case GpuProgramType.Vertex:
                    return new XnaVertexProgram( this, name, handle, group, isManual, loader, device );
                case GpuProgramType.Fragment:
                    return new XnaFragmentProgram( this, name, handle, group, isManual, loader, device );
				
                default:
                    throw new NotSupportedException( "The program type is not supported." );
            }
        }
Exemplo n.º 49
0
			public DummyGpuProgram( ResourceManager creator, string name, ulong handle,
				string group, bool isManual, IManualResourceLoader loader )
				: base( creator, name, handle, group, isManual, loader )
			{
			}
Exemplo n.º 50
0
		public Font( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
		             IManualResourceLoader loader )
			: base( parent, name, handle, group, isManual, loader )
		{
		}
Exemplo n.º 51
0
		public D3D9HLSLProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
		                        IManualResourceLoader loader )
			: base( parent, name, handle, group, isManual, loader )
		{
			UseColumnMajorMatrices = true;
		}
Exemplo n.º 52
0
		/// <summary>
		///		Constructor.
		/// </summary>
		public GLSLProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader )
			: base( parent, name, handle, group, isManual, loader )
		{
		    InputOperationType = OperationType.TriangleList;
            OutputOperationType = OperationType.TriangleList;
		    MaxOutputVertices = 3;
            
            // Manually assign language now since we use it immediately
            SyntaxCode = "glsl";
		}
Exemplo n.º 53
0
		public Mesh( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
		             IManualResourceLoader loader )
			: base( parent, name, handle, group, isManual, loader )
		{
			// This will be set to false by serializers 1.3 and above
			this._autoBuildEdgeLists = true;

			// default to static write only for speed
			this._vertexBufferUsage = BufferUsage.StaticWriteOnly;
			this._indexBufferUsage = BufferUsage.StaticWriteOnly;

			// default to having shadow buffers
			this._useVertexShadowBuffer = true;
			this._useIndexShadowBuffer = true;

			// Initialize to default strategy
			this._lodStrategy = LodStrategyManager.Instance.DefaultStrategy;

			// Init first (manual) lod
			var lod = new MeshLodUsage();
			lod.UserValue = float.NaN; // User value not used for base lod level
			lod.Value = this._lodStrategy.BaseValue;
			lod.EdgeData = null;
			lod.ManualMesh = null;
			this.meshLodUsageList.Add( lod );


			// always use software blending for now
			this.useSoftwareBlending = true;

			SkeletonName = "";
		}
Exemplo n.º 54
0
		/// <summary>
		/// </summary>
		/// <param name="name"> </param>
		/// <param name="handle"> </param>
		/// <param name="group"> </param>
		/// <param name="isManual"> </param>
		/// <param name="loader"> </param>
		/// <param name="createParams"> </param>
		/// <returns> </returns>
		protected override Resource _create( string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, NameValuePairList createParams )
		{
			return new GLESTexture( this, name, handle, group, isManual, loader, this._glSupport );
		}
Exemplo n.º 55
0
		public XnaGpuProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader, XFG.GraphicsDevice device )
			: base( parent, name, handle, group, isManual, loader )
		{
			this.device = device;
			this.shaderCode = null;
		}
Exemplo n.º 56
0
		public GLGpuProgram Create( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader, GpuProgramType type, string syntaxCode )
		{
			GLGpuProgram ret = new NvparseFragmentProgram( parent, name, handle, group, isManual, loader );
			ret.SyntaxCode = syntaxCode;
			ret.Type = type;
			return ret;
		}
Exemplo n.º 57
0
		/// <summary>
		///		Creates a barebones Mesh object that can be used to manually define geometry later on.
		/// </summary>
		public Mesh CreateManual( string name, string group, IManualResourceLoader loader )
		{
			return (Mesh)Create( name, group, true, loader, null );
		}
Exemplo n.º 58
0
        internal XnaFragmentProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader, XFG.GraphicsDevice device )
			: base( parent, name, handle, group, isManual, loader, device )
		{
		}
		public GLGpuProgram Create( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual,
		                            IManualResourceLoader loader, GpuProgramType type, string syntaxCode )
		{
			// creates and returns a new ATI fragment shader implementation
			GLGpuProgram ret = new ATIFragmentShaderGpuProgram( parent, name, handle, group, isManual, loader );
			ret.Type = type;
			ret.SyntaxCode = syntaxCode;
			return ret;
		}
Exemplo n.º 60
0
		protected override Resource _create( string name, ulong handle, string group, bool isManual,
		                                     IManualResourceLoader loader, NameValuePairList createParams )
		{
			throw new NotImplementedException( "Base class needs update to 1.7.2790" );
		}