***
2. Select the `SpeckleUnrealManager` instance in the `World Outliner` sidebar and use the options presented in the `Speckle` category.
***
3. There are **two ways to import objects** using the `Speckle Unreal Manager` actor.
**3.** Enter the **Object ID** of the object you want to receive.
You can explore the objects in a project by using the Speckle Web App for the Speckle server that you use.
**4. If the stream is private**, you will need to generate an **auth token**.
To do so, head to your profile page [https://app.speckle.systems/profile](https://app.speckle.systems/profile), and generate a new Access Token (with all scopes)
**2.** Paste the auth token into your `Speckle Unreal Manager` actor (also, ensure the `ServerUrl` is correct)
**3.** Deselect the "specify by object id" option, and, assuming the url + token is valid, the drop down selections for `project`, `model`, and `version` will be available.
(optional notes) The number of project/model/versions is capped, by default at 15, but this value can be adjusted under the advanced settings `options limit` value.
If no options appear, then try deselecting, and reselecting the actor, and check the `Output Log` for warnings.
Additionally, a number of Blueprint macro nodes are provided to fetch details about project/model/version/users.
## Object conversion
The `SpeckleConverterComponent` provides the conversion functionality for converting **Speckle objects to native UE Actors**.
However, this class does not contain specific conversion logic.
And the default translucent material "SpeckleGlassMaterial", looks like this:
These base materials are exposed as properties of the converter, and can be changed from within the editor (or from BP/C++) to a custom material.
#### Overriding/Substituting converted materials
Speckle does **not currently** support sending/receiving textured materials.
However, we do provide a way to automatically apply native Unreal materials while receiving objects from Speckle.
Converted materials can be overridden with custom materials in two ways.
* **By Name** - The `RenderMaterial.name` will be matched against materials in the `MaterialsOverridesByName` array.
* **By Id** - The `RenderMaterial.id` will be by key with materials in the `MaterailOverridesById` map.
Screenshot of material overrides **By ID** in the details panel of the default `MaterialConverter` instance.
Materials with the ID `f5f7ebd4a...` will use this material instead of converting one from the object's `RenderMaterial`.
Screenshot of material overrides **By Name** in the details panel of the default `MaterialConverter` instance..
Materials with the name `Mossy_Grass` will use this material instead of converting one from the object's `RenderMaterial`.
#### Material priorities
Material priority (high to low).
1. A material in `OverridesById` that matches by Id.
2. A material in `OverridesByName` that matches by Name.
3. A material cached from a previous receive operation.
4. A material asset in the `/Game/Speckle/Materials/{id}` package. (i.e. from a previous receive, but not cached, or from a strategically placed asset)
5. A material converted from `RenderMaterial` of the Mesh.
6. Finally, if all else fails, the `DefaultMaterial` set in the `MaterialConverter` will be used.
> Note: If there is no material on an object, we do not fall back to the parent's material like previous versions of this connector.
> We are aware this may cause unexpected behaviour. This issue will be addressed.
#### Limitations
* In order to use textured materials, meshes need to have **Texture coordinates** (UV coordinates). Currently, Texture coordinates are only outputted from Rhino, Blender, and Sketchup connectors. (More connectors will receive support shortly! see [issue](https://github.com/specklesystems/speckle-sharp/issues/797). The Unreal Connector does **not** generate texture coordinates for you.
Having UV coordinates also has other advantages for baked lighting.
* **Textures cannot be sent/received through Speckle**, only flat colours and simple PBR properties. Texture support is on our roadmap, but there are several techincal chalanges to overcome before this is possible.
### Developing custom conversion logic
As previously mentioned, `ISpeckleConverter` classes can expose properties, such as the type of Actor to create, whether to create an asset, or build settings etc.
If this doesn't satisfy your needs, there are a few ways to further customise conversion.
1. You can extend an existing converter, and re-implement specific functions.
2. You can write a completely custom `ISpeckleConverter` class and add an instance to your `SpeckleConverterComponent`
3. You can extend the `SpeckleConverterComponent` to customise more generally how objects are converted and actors attached.
Converters can be created in either C++ or Blueprint.
#### Custom object models
Object Models in the Unreal plugin function the same as the Object Models in .NET.
Out of the box, the Speckle for Unreal plugin provides several Object Models.
These classes can be found in `speckle-unreal\Source\SpeckleUnreal\Public\Objects` and are all subclasses of the `UBase` type.
For the most part, these classes are direct ports of the corresponding .NET classes from our Objects kit.
For example `Mesh`, and `BlockInstance`.
An Object Model is required in order to convert Speckle objects.
If you are looking to convert a type that we don't provide an Object Model, creating one is simple.
This process is very similar to defining an object model in the .NET and PY SDKs,
But be aware of certain limitations:
1. The UE plugin **does not provide a reflection based (de)serializer**.
Object Models implement their own (de)serialization logic in the form of manually parsing JSON properties.
2. **Only certain Object Models are provided** out of the box, while most are direct ports of Objects kit, some are not!
3. The Speckle Type is defined in the Object Model's constructor, not by its Namespace like in .NET.
4. Units are applied while parsing (rather than ToNative conversion - subject to change)
To implement your own Unreal Object Model, simply create a new class inheriting from `UBase`.
Add your properties, and implement the `Parse` method to set these properties from the JSON object.
```cpp theme={null}
bool UMyObjectModel::Parse(const TSharedPtr
Under *Class Settings* add `ISpeckleConverter` to the *Implemented Interfaces* list.
Finally, implement your conversion logic in the required functions.
