class RED::IResourceManager

Generates a new transaction (or frame) identifier.

This method creates a RED::State object that must be used for all changes in REDsdk. It uniquely identifies the transaction (or frame) being defined (see RED::State::GetNumber to get the transaction number). The transaction defines a begin / end interval. Any change that occur between a call to RED::IResourceManager::BeginState and RED::IResourceManager::EndState is recorded as being part of that transaction. All methods actually modifying the engine contents are using a RED::State instance as the last method parameter.

Note that if a transaction has already been started, this method returns the current transaction.

From this call up to RED::IResourceManager::EndState, all calls that perform modifications on the rendered data in the engine should occur on the same thread.

The resource manager is created with a started transaction, so there's no need for call to RED::IResourceManager::BeginState call upon startup, before the first draw. However, a transaction must be closed before the first draw.

See Transaction management for details on transactions.

Returns:

General resource manager shared resources cleanup.

This method calls the cleanup tool for materials, images and fonts, without any exclusion list. Therefore, anyone useless is deleted. The method takes care of cleaning materials before images so that we don't waste memory.

The iNotMe list indicates a list of objects that must not be removed. That way it's possible to clean objects but to keep some specific instances that are needed later for other purposes, but that could be unused at the time of the call.\

The method must be called on the rendering thread during a valid transaction as it may destroy images.

Parameters:

Returns:

Clears all known layer identifiers for the cluster.

This method must be carefully used as it'll destroy all IDs known for all layers in the cluster. Therefore, after use, an existing RED::LayerSet object won't be valid anymore, as it's existing layer mask won't correspond to anything valid for the cluster.

After the call, new layers that are declared will re-use existing layer bits positions that could have been used before by other layers.

The method automatically removes all layersets for all shapes instances connected to cameras that are inserted in cluster windows. However, it can't clear layersets of shapes that are not connected to a cluster connected camera.

Parameters:

Returns:

Font list cleanup tool.

This method is used to delete all fonts that are no longer in use within the cluster. A fotn is considered useless if there's no shape object that is using it AND that is connected to a viewpoint.

The method won't catch fonts of shapes that are not in a scene graph connected to a viewpoint.

All fonts of the resource manager are checked, unless the 'iScope' list is filled with a list of objects to handle. If 'iScope' is not empty, then only objects in it will be searched for cleanup.

The 'iNotMe' list indicates a list of objects that must not be removed. That way it's possible to clean fonts but to keep some specific instances that are needed later for other purposes, but that could be unused at the time of the call.

Due to state management, effective destruction of cleaned resources only occur at the closing of the transaction after this one.

Parameters:

Returns:

Image list cleanup tool.

This method is used to delete all images that are no longer in use within the cluster. An image is considered useless if there's no material using it.

All images of the resource manager are checked, unless the 'iScope' list is filled with a list of objects to handle. If 'iScope' is not empty, then only objects in it will be searched for cleanup.

The 'iNotMe' list indicates a list of objects that must not be removed. That way it's possible to clean images but to keep some specific instances that are needed later for other purposes, but that could be unused at the time of the call.

This method calls RED::IResourceManager::DeleteImage, and is subject to the same calling restrictions.

Parameters:

Returns:

Material list cleanup tool.

This method is used to delete all materials that are no longer in use within the cluster. A material is considered useless if there's no shape object that is using it AND that is connected to a viewpoint.
The method won't catch materials of shapes that are not in a scene graph connected to a viewpoint.

Shared resources used by the freed materials (images, fonts, programs) are not deleted by this call. See the corresponding cleanup calls to perform the dedicated operations.

All materials of the resource manager are checked, unless the 'iScope' list is filled with a list of objects to handle. If 'iScope' is not empty, then only objects in it will be searched for cleanup.
The 'iNotMe' list indicates a list of objects that must not be removed. That way it's possible to clean materials but to keep some specific instances that are needed later for other purposes, but that could be unused at the time of the call.

Due to state management, effective destruction of cleaned resources only occur at the closing of the transaction after this one.

Parameters:

Returns:

Creates a duplicate copy of the specified source image.

This method creates a full copy of the 'iSource' image. All parameters of the image are duplicated, including all pixel arrays, both in hardware and software operating environments.

Note that the local pixel storage of 'iSource' is used and overriden during the operation, so any former pixel data stored in the image local storage will be lost.

A built-in render image of a VRL can't be cloned. See RED::IViewpointRenderList::GetRenderImage for details. Another render image should be created using RED::IImage2D::SetRenderImage instead.

See also Duplicating an image.

Parameters:

Returns:

Clones a material instance.

This method performs a clone of a given iSource Material. The created clone has all shaders and all rendering configurations duplicated. Depending on the value of iImageCopy and iTinyImageCopy, all images that are pointed to by oMaterial can either be copies of all images in iSource or can be shared images.

Note that if an image is shared by several parameters in iSource, the copy of that image will be shared by the same set of cloned parameters in oMaterial if iImageCopy (or iTinyImageCopy depending on the image size) is true. If iImageCopy (or iTinyImageCopy) is false, then the same image address will be shared by both sets of parameters in iSource and in oMaterial.

iImageCopy refers to images whose pixel size is above 1 in at least one dimension, iTinyImageCopy refers to images whose pixel size is exactly 1 in all dimensions. Tiny images are often used in textured shader constructions, where if a shader uses at least one texture, all its parameters are set to textures.

Note that all local storages of all images that are cloned are overriden during the operation. Therefore, any data stored in any duplicated image storage will be lost.

See also Using the realistic material.

Parameters:

Returns:

Tests the entire cluster memory.

This method tests the existence of every object inside the cluster. All windows, viewpoints, materials, shaders, images, etc... addresses are verified. The test will stop on the first invalid address found.
The method only works if the RED::MemoryLeakTracker has been enabled before the resource manager creation. If this is not the case, then the method will return RED_WORKFLOW_ERROR.

Parameters:

Returns:

Constant color material for fonts.

This method creates a material set with a constant color suitable to render RED::FNT_TRIANGLE fonts. RED::FNT_TRIANGLE fonts don't support high definition matrices and therefore can't be rendered using built-in shaders.

See also Geometry layers.

Parameters:

Returns:

Constant color material.

This method creates a material set with a constant color, in a RED::RenderShaderSolid. The shader is in the RED::MTL_PRELIT rendering pass.

See also Geometry layers.

Parameters:

Returns:

Creates a font object instance.

The created font must be specified before it can be used within a CID_REDTextShape (see RED::ITextShape) instance for the rendering.

Task: Creating a font

A font is a shared resource in REDsdk. It must be created directly from the cluster's resource manager:

// Create the font using the resource manager and retrieve its font interface:
RED::Object* font;
RC_TEST( iresmgr->CreateFont( font, iresmgr->GetState() ) );
RED::IFont* ifont = font->As< RED::IFont >();

Then, the font MUST be configured before it can be used for the rendering. If a font is not configured, then REDsdk rendering methods will return an error:

// Setup minimal font parameters for the display:
RC_TEST( ifont->SetType( RED::FNT_SYSTEM, iresmgr->GetState() ) );
RC_TEST( ifont->SetRenderMode( RED::FNT_TRIANGLE, iresmgr->GetState() ) );
RC_TEST( ifont->SetTypeFaceName( "Arial", iresmgr->GetState() ) );
RC_TEST( ifont->SetCharSet( RED::FNT_ANSI_CHARSET, iresmgr->GetState() ) );
RC_TEST( ifont->SetSize( 0.0f, 80.0f, iresmgr->GetState() ) );

Parameters:

Returns:

Creates a new 2D image instance.

Creates a new 2D bitmap image instance. At least one window must have been created before calling this method. Images can be created from any thread that is the unique edition thread, assuming that the engine has a valid transaction being opened.

Task: Creating a 2D image

RED::Object* image_2d;

// Create the image.
RC_TEST( iresmgr->CreateImage2D( image_2d, iresmgr->GetState() ) );

RED::IImage2D* i2d = image_2d->As< RED::IImage2D >();

// Let the engine to allocate the image 1024 x 1024 (POTD) pixels array for us.
RC_TEST( i2d->SetLocalPixels( NULL, RED::FMT_RGB, 1024, 1024 ) );

unsigned char* pixels = i2d->GetLocalPixels();
for( int y = 0; y < 1024; ++y )
  for( int x = 0; x < 1024; ++x )
    // Fill in the texture...

// Set the texture content to the renderer.
RC_TEST( i2d->SetPixels( RED::TGT_TEX_2D, iresmgr->GetState() ) );

This code sample creates a 2D image, uses REDsdk to allocate a local pixel array in the image and uploads the contents of this local pixel array in the engine (therefore on the GPU if REDsdk uses GPU rendering, and in CPU memory is REDsdk uses software rendering). The local pixel array remains. It can be deleted if not needed anymore using RED::IImage2D::ClearLocalPixels.

Parameters:

Returns:

Creates a new 3D image instance.

Creates a new volume image instance. At least one window must have been created before calling this method. Images can be created from any thread that is the unique edition thread, assuming that the engine has a valid transaction being opened.

Task: Creating a 3D image

RED::Object* image_3d;

// Create the image.
RC_TEST( iresmgr->CreateImage3D( image_3d, iresmgr->GetState() ) );

RED::IImage3D* i3d = image_3d->As< RED::IImage3D >();

// Let the engine to allocate the image 256x256x256 pixels array for us.
RC_TEST( i3d->SetLocalPixels( NULL, RED::FMT_RGB, 256, 256, 256 ) );

unsigned char* pixels = i3d->GetLocalPixels();
for( int z = 0; z < 256; ++z )
  for( int y = 0; y < 256; ++y )
    for( int x = 0; x < 256; ++x )
      // Fill in the texture...

// Set the texture content to the renderer.
RC_TEST( i3d->SetPixels( RED::TGT_TEX_3D, iresmgr->GetState() ) );

This code sample creates a 3D image, uses REDsdk to allocate a local pixel array in the image and uploads the contents of this local pixel array in the engine (therefore on the GPU if REDsdk uses GPU rendering, and in CPU memory is REDsdk uses software rendering). The local pixel array remains. It can be deleted if not needed anymore using RED::IImage3D::ClearLocalPixels.

Parameters:

Returns:

Creates a new composite image instance.

Creates a new composite image instance. At least one window must have been created before calling this method. Images can be created from any thread that is the unique edition thread, assuming that the engine has a valid transaction being opened.

See also Setup a composite image.

Parameters:

Returns:

Creates a new cube image instance.

Creates a new cube image instance. At least one window must have been created before calling this method. Images can be created from any thread that is the unique edition thread, assuming that the engine has a valid transaction being opened.

Task: Creating a cube image

RED::Object* image_cube;

// Create the image.
RC_TEST( iresmgr->CreateImageCube( image_cube, iresmgr->GetState() ) );

RED::IImageCube* icube = image_cube->As< RED::IImageCube >();

for( int face = 0; face < 6; ++face )
{
  // Set the content of each cube face.
  RC_TEST( icube->SetFacePixels( face, face_pixels[face], 512, RED::FMT_RGB, iresmgr->GetState() ) );
}

Here, we assume that we have a valid pixel array in 'face_pixels[face]', for each of the 6 faces of the cube to process.

Parameters:

Returns:

Creates a new readback image instance.

Creates a new composite image instance. At least one window must have been created before calling this method. Images can be created from any thread that is the unique edition thread, assuming that the engine has a valid transaction being opened.

Parameters:

Returns:

Creates a new REDMaterial instance.

This method instantiates a new material object. That material can be set as the material of a given shape instance using RED::IShape::SetMaterial.

See also Hello world!.

Parameters:

Returns:

Creates a material for the display of dashed lines after a parametrization.

A special material is required to display the results of a call to RED::ILineShape::Parametrize. This method creates the material with the requested setup to do so. Specifically, it discards connectivity strip segments that are requested to draw the strip geometry into one single part.

See the RED::ILineShape::Parametrize method for all details. The 'iParameterChannel' should be set to the geometrical channel used to store the results of the parametrization. Then, the material is set to render lines with a stipple pattern ( 'iStippleFactor' and 'iStipplePattern' ) as they can be specified in a RED::StateShader, and may apply line smoothing (and blending) based on 'iSmooth'.

The created material has disabled batching capabilities (RED::IMaterial::SetBatchMode) so that different shapes can use it.

See also Generating vector graphics.

Parameters:

Returns:

Helper to create a complete textured font material.

Creates a complete material for the rendering of textured fonts. A state shader is set in the RED::MTL_PRELIT to do an ADDITIVE blending of the RED::RenderShaderText that follows after. The rendering uses the provided 'iColor'. The shader uses the linear alpha interpolation mode.

See also Displaying texts.

Parameters:

Returns:

Deletes all font objects instances.

Deletes all fonts stored by the resource manager. It's the caller's responsibility to ensure that these fonts are no longer used by any shape in any scene graph of the cluster.

Parameters:

Returns:

Deletes all images from the resource manager.

This is the caller's responsibility to ensure that no more image are used by any material used in the cluster at the time of the operation.

Image destruction is immediate. Image may be still referenced in the previous transaction list of images stored by the resource manager. It's the responsibility of the caller to make sure that these images are not used anymore.

Image destruction should only occur from the rendering thread and it can't happen while the software ray-tracer is rendering a scene.

Parameters:

Returns:

Deletes all the materials from the resource manager.

Parameters:

Returns:

Deletes a font object instance.

Deletes all fonts stored by the resource manager. It's the caller's responsibility to ensure that that font is no longer used by any shape in any scene graph of the cluster.

Parameters:

Returns:

Deletes an image from the resource manager.

This is the caller's responsibility to ensure that this image is no longer used by any material or viewpoint parameter or instance callback used in the cluster at the time of the operation.

On calling this method a search for remaining usages of the image is made, which can take a bit of time in large clusters. In that case, the RED::IResourceManager::SetAliveImagesCheck method can be used to enable / disable the usage search. If the image is found to be still used, RED_SCG_IMAGE_STILL_IN_USE is returned and the REDsdk error callback will provide the address of the object holding the image (viewpoint, material). The image will not be released.

Image destruction is immediate. The image may be still referenced in the previous transaction list of images stored by the resource manager. It's the responsibility of the caller to make sure that this image is not used anymore.

Image destruction should only occur from the rendering thread and it can't happen while the software ray-tracer is rendering a scene.

See also Creating and destroying images.

Parameters:

Returns:

Deletes a material from the resource manager.

This method deletes a material from the resource manager. The caller should ensure that this material is no longer used by any shape of any scene graph in the cluster. If the material has a controller that is associated to it, the controller is unregistered from the material and destroyed by the call.

See also Creating and destroying materials.

Parameters:

Returns:

Indicates the end of a transaction.

This method terminates the transaction initiated earlier on by RED::IResourceManager::BeginState. From now on, all changes to perform on engine data must occur using another transaction, that is to be initiated again by a call to RED::IResourceManager::BeginState.

The next draw method will render the most recent finished transaction. This is the transaction number defined by the last call to RED::IResourceManager::EndState. Note that at least one first transaction must be finished to before calling a rendering method on the RED::IWindow.

Calling this method several times has no effect. The first call closes the current transaction and all subsequent calls are ignored.

This method flushes all the pending orders that have been defined during the transaction. It destroys all objects that have been sent to the RED::Factory::DeleteInstance, and performs the update of the entire engine data cluster for the rendering.

This method should not be called if no window has been created yet. As REDsdk is a hybrid CPU / GPU rendering engine, it may need to do OpenGL operations during the EndState call. Before it can proceed with any OpenGL operation, it needs a window that provides the necessary informations to setup the link with the OpenGL layer of the hosting system.

See Transaction management for details on transactions.

Returns:

Finds a font instance by its ID.

Parameters:

Returns:

Searches an image by its id.

Performs a search of the image by the provided iImageID. The first image occurrence found with that ID is returned.

Parameters:

Returns:

Search a material by its id.

Performs a search of the material by the provided iMaterialID. The first material occurrence with this ID is returned.

See also Cutting geometries: a practical example.

Parameters:

Returns:

Search a material by its label.

This is a helper which calls FindMaterial( iMaterialLabel.ToID(), iStateNumber ).

See also Cutting geometries: a practical example.

Parameters:

Returns:

Searches all materials with a given id.

Searches all materials having the iMaterialID id.

Parameters:

Returns:

Searches all materials with a given label.

This is a helper which calls FindMaterials( oMaterials, iMaterialLabel.ToID(), iStateNumber ).

Parameters:

Returns:

Enumerates all available system fonts.

This method enumerates all fonts available in the system. Returned fonts are identified by their full typeface string. At least a window must have been created for this call to work.

Parameters:

Returns:

Returns the batch sync callback parameters currently set.

Parameters:

Retrieves the cluster's data manager instance.

This method returns the data manager object instance that is associated to this cluster. The data manager is used for all context based animations for loaded files.

The returned data manager implements the RED::IDataManager interface.

Returns:

Returns:

Returns:

Returns:

Returns the list of fonts.

The returned list is not reliable if fonts are created or deleted while it's in use.

Parameters:

Returns:

Returns the list of images stored by the resource manager.

Please note that the returned list is not reliable if images are created or deleted while it's in use, as the returned vector is a pointer to the class' internal image list.

Parameters:

Returns:

Returns the current user interruption callback.

Parameters:

Gets a material controller for a given material.

The returned object implements the RED::IMaterialController interface.

See also Using the realistic material.

Parameters:

Returns:

Returns the list of materials.

The returned list is not reliable if materials are created or deleted while it's in use.

Parameters:

Returns:

Returns the number of CPU cores on the system.

This method returns the number of CPU cores available on the system.

See also Generating vector graphics.

Returns:

Returns:

Returns:

Returns:

Returns:

Returns:

Returns:

Gets the runtime platform identifier.

Returns the identifier of the runtime platform identifier. See the RED::HARDWARE_PLATFORM enum for the list of all platform identifiers.
Unless specified by RED::IResourceManager::SetPlatform, the runtime platform is defined by the chipset revision of the computer running the application.

For example, if the program is running on a ATI Radeon 9800 Pro, the returned runtime platform should be RED_HW_ATI_R300.

Note that the runtime platform is defined after the first window creation. Before that, the method will return RED_HW_GENERIC.

See Hardware platforms for details on this topic.

Returns:

Gets the shader program string.

This method returns the program associated to a given iShaderID shader ID.

Parameters:

Returns:

Gets a registered shading callback from its label.

Parameters:

Gets the current state transaction object.

This method can be queried anytime to figure out the current status of the cluster versus transactions.

If we're in a BeginState/EndState transaction, the method returns the current state, that is also retrieved by the RED::IResourceManager::BeginState method. If we are not in a transaction, the method returns an invalid state, whose mode is set to RED::TRANSACTION_OUT.

See Transaction management for details on transactions.

Returns:

Gets the list of windows we have in the cluster.

Parameters:

Returns:

Returns:

Checks if a custom shading callback has already been registered for the given label.

Parameters:

Returns:

Returns:

Loads a shader program from a character string.

This method loads the shader from the iShaderProgram contents. The method returns an identifier in oShaderId that can be used to access to the loaded byte buffer, using RED::IResourceManager::GetShader.

Theis method can be used to load ARB programs or GLSL programs under OpenGL.

See also Cartoon shading.

Parameters:

Returns:

Registers a material controller.

The given controller will be registered for the material it points to (the one passed at the controller creation). If the material has already a controller registered for, the passed controller will be ignored and nothing will be done by the call. You must previously ensure that the material has no controller registered for (by using GetMaterialController and optionally UnregisterMaterialController).

Parameters:

Returns:

Registers a custom shading callback.

If a different callback has already been registered for the given label, RED_FAIL is returned.

See also Cartoon shading.

Parameters:

Returns:

Turn on or off live image checking within REDsdk.

This method can be called to turn on or off live image checking in REDsdk. When enabled, all images used in materials or by controllers are checked whenever possible for existence (e.g. are these image addresses part of RED::IResourceManager::GetImageList?).

Unless your application is performance critical, there's no need to turn live image checking off. The extra cost is in the millisecond range and proportional to the number of material changes that occur per frame.

Default alive image checking is disabled.

An image address which is found invalid triggers a RED_SCG_INVALID_IMAGE_ADDRESS error code.

Parameters:

Setups a callback to flag the end of GPU data synchronization.

See the RED::BATCH_SYNC_CALLBACK details for explanations on the batch synchronization callback.

Parameters:

Setup an error callback.

Parameters:

Returns:

Sets the path of the REDsdk error file.

Defines the complete filepath of the "redsdk_error.txt" file which can be produced by REDsdk whenever an error occurs. See Error tracking for details on detailed error handling within REDsdk. If the folder does not exist, no error file will be written by REDsdk. The default error filepath is the current directory: ".".

Parameters:

Returns:

Sets the user defined interruption callback.

The engine calls the interrupt callback on a regular basis during the rendering of a frame. This can be used to stop a frame whenever the user does not want it to finish.

Parameters:

Setup an OpenGL buffer callback.

Parameters:

Setup an OpenGL material callback.

Parameters:

Setup an OpenGL viewpoint callback.

Parameters:

Selects the platform identifier for this application.

RED::Shader objects are able to register shaders per platform. A platform may be a chipset revision or an user tag. It's used to choose the programs and parameters that'll be used by the shader at runtime for the rendering.

For example, a shader may use a given pixel shader on a NVIDIA hardware and another one on ATI hardware. It may use a set of parameters for a given user tag and another one for another tag. If we think to a game or to a game like application, we could set a "graphic quality" setting, and choose the tag value based on the user's input.

The engine has a runtime platform, which is set to the identifier of the GPU chipset used by the application, unless it's changed by this method.

The engine uses a platform tree to parse shader configurations for a version of data that matches the runtime platform requirements.

If the runtime platform is any of the RED::HW_NVIDIA_<chipset> values, then if the shader has no configuration for this platform, the engine will look for a RED::HW_NVIDIA_GENERIC version of the shader. Then, if this research fails, it'll look for a RED::HW_GENERIC version of the shader. Finally if this fails, there'll be nothing rendered for this shader.

The same applies to any RED::HW_ATI_<chipset> platform that goes to RED::HW_ATI_GENERIC before going to RED::HW_GENERIC and to any RED::HW_INTEL_<chipset> that goes to RED::HW_INTEL_GENERIC before going to RED::HW_GENERIC.

The same rule also applies to all RED::HW_USER_<number> platforms and to the RED::HW_USER_GENERIC platform.

See RED::HARDWARE_PLATFORM for the list of all available platform identifiers.

The platform can't be chosen after the startup of the first transaction.

See Hardware platforms for details on this topic.

Parameters:

Returns:

Turn on or off the synchronization lock.

This method can be used to disarm the internal synchronization lock used to prevent concurrent accesses to occur while using REDsdk in a multi-threaded environment with reader & writer threads. This method should be called once at the application startup. Turning off the synchronization lock can improve REDsdk edition performance a bit in performance critical applications.

Parameters:

Unregisters a material controller.

If the given material has no controller registered for or is NULL, the method will return RED_OK. The controller, if it exists, is not destroyed by the call.

Parameters:

Returns:

Un-registers a custom shading callback.

If no callback is registered for the given label, the method returns RED_OK.

Parameters:

Returns: