/// <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)); }
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 ); }
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 }
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 ); }
/// <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 ); }
/// <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 ); }
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)); }
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>(); }
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); }
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 ); }
/* 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 ); }
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)); }
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); }
//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); }
/// <summary> /// Protected unnamed constructor to prevent default construction. /// </summary> protected Resource() { _creator = null; _handle = 0; _size = 0; _isManuallyLoaded = false; _loader = null; }
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); }
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"; }
/// <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(); }
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)); }
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; }
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); }
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 ); } }
/// <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; }
/// <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"; }
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; }
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); }
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)); } }
/// <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; }
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); }
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)); }
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(); }
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); }
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); }
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)); } }
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; }
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; }
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); } }
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 ); }
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 ); }
/// <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 ); }
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 ); }
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)); }
/// <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 ); }
/// <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." ); } }
public DummyGpuProgram( ResourceManager creator, string name, ulong handle, string group, bool isManual, IManualResourceLoader loader ) : base( creator, name, handle, group, isManual, loader ) { }
public Font( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader ) : base( parent, name, handle, group, isManual, loader ) { }
public D3D9HLSLProgram( ResourceManager parent, string name, ResourceHandle handle, string group, bool isManual, IManualResourceLoader loader ) : base( parent, name, handle, group, isManual, loader ) { UseColumnMajorMatrices = true; }
/// <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"; }
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 = ""; }
/// <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 ); }
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; }
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; }
/// <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 ); }
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; }
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" ); }