Common Art Sprint #1 Delivery

 Responsible for: 

• Skeleton for Character
• Assisted in editing layout reel to include timecode, names, and storyboards
• https://youtu.be/XN5_ZIx9keE
  

Python in UE5

 TO start, go into the unreal plugins, look for python. Turn on Python Editor Script Plugin. Go into settings and look for python, make sure developer mode is turned on (you will have to restart unreal).

    Go into your unreal project, inside intermediate>PythonStub, you'll find unreal.py file

    Make a new visual studio project, copy and paste this unreal.py file into your new project. 

    Make a new python file named logger.py. Import the unreal file and right out a log statement. This will help so that visual studio will autofill the unreal functions. 

import unreal

unreal.log("Tech Art Rocks!")

    Save this file. Then go to your unreal project. At the bottom right you should see a place to write commands. You can change this to python instead. 

    Copy and paste the file path that you saved the logger.py file, then add \logger.py to it and hit enter.

    You should see in your output log the text written out. 

    You can also log warnings and errors. 

unreal.log_warning('this is a warning')

unreal.log_error('this is error')

Press up on the keyboard while in the text box to go back to a previous command. 

If you want to have scripts that automatically load on startup, go to project settings, 

    Restart Unreal to see the script automatically run when it starts up again. 

    If you want to add more paths to the default PYTHON_PATH in your unreal project, you can also do that in the project settings using the 'additional paths' parameter.

    This will need to restart unreal again to apply the settings.
    Want to install other packages to your python like numpy? Go to this file location

C:\Program Files\Epic Games\UE_5.4\Engine\Binaries\ThirdParty\Python3\Win64

Open up a command prompt and change to this directory. 

    We're going to be using pip to install numpy

    This should have installed numpy and you can use it to perform matrix multiplication. 

    In unreal python, you have UObjects and they've got properties you can get/set them. You can see the documentation here. 

Here's a script that prints the name, path name, full name, and class type of selected objects in editor:

import unreal

#decorator

@unreal.uclass()

class EditorUtils(unreal.GlobalEditorUtilityBase):

    pass

selectedAssets = EditorUtils().get_selected_assets()

for asset in selectedAssets:

    unreal.log(asset.get_full_name())

    unreal.log(asset.get_fname())

    unreal.log(asset.get_path_name())

    unreal.log(asset.get_class())

    unreal.log(type(asset))

    unreal.log('#####################')

    A way of repurposing a class by taking an existing class out of context, and using it how you want it.

Say you wanted to make a blueprint with a python script. Unreal python has 'factorys' where you create assets. So if you want a blueprint, you need to make a BlueprintFactory. 

    Example script to make several blueprints depending on the parameters you give

import unreal

import sys

blueprintName = "AStreamingBlueprint"       #name of the blueprint

blueprintPath = "/Game/MyClassBlueprints"   #where we will put it

createdAssetsCount = int(sys.argv[1])       #gives us the first parameter the user will input

createdAssetName = str(sys.argv[2])         #gives us the second parameter the user will input

factory = unreal.BlueprintFactory()         #factory to make blueprint

factory.set_editor_property("parent_class", unreal.GameMode)  #changing the parent class

assetTools = unreal.AssetToolsHelpers.get_asset_tools()

for i in range(createdAssetsCount):

    assetName = f'{createdAssetName}_{i:02}'

    unreal.log(assetName)

    myAsset = assetTools.create_asset(assetName, blueprintPath, None, factory)      #creating the blueprint

    unreal.EditorAssetLibrary.save_loaded_asset(myAsset)        #will save your asset, it will not save automatically

    Putting 'createAssetWithArgs.py 3 FUBAR' in the command will create 3 blueprints. 

A Crash Intro to Color - Color Operations and Linear Lighting

 Linear Color Vs Perspective color and Basic Color Operations

Color doesn't exist, it's only your head trying to make sense of the electromagnetic signals. Light is an electromagnetic wave. When it is around it bounces all over the place. Without light reality still exists.

    The phenomenon of color happens inside of our eyes. Light bounces into our eyes as photons through our Cornea., some is absorbed in surface as heat, some of it reach the back of our eye and stimulate the nerves (retina) in the back of our eye. Colors are read through cones. Humans only have three color receptors in our retinas. With it we can see approximately 10 million Colors.

Light Breakdown

Because we have three different types of receptors:

    You can see we have three waves here. The shortest wave corresponds with blue, so we don't see blue as well. We are most sensitive to green. (That's why night vision goggles are green, it picks up the most amount of information for us. 

    Types of Color:

• Additive
• Subtractive
• HSV/HSL
• YUV (Y- brightness, U- blues and greens, V- reds and yellows; used for transmitting signals for cathode-ray tube tvs in Europe) (also called PAL)

• YIQ (Y - brightness, I - blues and reds, Q- greens and magenta; used for transmitting signals for cathode-ray tube tvs in America)(also called NTSC)
• YCbCr (Y- brightness, Cb- blue and yellows, CR- greens/cyan and reds/magenta)(also known as MPEG/JPEG/HDMI)

We Describle Colors using color models. Abstract representations of colors as tuples of numbers: 

• RGB is an additive color model as a tuple (r,g,b). projected as white light
• CMYK is subtractive and a tuple (c,m,y,k). colors are absorbed

24 Bit RGB means you have 8 bits per color = 256 shades. 24 = 8+8+8

    Gamut is like the footprint a color model. Not all display devices are created equal

    Photo Real Test

1. Can an image be captured with real colors?
2. Can a photo real image be rendered based on the input?
3. Can the image display accurately on a device?

Emission vs Perceptual

Nominal Light Emission is Linear. It is additive color. Each bar is increasing in value at the exact same speed. This is what real light is. 

Perceptual Light is Gamma (sRGB). This slows down the transition so we don't go to the bright whites as fast. It happens right before an image shows up on your display. These are false colors. 

Gamma Color Space (sRGB)

    All recording and display devices record and display in 'Gamma' color space. When you look at any display you are looking at a lie!

    When performing operations on colors:

1. Convert color to linear color space
2. Perform operations on color
3. Convert back to gamma (sRGB) color space

When writing out to Bitmap and not to materials:

all base color and diffuse -> sRGB

all others -> Linear

    
    This is a MacBeth charts, each piece has a linear color associated with it. You can use it to calibrate and make sure the colors show up true. 

Project Management Notes

 Facility

    How many branches does your company have? Are you in games, cinematics, Real Time VFX, Location based entertainment, commercial, film, or services (outsourcing)?

    How many Projects is each branch working on? How long does each Project take? A commercial could take a month, while a AAA game could take 5+ years. If it takes several years, how often do new versions of your DCC release. Is it possible for different projects to be working on different versions of software? You could be working on two games, one has been going for 4 years and another that you've just started? Are you using different versions of blender for it now? How are you controlling that your artists are using the correct DCC for the correct project?

    DANGER: NEVER IF POSSIBLE CHANGE SOFTWARES DURING A PROJECT!!!

    What is the folder structure for your project's destination? Where is it in engine. Or are you delivering assets to another company. How is the folder structure you're delivering these outsources assets? What is the file structure for your art depot? Do they match?

    How is art delivered into the engine? Is it done through DCC Output? Do your artists know what file to output? For Texture formats (png, jpeg)? Intermediate data formats (fbx, collada, alembic, json/xml, USD, proprietary)?

    Which DCCs is your project using and which versions? What Tools are your project artists using (Plug-ins, scripts, custom versions)? How do you guarantee the artists are using the correct software? Do your DCCs have the correct configurations (plug-ins, shelves)? Do you allow your artists to use their own tools (without upsetting the integrity of the project)?

    How are your assets organized? How are your scenes/levels structured? Which files are crucial for asset reproduction? Have you lost the original source files? The intermediate formats are replaceable but the source files are necessary to keep. Game assets should not live with source assets. Your maya and blender files should be in one place, and then in another folder you should have your game assets. Your source assets should not be touched by designers. How is your structure integrated with Revision Control? Do you have non-authorable assets in your game?

    How are your Folders, Files, and Tools organized? As a suggestion (you can change this as long as you stay consistent), have Three separate Levels: 

1. Facility/Branch (logos, promotional materials, literature, marketing, things that could effect the whole company)
2. Project/Show (Master Materials, Master Textures, fundamental assets that can go into any scene at anytime)
3.  Shot/Level Asset (belongs to a separate subset of a level or a shot. Exclusively in a shot or level. You can't mix up the assets in the different shots/levels they have to have separate places)

    The structure of each of these Folders should all be the same. All Lower Levels have access to upper levels, but upper levels don't have access to the lower levels. 

    All three levels should contain the same content structure:

• Tools (These are custom tools controlled by the level)
• Assets (These are art contents - source assets and game ready assets)
• Configurations (xml or json files controlling meta data, files which explain entire level structure, always present, may be hidden from 'user perspective')

    How can you guarantee the correct assets are used in game?

    You wanna also track metrics: Which DCCs are being used (how often and by whom?) How many textures are there? (format size by whom)? How many geos are there? (format, size and by whom)? How many different animation clips? How much memory do they consume? How are you going to keep track of all this information?

    How does your Project Management Tool Interface? Command Line? (Management commands, directory, jumping, directory listing) GUI? (browsing, searching) DCC Collaboration? (DCC support, third party support)

    PMT Responsibilities

• Create initial folder structures
• facility/project/individual assets
• all levels must have same structure
• tools/assets/configurations
• any should be able to navigate/manipulate
• create proxy placeholders
• asset/level/shot
• Empower correct computer configuration for each level
• Department/project/asset
• correct DCCs/versions/plug-ins/scripts/customizations
• Artists may transition
• from department project asset

Examples: Shotgrid, Rex, Anaconda