Niagara: What’s New | Live Training | Inside Unreal


>>AMANDA: HEY FOLKS!
WELCOME TO THIS WEEK’S
UNREAL ENGINE NEWS
AND COMMUNITY SPOTLIGHT.
WE ARE THRILLED TO ANNOUNCE
THE WINNERS IN OUR FIRST
EVER UNREAL AWARDS:
EXPERIENCE DESIGN COMPETITION,
AS WE SET OUT TO FIND
DESIGN INNOVATORS
USING UNREAL ENGINE
FOR ARCHITECTURE,
MANUFACTURING,
AND PRODUCT DESIGN,
AND WE WEREN’T DISAPPOINTED.
BE SURE TO LOOK AT THE BLOG
TO SEE THE FULL LIST OF WINNERS.
CONGRATULATIONS TO ALL OF THEM,
WHO WILL
SHARE OVER $70,000
WORTH OF PRIZES,
AND THANK YOU
TO EVERYONE WHO ENTERED,
AND OF COURSE
TO OUR GENEROUS SPONSORS:
SUBSTANCE, ESRI, AXYZ,
AND TURBOSQUID.
UNREAL ENGINE 4.22
ISN’T QUITE READY YET,
BUT YOU CAN START EXPERIMENTING
WITH ITS NEW FEATURES TODAY
WITH THE RELEASE
OF 4.22 PREVIEW 1!
PREVIEW 1 INCLUDES SUPPORT
FOR REAL-TIME RAY TRACING,
EDITOR UTILITY WIDGETS, MOVABLE
SPOTLIGHT SUPPORT ON MOBILE,
VIRTUAL PRODUCTION UPDATES,
OCULUS QUEST SUPPORT,
AND BLUEPRINT
INDEXING OPTIMIZATIONS.
A FULL LIST OF THE UPCOMING
CHANGES TO THIS BUILD
ARE AVAILABLE ON THE FORUMS
AND, AS ALWAYS,
WE’D LOVE ANY FEEDBACK
ON THE CURRENT PREVIEW.
DO KEEP IN MIND THAT PREVIEW
RELEASES ARE INTENDED
ONLY TO PROVIDE A SAMPLE
OF WHAT WILL BE RELEASED
AND THEY ARE NOT
PRODUCTION-READY.
FOR NOW, PLEASE USE COPIES
OF YOUR PROJECTS
TO TEST NEW FEATURES.
IN OUR LATEST TECH BLOG,
UNREAL DEV GRANT RECIPIENT
AND MELBOURNE-BASED
INDIE STUDIO
BIT DRAGON EXPLAINS
HOW THEIR SMALL TEAM
SHIPPED THE FAST-PACED
ARENA BRAWLER
HYPER JAM, THE TEAM’S
FIRST TITLE, ON PC, PS4,
AND XBOX ONE WITH LOCAL VERSUS,
PRIVATE ONLINE,
AND CROSS-PLATFORM
MATCHMAKING.
DIVE IN AND SEE HOW THEIR TEAM
ACCOMPLISHED THIS AMBITIOUS FEAT
AND GIVE HYPER JAM A WHIRL.
VLADIMIR MASTILOVIC,
3LATERAL FOUNDER AND DIRECTOR,
JOINS OUR LATEST PODCAST
TO TALK ABOUT THEIR AMAZING,
REAL-TIME
FACIAL-CAPTURE TECHNOLOGY,
HOW NEW DEVELOPMENTS
WILL CHANGE FILMMAKERS’ APPROACH
TO DIGITAL PERFORMANCE
IN VIRTUAL PRODUCTION,
AND HOW HE’D LIKE TO
SHARE IT WITH THE WORLD.
GO LISTEN TODAY TO ALSO HEAR
ABOUT HOW 3LATERAL PLANS
TO CONTINUE THEIR WORK AS PART
OF THE EPIC GAMES FAMILY.
NOW FOR THIS WEEK’S KARMA
EARNERS!
MANY, MANY THANKS TO:
CHYROS, THOMPSONN13,
NEBULA GAMES INC,
SENSEIHAKETON,
MAVERICK_TANGO, TUERER,
SHADOWRIVER, MIGHTYENIGMA,
RAXS_SLAYER,
AND BRIAN JOHNSTONE.
HEAD OVER TO ANSWERHUB,
SHARE YOUR UE4 KNOWLEDGE
AND YOU COULD HEAR
YOUR NAME UP HERE TOO!
AND NOW FOR OUR SPOTLIGHTS!
FIRST UP IS THE ADORABLE FARMING
SIM SNACKO, IN DEVELOPMENT
BY A HUSBAND AND WIFE DUO!
IN SNACKO, YOU’LL FARM, FISH,
MINE, COLLECT,
AND BUILD YOUR WAY
TO A PROSPEROUS TOWN
THAT’S UNDER YOUR CONTROL!
WITH A WORKFLOW INSPIRED
BY OCTOPATH TRAVELER,
YOU’LL TRAVERSE DUNGEONS
AND SOLVE PUZZLES
TO FIND NEW FRIENDS
THAT YOU CAN RECRUIT IN THE 2D
AND 3D BLENDED WORLD.
A PUZZLE GAME WITH LOADS
OF EXPLOSIONS,
MR BOOM’S FIREWORK FACTORY
IS OUR SECOND SPOTLIGHT!
IN IT, YOU’LL TRY TO SHIP
YOUR CRATES
IN THE CORRECT ORDER
WITHOUT DESTROYING THEM,
WHICH SEEMS LIKE
AN AWFULLY TRICKY TASK.
AND FINALLY, INSPIRED BY
THE ART STYLE OF DARKSIDERS,
GO ‘ RIM CREATED THE FORGE,
A COOL, MOODY
DUNGEON-ESQUE SCENE.
WE REALLY ENJOY THE COMPETING
WARM AND COOL ELEMENTS
USED TO BALANCE THE ENVIRONMENT.
VERY NICE WORK!
AND THAT’S ALL FOR THIS WEEK’S
NEWS AND COMMUNITY SPOTLIGHT
THANKS FOR JOINING!
>>AMANDA: HEY, FOLKS.
WELCOME TO OUR
UNREAL ENGINE LIVESTREAM.
I’M YOUR HOST, AMANDA BOTT.
WITH ME THIS WEEK,
WE HAVE WYETH JOHNSON,
OUR LEAD TECHNICAL ANIMATOR,
AND A RESIDENT
NIAGARA EXPERTS.
>>WYETH JOHNSON: HEY,
GUYS.
>>AMANDA: — SO
THANK YOU FOR JOINING US.
>>WYETH: IT IS
MY PLEASURE.
>>AMANDA: AND FELLOW
COMMUNITY MANAGER, VICTOR BRODIN.
>>VICTOR: I’M BACK.
>>AMANDA: SO TODAY,
WE’VE GOT —
WELL, WE’RE DOING
WHAT’S NEW IN NIAGARA.
>>WYETH: YEP.
>>AMANDA: SO WE WILL BE
GOING OVER THE NEW FEATURES
AND CHANGES THAT HAPPENED
IN THE LAST SIX MONTHS
SINCE WE HAD YOU ON.
I CAN’T BELIEVE
IT HAS BEEN THAT LONG.
>>WYETH: WE HAD
SOME ENGINE RELEASES
IN THERE
AND SO WE NEEDED TO SUSS OUT
WHAT IS VALUABLE
FOR PEOPLE TO SEE,
NOT JUST WHAT’S
COMING UP IN 4.22,
BUT MAYBE WHAT WE MISSED
IN 4.21 AND SO ON.
>>AMANDA: AWESOME.
AND TODAY IS ALSO
OUR WINTER UE4 JAM KICKOFF.
SO HANG TIGHT, WE WILL HAVE
LOTS OF WONDERFUL INFORMATION
COMING VERY SHORTLY,
AND THEN WE’LL HIT YOU
WITH A THEME ANNOUNCED
LATER IN THE STREAM.
SO FEEL FREE TO DIVE IN
AND BESTOW YOUR KNOWLEDGE
UPON OUR COMMUNITY.
>>WYETH: LET’S DO IT.
I CAN’T WAIT.
SO THE — NIAGARA IS IN
A GOOD STATE RIGHT NOW
BECAUSE WE ARE STARTING
TO ROUND OUT THE SET OF FEATURES
THAT MOST PEOPLE
WOULD FEEL LIKE THEY REALLY,
REALLY NEED TO MAKE
THE MAJORITY OF THINGS.
YOU KNOW, WHEN WE FIRST
WENT INTO EARLY ACCESS,
WE HAD A COUPLE
OF BIG MISSING PIECES,
SOME THINGS
THAT YOU JUST KIND OF,
IF YOU WERE THINKING ABOUT
A FORWARD-LOOKING TOOL
AND REALLY PUSHING FORWARD
TO THE FUTURE,
IT WOULD BE STUFF
THAT WAS MISSING.
NOW AS WE MOVE INTO 4.22,
WE ARE STARTING TO SCRAPE OFF
THE ROUGH EDGES A LITTLE BIT.
>>AMANDA: RIGHT.
>>WYETH: NOW
I THINK WOULD BE A GREAT TIME,
IF YOU HELD OFF
PLAYING WITH THE TOOL,
BECAUSE YOU ARE —
“WELL, I’M WORKING IN CASCADE,
IT IS FAMILIAR TO ME,
MAYBE I’M IN A SHIP CYCLE”
OR SOMETHING LIKE THAT.
I THINK RIGHT NOW, 4.22 IS THE
RIGHT TIME TO MAYBE PICK IT UP
BECAUSE I THINK
YOU WILL FIND THERE
ARE FEWER SHARP CORNERS TO —
>>AMANDA: GOOD.
>>WYETH: — TO CATCH
YOUR FINGERS ON, SO TO SPEAK.
>>AMANDA: THAT’S
IMPORTANT.
>>WYETH: SO I THINK
PROBABLY WHERE WE SHOULD START
WOULD BE TO GO BACK
TO THE EXAMPLE HALL,
WHERE WE LEFT OFF LAST TIME.
>>AMANDA: UH-HUH,
BACK TO THE HALLWAY.
>>WYETH: SO INTREPID
VIEWERS
WHO WERE WATCHING LAST TIME
WHO WOULD KNOW
WE DIDN’T MAKE IT
TO THE END
OF THE EXAMPLE HALL,
AND WE HAVE ONE NEW EXAMPLE
WE’VE ADDED IN THE MEANTIME,
AND WE CAN TALK
ABOUT THAT AS WELL.
THERE ARE ACTUALLY
SOME CHANGES
TO THE EXISTING EXAMPLES,
TO GO ALONG WITH THAT.
>>AMANDA: PERFECT.
>>WYETH: SO, I WILL
START FROM THE BEGINNING,
AND WE CAN TALK ABOUT THE THINGS
FUNDAMENTALLY WE’VE CHANGED
TO MAKE THINGS BETTER
FOR USERS,
AND THEN WE’LL GET TO THE END
OF THAT HALL, SHOW THE STUFF —
>>AMANDA: WE WILL FINALLY
SEE WHAT’S IN THE OTHER ROOM.
>>WYETH: —
THAT SECRET ROOM THREE,
YEAH, THERE’S SOME PRETTY
COOL STUFF IN THERE.
AND THEN I’VE GOT A BIG LIST
OF OTHER THINGS
NOT NECESSARILY REFLECTED
IN THE CONTENT EXAMPLES,
BUT JUST STUFF WE’RE WORKING ON.
AND I TALKED WITH SHAWN
A LITTLE BIT EARLIER TOO,
AND HE’S OKAY IF WE TEASE
A FEW THINGS
THAT AREN’T QUITE READY
FOR 4.22,
BUT THEY ARE COMING.
>>AMANDA: AWESOME.
>>WYETH: SO
WE’LL DROP A FEW
FOR YOU SO YOU KNOW,
YOU CAN PREDICT —
>>AMANDA: LITTLE
TREATS.
>>WYETH: — YEAH,
LITTLE TREATS,
AND STUFF THAT WE KNOW
IS COMING.
SO, YEAH, LET’S GET INTO IT.
SO ONE THING I WANTED TO FIRST
START OFF WITH IS, WE —
ALL THESE EXAMPLES WILL LOOK
THE SAME AS THEY DID FROM
WHEN YOU SAW IT LAST TIME.
HOWEVER, UNDER THE HOOD,
WE MADE A COUPLE OF CHANGES
TO MAKE THINGS A LITTLE
EASIER FOR YOU TO RE-CREATE
THEM OR DERIVE FROM THEM.
SO I WILL SHOW YOU
ONE OF THOSE.
IF I SELECT THIS EMITTER HERE
AND I OPEN IT,
SO ONE OF THE FIRST THINGS
THAT WE’VE DONE IS WE REALIZED,
AS WE WENT THROUGH– THERE’S
A NUMBER OF ATTRIBUTES
YOU GENERALLY
ALWAYS CARE ABOUT.
>>AMANDA: UH-HUH.
>>WYETH: AND THESE MIGHT
BE JUST POINT ATTRIBUTES,
LIKE HOW LONG
DOES SOMETHING LIVE,
OR WHAT ARE ITS —
THE SIZE OF ITS SPRITES,
OR THE COLOR
YOU ARE WRITING TO IT.
THESE ARE REALLY COMMON THINGS.
BEFORE, IN THESE EXAMPLES,
WE WERE WRITING
TO THE ATTRIBUTES
THAT DRIVE THOSE DIRECTLY.
SO, FOR EXAMPLE, I WOULD GO IN
AND, YOU KNOW,
WRITE TO PARTICLE LIFETIME,
FOR EXAMPLE,
OR TO PARTICLE COLOR.
AS A WAY TO MAKE IT
A LITTLE EASIER FOR PEOPLE,
WE HAVE NOW CREATED THIS
INITIALIZED PARTICLE MODULE.
THIS MODULE
COMES ALONG FOR THE RIDE
IN ALL OF OUR TEMPLATES NOW.
SO, IF I HAVE
BASIC ATTRIBUTES —
I JUST WANT SOME SPRITES
OR SOME MESHES,
OR SOME RIBBONS TO FLY AROUND,
ALMOST ALL OF THE SET-UP WORK
I WOULD NORMALLY DO
IS HERE IN THIS WINDOW.
AND SO I CAN SAY,
“YOU KNOW WHAT I WANT TO SAY
THE LIFETIME OF MY PARTICLES.
I WOULD LIKE TO INITIALIZE
THEIR MASS,” —
I WILL GET TO MASS
IN A SECOND,
BECAUSE I WILL SPEND SOME TIME
TALKING ABOUT MASS.
“I WOULD LIKE TO INITIALIZE
THEIR COLOR
OR, YOU KNOW,
CREATE A SPRITE SIZE
FOR WHEN THEY SPAWN,”
THOSE KIND OF THINGS.
WE PACKED ALL OF THESE
INTO ONE SPACE,
AND OFTEN TIMES WHAT’LL HAPPEN
IS YOU WILL FIDDLE WITH THESE
UNTIL YOU GET THEM RIGHT,
AND THEN YOU DON’T
NEED THEM ANYMORE,
SO IT IS NICE TO COLLAPSE
ALL OF THIS INITIALIZATION
STUFF ALL IN ONE SPOT.
THAT’S THE FIRST THING
WE’VE DONE WHICH,
IS JUST A HELPER FUNCTION,
BUT IT IS SOMETHING THAT KIND OF
GETS PEOPLE
ROLLING A LITTLE BIT
MORE QUICKLY.
THE OTHER THING YOU’LL NOTICE
IS THAT THESE ARE CONDITIONAL,
AND KIND OF BEHIND
AN IF STATEMENT,
WHICH SAYS, IF I DON’T WANT
TO WRITE TO POSITION,
I JUST UNCHECK THE BOX,
AND SO THAT GIVES PEOPLE
A LITTLE BIT OF FLEXIBILITY
TO DECIDE WHAT TO WRITE TO
AT ANY GIVEN SITUATION.
AND YOU’LL SEE THAT ACROSS
ALL OF THE DIFFERENT
CONTENT EXAMPLES
THAT ARE HERE IN THE HALL.
THE — THESE GUYS
ARE ALL THE SAME,
AND YOU SHOULD GO BACK
AND WATCH THE PREVIOUS VOD
IF YOU WANT ME TO TALK IN DEPTH
ABOUT WHAT EACH ONE OF THEM
IS DOING.
WE’VE UPDATED A COUPLE
OF MODULES HERE AND THERE,
A COUPLE LITTLE REFERENCES
INSIDE OF THEM,
BUT THE BEHAVIORS ARE BASICALLY
THE SAME ACROSS THESE.
YOU WILL NOTICE A COUPLE
OF SUBTLE THINGS.
FOR EXAMPLE,
THIS LOOKS SMOOTHER NOW.
SO THIS IS OUR STATIC
BEAM EXAMPLE.
AND THE — THIS IS BASICALLY
JUST A SIMPLE EXAMPLE
OF SPAWNING BEAMS THAT HAVE
A START POINT AND END POINT
AND IT CALCULATES A BUNCH
OF POINTS IN BETWEEN
AND THEN THOSE POINTS
SIMULATE AWAY OVER TIME,
USING FORCES AND SO ON.
IN 4.21,
THIS HAS A LITTLE BIT OF,
KIND OF, KINKING
AND INTERRUPTIONS IN THE SHAPE,
AND THAT WAS DUE TO SOME
PROBLEMS WITH OUR CURL NOISE.
OUR PREVIOUS CURL NOISE
CALCULATION WAS FINE,
BUT IT WASN’T REALLY
DOING THE JOB.
IT WASN’T WHAT THEY WOULD
CALL DIVERSIONS FREE,
WHICH MEANS A PERFECTLY
CONTIGUOUS, SMOOTH FIELD.
THE APPROXIMATIONS
WE WERE USING JUST —
THEY WEREN’T WHERE
YOU WOULD WANT.
AND SO WE WENT BACK IN AND,
FROM THE GROUND UP,
REWROTE CURL NOISE.
A LOT OF TIMES
IN CASCADE,
PEOPLE WOULD USE VECTOR FIELDS
TO JUST GET,
KIND OF, GENERAL NOISE
ON THEIR PARTICLE.
>>VICTOR: RIGHT.
>>WYETH: YOU PUT IN
A VECTOR FIELD,
I JUST WANT SOME ERRATIC ERRATIC
NATURE TO THE LOOK OF MY THING,
THAT IS SO COMMON.
ANYTHING LINEAR
TENDS TO FEEL BORING.
>>AMANDA: RIGHT.
>>WYETH: YOU WANT TO
INTRODUCE A BIT OF NOISE
IN THERE ALONG THE WAY,
AND WE SUPPORT VECTOR FIELDS,
AND I WILL TALK
MORE ABOUT THE NEW
VECTOR SUPPORT WE
HAVE IN NIAGARA.
BUT, OFTEN TIMES,
IF YOU JUST WANT A LITTLE NOISE,
YOU CAN JUST DROP
SOME CURL NOISE IN.
>>AMANDA: HUH.
>>WYETH: SO GO IN
AND CHECK OUT THE CHANGES
TO CURL NOISE,
IT SHOULD BE MORE ROBUST NOW.
SOME SCALE FACTORS
HAVE CHANGED,
SO IF YOU HAD AN EMITTER IN 4.21
THAT USES CURL NOISE,
THE SCALE OF THAT NOISE
MIGHT BE DIFFERENT NOW.
IF YOU ARE WONDERING
WHY YOUR EFFECT
LOOKS A BIT DIFFERENT,
THIS IS WHY.
BUT I PROMISE YOU —
>>AMANDA: BECAUSE
ONGOING CHANGES.
>>WYETH: — IT IS
FOR THE BETTER,
BECAUSE THAT IS NOW A REALLY
NICE, SMOOTH NOISE RESULT.
>>AMANDA: YEAH,
THAT’S BEAUTIFUL.
>>WYETH: UM, NOTHING NEW
IN ANY OF THESE.
ALL OF THESE ARE
PRETTY MUCH UNCHANGED,
I’M GENERATING EFFECTS
WITH EXPRESSIONS AND SO ON.
YOU’LL NOTICE SOMETHING FUNNY
HERE WHICH IS,
IN THIS EXAMPLE,
THE COLLISIONS ARE BROKEN.
AND YOU MIGHT SAY, WYETH,
WHY ARE YOU SHOWING ME
BROKEN COLLISIONS?
WELL, THAT IS BECAUSE
THIS PARTICULAR BUILD,
JUST THE ONE THAT I CHOSE
THAT HAD OTHER EXAMPLES
FOR YOU GUYS IN IT,
DOES NOT HAVE OUR
LATEST AND GREATEST
COLLISION STUFF.
>>AMANDA: UH-HUH.
>>WYETH: SO, IN FACT,
I WILL TAKE A PIT STOP IN A SEC
AND TALK ABOUT COLLISION
IN A MINUTE.
I WANT TO GET TO THE END OF THE
HALLWAY, AND THEN
TALK THROUGH THOSE.
BUT WE WILL DEFINITELY
REVISIT COLLISION, BECAUSE
THERE’S SOME PRETTY NICE
STUFF COMING THERE.
>>AMANDA: TO
REITERATE FOR THE FOLK
THAT MAYBE HAVEN’T
WATCHED THE LAST STREAM,
WHERE DO THEY GO
TO GET THIS HALL?
>>WYETH: YEAH, SO YOU
BASICALLY GO TO THE LAUNCHER,
YOU GO INTO THE LEARN TAB —
THAT’S THE MOST IMPORTANT
THING TO KNOW,
IF YOU ARE SEARCHING
FOR MARKETPLACE ASSETS,
YOU WON’T FIND
THE CONTENT EXAMPLES.
THEY ARE IN A VERY
DEDICATED PLACE CALLED LEARN.
SO GO TO LEARN, AND THERE,
THERE’S A PROJECT,
A UPROJECT CALLED
CONTENT EXAMPLES.
AND THERE’S A NIAGARA.UMAP
IN THERE.
YOU OPEN IT UP
AND YOU GET A WHOLE HALLWAY
AND ALL THE EXAMPLES ARE THERE.
AND IF THESE EXAMPLES
USE ADDITIONAL,
CUSTOM-WRITTEN MODULES,
FOR EXAMPLE,
THE NEXT EFFECT WHICH I’M
GOING TO TALK ABOUT,
HAS SOME MODULES THAT WERE
WRITTEN BY JOHN LINDQUIST,
A BRILLIANT TECH ARTIST,
BY HAND,
AND HE INCLUDED THEM
IN THE CONTENT EXAMPLES
SO PEOPLE CAN ALSO SEE HOW YOU
MIGHT DEVELOP YOUR OWN WORK
OUT SIDE OF THE CONTEXT
OF OUR PLUGIN.
BECAUSE NIAGARA IS A PLUGIN.
SO IT IS SITTING THERE
OFF TO THE SIDE,
IT HAS ITS OWN CONTENT DIRECTORY
WITH FUNCTIONS, MODULES,
AND ALL OF THESE BEHAVIORS —
>>AMANDA: AND YOU
CAN ADD TO IT.
>>WYETH: — BUT THERE IS
NOTHING TO SAY
THAT YOU CAN’T MAKE
YOUR OWN MODULE
ANYWHERE YOU WANT
IN YOUR OWN CONTENT TREE
AND BRING IT INTO THE TOOL.
THIS WILL SHOW YOU
SOME OF HOW THAT WORKS.
OKAY, SO THIS IS THE FIRST PLACE
THAT WE DIDN’T MAKE LAST TIME,
WHICH IS THE CONCEPT
OF SAMPLING A STATIC MESH.
>>AMANDA: UH-HUH.
>>WYETH: SO BASICALLY
THE IDEA IS,
I HAVE A STATIC MESH, THE STATIC
MESH HAS VERTEX COLORS,
SO EACH VERTEX KNOWS
WHAT COLOR IT IS
BY BEING ENCODED
FROM A DCC PACKAGE,
LIKE 3DS MAX OR HOUDINI
OR SOMETHING.
AND IT HAS ITS POSITIONS
IN SPACE,
LIKE HERE IS WHERE MY
ANY INDIVIDUAL VERTEX IS,
AND THEN HERE IS WHERE
THE LITTLE COORDINATE
IS BETWEEN THE VERTICES,
WHICH MAKE A TRIANGLE,
AND THERE’S ALL OF THIS DATA
HERE ON A MESH,
AND SO WE’VE WRITTEN
SOME SAMPLING FUNCTIONS
WHICH BASICALLY SAY, “OKAY,
GIVEN A LITTLE COORDINATE,
WHERE ARE YOU?
WHAT ARE YOU? WHAT IS YOUR UV,
WHAT IS YOUR NORMAL,
WHICH NORMAL DIRECTION
ARE YOU FACING,” AND SO ON.
AND SO WE HAVE AN EMITTER HERE,
I’M GOING TO OPEN THIS EMITTER
FOR YOU GUYS SO WE CAN SEE IT.
AND I’M GOING TO GO AHEAD
AND COVER THE SCREEN FOR NOW,
BECAUSE YOU SAW THAT IN ACTION.
BUT, SO WHAT’S HAPPENING HERE?
BASICALLY, THE WAY
WE THINK OF SAMPLING,
WE USUALLY DO IT
IN TWO STEPS:
THE FIRST IS WE ASK
FOR THE DATA, AND THEN WE —
IN A SUBSEQUENT MODULE,
WE ACT ON THAT DATA.
SO THAT’S WHAT
WE’RE DOING HERE.
SO BASICALLY, WE HAVE A MODULE
HERE CALLED SAMPLE STATIC MESH.
THAT STATIC MESH IS BASED
ON A STATIC MESH PARAMETER,
IT IS LIKE A DATA TYPE,
OF TYPED STATIC MESH.
THIS IS ONE OF THESE NIAGARAISMS
WHERE WE HAVE THIS FLOW OF DATA,
“OKAY, I HAVE POINTS IN SPACE,
I HAVE A SKELETAL MESH
THAT I CARRY ABOUT,”
THAT’S A DATA TYPE
OF TYPE SKELETAL MESH,
I HAVE STATIC MESHES,
I HAVE CURVES,
FOR EXAMPLE, LIKE A CURVE ASSET,
LIKE SAMPLING A CURVE,
IT IS ACTUALLY ITS OWN
LITTLE TYPE OF DATA
THAT GETS, KIND OF, PIPED ALONG
THROUGH THE SIMULATION.
SO WE’RE BASICALLY JUST SAYING,
“HEY, SAMPLE A STATIC MESH.
ASK IT FOR ITS ATTRIBUTES.”
IN HERE,
THIS IS AS SIMPLE AS SAYING,
OF THAT LITTLE STATIC MESH THAT
I JUST EXPOSED TO THE USER HERE,
GIVEN A RANDOM COORDINATE,
A RANDOM TRIANGLE,
AND A RANDOM POSITION
ON THAT TRIANGLE,
WHAT ARE YOUR ATTRIBUTES?
AND SO I GET THE TANGENT OF IT,
I GET THE NORMAL OF IT,
I GET ITS POSITION, ITS VELOCITY
IN CASE IT’S MOVING.
I GET THE TRIANGLE COLOR,
WHICH IS THE VERTEX COLOR.
I CAN ASK FOR IT’S UV,
AND SUBSEQUENTLY,
I CAN GO AND USE THAT TO LOOK UP
AND DO A TEXTURE,
AND ASK FOR, YOU KNOW,
THE TEXTURE SAMPLE.
WE’RE BASICALLY HERE DOING THAT,
AND THEN WE PACK ALL OF THIS
INTO THESE LITTLE ATTRIBUTES.
SO I SAY, OKAY,
I’VE SAMPLED THIS INFORMATION.
I’VE GOT THIS INFORMATION,
SAVE ALL THIS ATTRIBUTES OFF.
SO IN MY LITTLE PARTICLE
PAYLOAD HERE,
I’M SAYING,
SAVE OFF THE NORMAL,
THE TANGENT, THE POSITION,
AND ALL THESE OTHER THINGS.
SUBSEQUENTLY, THOSE GET USED
IN A MODULE WHICH ACTS ON THEM.
IN THIS CASE,
I’M ASKING FOR THOSE THINGS
WHICH I JUST SAMPLED,
AND THEN I’M ACTUALLY
PUTTING THE PARTICLES
IN THOSE LOCATIONS.
SO I HAVE A DIFFERENT
MODULE, WHICH IS
BASICALLY ASKING FOR
THOSE ATTRIBUTES.
THEY COME IN ALONG THE CHAIN,
THE SAMPLED
POSITION OF THE MESH,
THE SAMPLED NORMAL OF THE MESH,
AND THEN I WRITE THOSE TO
THE ATTRIBUTES OF THE PARTICLE.
SO I SAY, “HEY, WHERE WAS
THE POSITION ON THE MESH,
I’M GOING TO MAKE
THAT MY PARTICLE POSITION.”
SO WE HAVE THIS LITTLE
HELPER MODULE HERE.
SO YOU MIGHT ASK YOURSELF,
WHY NOT DO THAT ALL IN ONE STEP,
WHY NOT SAMPLE IT
AND WRITE IT RIGHT THERE.
YOU ARE LITERALLY RE-USING IT
AS WE SPEAK.
THE REASON WE DO THAT
IS BECAUSE NIAGARA
IS COMPLETELY PROGRAMMABLE.
AND WE DON’T WANT TO PRESUME
THAT WE KNOW
HOW YOU WANT TO USE THAT DATA.
SO WE WANT TO SPLIT THE IDEA
OF ASKING FOR DATA
AND USING IT INTO
TWO SEPARATE THINGS.
SO YOU WILL OFTEN SEE US
DO THAT AS WE MAKE MODULES,
YOU WILL SEE US MAKE A SAMPLE
FOR,
LIKE, SAMPLE A VECTOR FIELD.
SAMPLE A TEXTURE.
BUT WE DON’T ACT ON IT.
WE JUST SAY, “ASK FOR IT, PACK
IT AWAY INTO SOME ATTRIBUTES.”
AND NOW YOU KNOW, SO TO SPEAK,
AND THEN WE LET THE USER DECIDE
WHAT THEY WANT TO DO WITH IT.
IN THE BEGINNING,
MOST PEOPLE ARE GOING TO SAY,
PUT IT WHERE IT’S GOING TO GO
AND WE GIVE YOU THAT FUNCTION.
IF YOU DIDN’T USE THIS,
AND YOU WANTED TO, LET’S SAY,
SAMPLE A NORMAL ON THE MESH,
AND THEN YOU WANT TO USE THAT
AS YOUR PARTICLE VELOCITY,
THEN YOU WOULD JUST GO IN
AND ADD
SOME VELOCITY INTO THE SCRIPT
AND THEN YOU WOULD LINK
THE SAMPLED NORMAL OF THE
OF THE TRIANGLE YOU ASKED FOR,
YOU WOULD LINK THAT TO SOMETHING
THAT ADDS VELOCITY.
NOW YOUR PARTICLES
WILL FLY AWAY
IN THE DIRECTION OF THE SURFACE
NORMAL OF THE TRIANGLE.
THIS IS WHY WE DON’T PRESUME
TO KNOW HOW YOU WANT TO WORK.
WE TRY TO BREAK THOSE
UP FOR YOU, BUT
WE WILL GIVE YOU THE
HELPER FUNCTIONS
IF YOU WANT TO DO
THE 99 PERCENT CASE,
SO THEY ARE THERE FOR YOU.
WHAT’S HAPPENING
IN THIS SPECIFIC EXAMPLE
IS PRETTY SIMPLE.
WE BASICALLY DO TWO THINGS.
WE SPAWN THE PARTICLES
IN A SPHERE,
AND THEN WE SAMPLE
THE STATIC MESH LOCATIONS,
AND THEN DOWN HERE,
IN THIS UPDATE SCRIPT,
WE JUST INTERPOLATE
BETWEEN THOSE TWO THINGS.
SO I’M DIRECTLY SETTING
THE PARTICLE POSITION TO BLEND
BETWEEN WHERE I SPAWNED
IN A SPHERE,
AND THEN WHAT I SAMPLED —
THE POSITION I SAMPLED
WHEN I WAS BORN ON THE MESH,
AND THEN I,
AS THE INTERPOLATION,
OR THE LERP
IN BETWEEN THOSE POSITIONS,
I USE A SINE WAVE.
SO UP HERE AT THE EMITTER LEVEL,
I’VE USED —
I’VE MADE MYSELF
A LITTLE SIN WAVE.
I MADE MYSELF AN EMITTER
LEVEL VARIABLE AND, AGAIN,
SOMETHING HAPPENING
AT THE EMITTER LEVEL
IS JUST HAPPENING,
KIND OF, ONCE.
SO, LIKE RIGHT NOW,
EMITTER UPDATE, SO EVERY FRAME,
THIS IS RE-EVALUATING ITSELF,
JUST PER EMITTER,
THAT IS NOT PER PARTICLE.
I HAVE THIS GLOBAL SINE WAVE
PER EMITTER
GOING UP AND DOWN,
UP AND DOWN, UP AND DOWN.
IT IS GOING FROM 0 TO 1,
0 TO 1, 0 TO 1.
THEN I USED THAT TO BLEND
BETWEEN MY POSITIONS.
THE PARTICLES KNEW
WHERE THEY SPAWN,
WHICH IS IN A CIRCLE.
THEY KNEW WHERE
THEY WANTED TO GO,
THE POSITION OF THE
MESH, AND THEN I JUST
GIVE THIS LITTLE
INTERPOLATION FACTOR
USING THAT SINE WAVE
TO BLEND BETWEEN THE TWO.
SO THE END RESULT
HERE IS WHERE THEY
SPAWNED, THEY SPAWNED
IN A SPHERE,
AND THEN THERE’S A SINE WAVE
THAT SAYS,
“YOU KNOW WHAT, BLEND YOURSELF
WITH THE POSITIONS.”
THEN WE ALSO DO SOME LOGIC
IN THERE
TO BLEND ITS COLOR, SO
THEY SPAWN WHITE, AND
THEN THEY BLEND TO THE
COLOR OF THE MESH,
AND THEN THEY BLEND BACK.
SO I THINK
THIS IS A GOOD EXAMPLE
BECAUSE IT SHOWS —
IT IS A LITTLE BIT —
WE PUT IT IN ADVANCE,
EVEN THOUGH IT IS A SIMPLE IDEA,
BECAUSE OF THIS CONCEPT
OF ABSTRACTING THE —
ASKING FOR DATA
AND USING IT CONCEPT.
I THINK IT IS AN ADVANCED,
NIAGARA CONCEPT.
AND ALSO, THIS IS
THE FIRST EXAMPLE,
WHICH IS STARTING TO REALLY
UNLOCK
THE POWER BURIED IN THERE,
WHERE YOU DON’T HAVE TO USE
THE STUFF
THE WAY WE THINK YOU WANT
TO USE IT.
ANY OF THE DATA
WE GIVE YOU,
GO AHEAD
AND USE IT HOWEVER YOU HAD LIKE.
THIS IS KIND OF
A FIRST EXAMPLE
OF DOING THAT IN A LIGHT WAY.
>>AMANDA: HUH.
>>WYETH: THIS
EXAMPLE IS SIMPLE.
IT’S ONLY PUT INTO ADVANCE
FOR ONE REASON:
YOU HAVE TO KNOW A LITTLE BIT
ABOUT HOW NIAGARA FUNCTIONS.
SO I SEE THESE LITTLE ARROWS
FLYING AROUND,
THESE LITTLE ARROWS
ARE PARTICLE SIM,
AND THEY’RE THE ORIGIN
OF THE PARTICLE IS RIGHT
AT THE WHITE SPOT
AT THE BOTTOM OF THE ARROW.
AND THEY FLY AROUND
AND THEY ORIENT THEMSELVES
TO THE DIRECTION OF TRAVEL.
BUT THEN YOU ALSO HAVE
THIS SECONDARY SPRITE,
AND THE WAY WE WOULD HAVE
DONE THIS IN THE PAST
IS YOU HAVE A WHOLE
OTHER EMITTER,
AND THAT SECOND EMITTER
WOULD BE TICKING AND SIMULATING
AND HAVING ALL THIS OVERHEAD
AND THEN YOU WOULD TELL IT,
YOU KNOW, I WANT TO LINK
YOU OVER TO THIS OTHER ARROW.
AND SO NOW, YOU ARE PAYING
THE COST OF TWO SIMULATIONS
IN ORDER TO GET THIS RESULT.
WITH NIAGARA,
YOU CAN SIMULATE ONCE,
AND YOU CAN RENDER
AS MANY TIMES AS YOU’D LIKE.
THAT IS INCREDIBLY POWERFUL,
THIS IS AN AMAZING OPTIMIZATION
AND A VISUAL IMPROVEMENT
IN THE AREAS
WHERE YOU JUST WANT TO RAPIDLY
LINK TWO CONCEPTS TOGETHER.
THERE’S A NUMBER OF REASONS
WHY THIS IS NICE.
>>AMANDA: HUH.
>>WYETH: IT IS
IN ADVANCE
BECAUSE IT REQUIRES YOU
TO CREATE SOME NEW ATTRIBUTES.
THIS IS ANOTHER THING
THAT’S REALLY FUNDAMENTAL
TO THE CONCEPT OF NIAGARA.
SO I’M INITIALIZING
MY PARTICLES,
MY POINTS IN SPACE,
I’M SETTING THEIR COLOR
AND THEIR SIZE
AND ALL THIS OTHER STUFF.
I’M SPAWNING THEM IN A SPHERE,
AND THEN I HAVE A LITTLE VORTEX
VELOCITY HERE,
WHICH IS DIRECTLY
SETTING THEIR VELOCITY
TO A VORTEX STYLE MOVEMENT.
I’VE CREATED MYSELF
A NEW VARIABLE,
AND I’VE DONE THIS BY GOING OVER
TO THE PARTICLES PANE
AND I JUST HIT THE PLUS SIGN.
SO I MADE MYSELF
A LITTLE VECTOR HERE,
AND IF I WANTED TO SET THAT,
I WOULD JUST DRAG IT
INTO THE STACK
AND IT WOULD DROP ME IN THIS
LITTLE SET VARIABLES NODE.
SO I MAKE MYSELF A NEW VECTOR,
I DRAG IT IN, BOOP,
AND IT APPEARS HERE
AS A LITTLE SET VARIABLES NODE.
WHAT AM I DOING IN HERE?
I’M PACKING A LITTLE EXTRA
PIECE OF DATA INTO THIS.
I HAVE THIS VECTOR,
WHICH IS MY RENDER OFFSET.
WHERE DO I WANT
THE SPRITES TO RENDER,
WHICH ARE OFFSET
FROM THE INITIAL MESH?
WHAT I DO IS, IS I ADD
THE EXISTING PARTICLE POSITION,
WHICH IS THE POSITION
OF MY FIRST PARTICLE, MY ARROW,
AND I ADD ANOTHER VECTOR
TO THAT.
SO I HAVE
THIS ROTATING VECTOR OUT HERE
THAT’S SPINNING AT A RATE OF,
YOU KNOW, I DON’T KNOW,
100 DEGREES A SECOND,
OR WHATEVER THAT MAY BE.
AND THEN I JUST HAVE THIS KIND
OF RANDOM OFFSET
FOR HOW FAR AWAY I WANT TO BE.
SO THE END RESULT HERE IS I HAVE
MY PARTICLE POSITION,
WHICH IS WHERE THE ARROW WAS,
AND THEN I HAVE
AN ADDITIONAL VECTOR
THAT IS SPINNING AROUND IT,
JUST LOOPING AROUND
AND AROUND AND AROUND.
AND THEN I MADE
A SECOND RENDERER.
SO THIS IS A KEY THING TO
UNDERSTAND ABOUT NIAGARA,
IS THAT I’M SIMULATING,
AND THEN IF I JUST CLICK
THIS PLUS SIGN,
I CAN ADD AN ADDITIONAL
RENDERER TO MY SIM.
SO YOU HAVE SEEN THAT,
I DROPPED ANOTHER
SPRITE RENDERER IN NOW,
AND NOW YOU CAN SEE
THAT I HAVE A THIRD SPRITE
THAT IS DRAWING EXACTLY IN
THE POSITION OF MY FIRST ARROW.
I CAN ADD AS MANY OF THESE
AS I WANT.
WE HAVE RIBBON RENDERERS,
WE HAVE SPRITE RENDERERS,
WE HAVE LIGHT RENDERERS,
MESH RENDERERS, AND SO ON.
THE ONLY THING I THEN HAVE
TO DO
IS LINK THE POSITION
OF MY NEW RENDERER
TO THIS NEW LITTLE ATTRIBUTE
I CREATED,
WHICH IS AN OFFSET FROM
MY EXISTING PARTICLE POSITION.
SO I GO DOWN INTO MY RENDERER,
AND YOU CAN SEE THAT THERE’S
A LINK FOR BINDINGS HERE.
NORMALLY MY POSITION
BINDING IN THE RENDERER
WOULD BE PARTICLE POSITION,
BUT IT SEES THAT THERE’S
ANOTHER VECTOR THAT I’VE MADE,
AND IT ALLOWS ME TO CHOOSE THAT
OTHER VECTOR TO
MY RENDER OFFSET.
IF I JUST SET THIS
TO PARTICLE POSITION,
NOW THEY ARE BOTH RENDERING
IN THE SAME LOCATION,
JUST LIKE THEY NORMALLY
WOULD IF I ADDED IT.
BUT IF I GO AND
FIND THAT RENDER
OFFSET I MADE, WHICH
IS JUST A VECTOR,
I HAVE
A BUNCH OF OTHER VECTORS
WHICH IT THINKS I CAN USE,
AND I COULD USE.
IF I CHOOSE THAT,
NOW THAT LITTLE OFFSET VECTOR
TAKES EFFECT.
SO GREAT OPTIMIZATION,
SIMULATING ONCE AND RENDERING
A BUNCH OF THINGS,
IS POTENTIALLY REALLY VALUABLE.
IF YOU’RE HEAVILY PERFORMANCE
CONSTRAINED,
THIS COULD BE A GREAT THING.
AND ALSO, IT’S JUST FUN
TO PLAY WITH.
I DON’T THINK WE’VE REALLY
PLUMBED THE DEPTHS
OF THIS FEATURE —
>>AMANDA: THERE’S SO MUCH

>>WYETH: — TO HAVE
THE COMMUNITY RUN WITH IT.
>>AMANDA: — THAT YOU
COULD DO THERE.
>>WYETH: THERE
IS.
>>AMANDA: AND SO MUCH
POTENTIAL.
>>WYETH: AND WE HAVE
TAKEN THIS
TO ABSURD PLACES IN OUR TESTING.
WHEN WE MAKE A HUGE SCRIPT,
WHICH IS DRIVING ALOT
OF DIFFERENT ATTRIBUTES,
AND YOU HAVE A TON OF RENDERS
WHO ARE ALL BEING DRIVEN
FROM IT.
RIGHT NOW IT GETS A LITTLE
CUMBERSOME AT SOME POINT.
YOU’RE DEALING
WITH TOO MUCH DATA —
WE WILL HAVE TO
GIVE YOU BETTER TOOLS
IF YOU WANT TO GO
REALLY CRAZY.
>>AMANDA: RIGHT.
>>WYETH:
THAT BEING SAID,
I THINK THAT WHEN PEOPLE START
TO GET USED TO THIS IDEA,
THEY WILL REALIZE
THEY DON’T NEED QUITE
AS MANY EMITTERS
AS THEY THOUGHT,
AND THAT’S JUST GONNA BE
A GENERAL PERFORMANCE WIN
ACROSS THE BOARD
FOR A LOT OF PEOPLE.
>>AMANDA: YEAH,
A LOT OF POTENTIAL
TUCKED AWAY IN THAT, I THINK.
>>WYETH: YES.
OKAY, THIS GUY.
THIS ONE SHOULD MAYBE
BE AN ULTRA ADVANCED
[LAUGHTER].
THIS EFFECT SHOULD BE
IN THE NEXT ROOM OVER PROBABLY,
AND IN THE BEST WAY.
BECAUSE IT REALLY SHOWS
HOW DEEP YOU CAN GO
IN CREATING YOUR OWN MODULES,
AND YOUR OWN BEHAVIORS,
IN LINKING TOGETHER ATTRIBUTES
AND THINGS FROM ACROSS SPAWN
AND UPDATE SCRIPTS
FROM HAVING ONE PARTICLE EMITTER
SEND EVENTS TO ANOTHER.
THERE’S JUST —
THIS HAS A LOT OF STUFF
GOING ON, BASICALLY.
AS YOU BECOME A LITTLE BIT
MORE FAMILIAR WITH NIAGARA,
THIS WILL BE WHERE
YOU’RE GONNA START TO GO
TO REALLY SEE KIND OF
A POWER USER AT WORK
DEVELOPING SOMETHING.
THIS WAS MADE BY JOHN LINDQUIST,
WHO’S AN ABSOLUTELY
BRILLIANT TECH ARTIST,
AND WHO HAS BEEN CREATING
A NUMBER OF THE MODULES
WHICH YOU GUYS ARE USING
IN NIAGARA NOW.
SO LET’S LET’S BREAK DOWN
A TEENY LITTLE BIT
OF WHAT’S HAPPENING.
THE THEORY BEHIND IT, BEFORE
I OPEN THE EFFECT, IS YOU
HAVE TWO EMITTERS. YOU
HAVE ONE PARTICLE EMITTER,
WHICH IS JUST THESE
LITTLE GLOWY SPHERES.
THEY’RE JUST FLYING AROUND
AND THEY JUST HAVE SOME RANDOM
POSITION AND VELOCITY
OR, YOU KNOW, AN ATTRACTOR
WHICH IS PULLING THEM BACK
TOWARD THE CENTER
OR WHATEVER.
I DON’T REMEMBER EXACTLY
HOW THEY’RE SET UP.
THEN YOU HAVE
A SECOND EMITTER,
WHICH IS SAMPLING
A SKELETAL MESH,
AND ASKING THAT MESH EVERY
SINGLE FRAME FOR ITS ATTRIBUTES.
WHERE IS THE —
WHERE ARE YOUR BONES,
WHERE IS THE TRIANGLE
THAT IS BOUND TO ANY GIVEN BONE,
WHAT IS THE VELOCITY OF THAT,
WHAT IS YOUR SURFACE NORMAL,
ALL THESE DIFFERENT THINGS.
WHAT ARE YOUR UVS.
THEN EVERY FRAME,
IT’S UPDATING THAT.
SO YOU CAN SEE HIM
START TO UPDATE HERE.
AND THEN AS THE SPHERES
KIND OF ENTER HIS INFLUENCE,
THEY START TO DISRUPT
THAT SAMPLING.
BUT EVERY SINGLE FRAME,
THOSE PARTICLES ARE BEING
RESAMPLED TO SAY,
“HEY, I KNOW
WHERE YOU CAME FROM.
WHEREVER YOU SPAWNED ORIGINALLY,
I WANT YOU TO GO BACK TO THERE,
AND I WANT YOU
TO ORIENT YOURSELF PROPERLY.”
>>AMANDA:
THAT’S SO COOL-LOOKING.
>>WYETH:
YEAH, IT IS VERY COOL.
AND THE OTHER THING TO NOTE
IS THAT, IF WE’RE GETTING CLOSE,
WE’RE DOING KIND OF
A COARSE APPROXIMATION
OF THE ACTUAL SHADING
OF THE MESH.
IT’S INHERITING ITS NORMALS,
IT’S INHERITING ITS ALBEDO
VALUE — THE DIFFUSE COLOR —
ITS INHERITING THE SPECULAR
COLOR FROM THE MESH.
WE’RE ACTUALLY
BASICALLY REPRODUCING
THIS MESH USING PARTICLES.
THEY TAKE A SPRITE,
THEY GET THE ATTRIBUTES
OF THE MATERIAL THAT’S APPLIED,
AND THEN THEY PUT IT ROUGHLY
WHERE IT’S SUPPOSED TO BE.
SO ONE OF THE BIG IDEAS ABOUT
WHAT IS HAPPENING IN HERE
IS BASED ON THIS CONCEPT
OF EVENTS.
SO I HAVE TWO EMITTERS.
I HAVE THE SKELETAL MESH
REPRODUCTION EMITTER.
AND THIS GUY
IS BASICALLY SAYING,
“HEY, I’M GONNA RECREATE
THIS SKELETAL MESH.”
IT DOES THAT WITH SOME
BUILT-IN SAMPLING FUNCTIONS
AND THEN SOME
BESPOKE FUNCTIONS, BASICALLY.
THERE’S THIS MESH REPRODUCTION
SPRITE MODULE,
WHICH IS KIND OF LIKE
A REALLY ROBUST VERSION
OF A BASIC SKELETON
MESH SAMPLER.
SO WE SUPPLY
IN THE NIAGRA PLUGIN,
WE SUPPLY A SAMPLE SKELETAL
MESH THING,
WHICH ALLOWS YOU
TO SAMPLE BONES OR SURFACES.
IT’S A MODULE
THAT’S AVAILABLE TO YOU.
THIS WOULD BASICALLY BE LIKE AS
IF SOMEBODY TOOK THAT,
AND THEN DUPLICATED IT AND ADDED
EXACTLY THE FEATURES THEY NEEDED
TO DO SOMETHING VERY SPECIFIC.
IN THIS CASE,
TO START TO REPRODUCE
A SKELETAL MESH IN ITS ENTIRETY.
YOU KNOW,
IT’S BASICALLY WRITING
TO THE INTRINSIC PROPERTIES
OF THE PARTICLES DIRECTLY.
IT’S SAYING, “YOU KNOW WHAT,
JUST SPAWN
AND GO RIGHT WHERE I TELL YOU.
I’M NOT GONNA
SAMPLE AND ASK FOR
DATA AND SAVE IT OFF.
I’M JUST GONNA PUT YOU
WHERE YOU’RE SUPPOSED TO GO.”
YOU KNOW,
YOU’VE GOT CONTROLS OVER
HOW LARGE THE PARTICLES ARE THAT
ARE BEING ATTACHED TO THE MESH.
YOU BASICALLY — ALL THESE
KIND OF THINGS ARE EXPOSED
TO YOU FOR WHAT’S SUPPOSED
TO HAPPEN ON THE FIRST FRAME
WHEN THE PARTICLES ARE BORN,
WHICH IS TO PUT YOURSELF
ON THE MESH, AND
THEN WHAT HAPPENS EVERY
FRAME THEREAFTER.
WHICH IS, “OKAY,
I INITIALIZED MY REPRODUCTION.
SO IF I WAS STATIC, I’M DONE.
BUT NOW I HAVE A SECOND MODULE,
WHICH IS ACTUALLY UPDATING
THIS EVERY SINGLE FRAME.”
AND SO, EVERY SINGLE FRAME,
I GO IN THERE AND I SAY,
“HEY MESH,
WHERE’S YOUR CURRENT TRIANGLE?
WHAT’S THE UV, YOU KNOW,
WHAT ARE SOME OF YOUR
OTHER PIECES OF INFORMATION?”
AND THEN I’M GONNA
PACK ALL THOSE
INTO SOME ATTRIBUTES,
AND I’M GONNA WRITE THEM
DIRECTLY OUT.
BASICALLY, THIS WOULD BE
SOMEBODY WHO REALLY KNEW
WHAT THEY WERE LOOKING FOR
TO DO SOMETHING DIFFERENT
FROM SOME OF OUR KIND OF
SUPPLIED IDEAS,
TAKING THOSE CONCEPTS,
AND CREATING SOMETHING BESPOKE.
THAT’S WHAT
YOU’RE SEEING HERE.
WHAT GETS REALLY INTERESTING
IS WHAT HAPPENS DOWN BELOW
WITH THE EVENTS.
SO WE HAVE THESE
LITTLE SPHERES HERE,
WHICH ARE YOUR INFLUENCERS.
THESE ARE JUST SPAWNING
AND THEY’RE JUST FLYING AROUND.
WE’RE JUST SETTING THE POSITION
DIRECTLY TO, YOU KNOW —
THEY’RE IN A SPHERE
AND THEY HAVE SOME VELOCITY.
THEY FLY ABOUT USING
SOME CURL NOISE AND
THEY GET ATTRACTED
BACK TO THE CENTER.
THESE ARE ALL BUILT IN MODULES
INSIDE OF NIAGARA.
AND THAT’S WHAT’S CONTROLLING
THESE ORBS
THAT ARE JUST FLYING AROUND.
THIS IS BASIC,
FUNDAMENTAL NIAGARA BEHAVIOR:
KEEPING THOSE GUYS IN PLACE
AND DOING WHAT THEY’RE
SUPPOSED TO BE DOING.
AND THEN — GO AHEAD, PLEASE.
>>AMANDA: REALLY
QUICK.
YOU WOULD —
YOU HAD SHOWN THE GRAPH,
AND THEY WERE ASKING ABOUT
THE GRAPH
INSIDE THE NODE
THAT YOU ARE EDITING.
>>WYETH: OH, YEAH.
I PROBABLY SKIPPED OVER
THAT TOO QUICKLY.
BUT YOU’RE GONNA SEE SOMETHING
SIMILAR IN BOTH THE SPAWN GRAPH
AND THE UPDATE GRAPH.
SO IF I DECIDE
THAT I WANT TO INITIALIZE
MY PARTICLE POSITIONS,
I BASICALLY —
I NEED TO KNOW
A TRIANGLE COORDINATE.
I NEED TO KNOW
WHERE I’M GONNA GO.
AND SO I CAN GET ONE RANDOMLY,
OR I COULD GENERATE ONE RANDOMLY
AND THEN SAVE IT OFF.
AND SAY
THIS TRIANGLE COORDINATE,
THIS SPECIFIC PART OF THE MESH,
THAT’S WHERE I CAME FROM.
SO INSTEAD
OF EVERY FRAME SAYING,
“I CARE ABOUT A DIFFERENT SPOT
ON THE MESH, I’M SPAWNING.
THEN I’M GONNA SAY, YOU KNOW
WHAT — AND THIS IS MY PLACE.
THIS SPOT ON THE ARM,
THAT’S WHERE I WANT TO GO TO.”
AND SO THAT’S BASICALLY CALLED
A TRI-COORDINATE.
AND THEN, INSIDE OF THAT,
YOU’VE GOT A LITTLE LOCATION
ON THE TRIANGLE
THAT IS INSIDE OF THAT
LITTLE TRIANGLE THAT YOU PICK.
JOHN HAS ALSO DONE
SOME CLEVERNESS IN HERE
TO FIGURE OUT THE SURFACE AREA
OF THAT TRIANGLE.
SO YOU COULD CRACK THIS OPEN
AND YOU CAN SEE HE’S GOT, LIKE,
SOME —
BASICALLY
SOME CALCULATIONS HERE,
WHICH CALCULATE THE AREA
BASED ON THE WORLDSPACE POSITION
OF THE THREE CORNERS
OF THE TRIANGLE.
SO HE KNOWS WHERE THE THREE
VERTICES OF THE TRIANGLE ARE
AND, THEREFORE, HE CAN ROUGHLY
CALCULATE THE AREA FROM THAT
AND THEN THAT’S HOW HE KNOWS
HOW BIG TO MAKE HIS SPRITE.
IF IT IS A BIG TRIANGLE,
HE PUTS A BIG SPRITE ON IT.
IF IT’S GOT A TINY TRIANGLE,
HE PUTS A TINY ONE ON IT.
AND THEN HE’S KIND OF SAVING
ALL OF THIS STUFF OFF
INTO ATTRIBUTES HE THINKS
HE’S GOING TO USE LATER.
SO HOW BIG IS THE TRIANGLE,
YOU KNOW, WHAT IS THE UV AREA
THAT’S TAKEN UP BY THE TRIANGLE.
WHAT’S THE MAX SIZE A TRIANGLE
OR A SPRITE SHOULD EVER BE.
HE’S BASICALLY DOING
A BUNCH OF CLEVERNESS
TO BAKE ALL OF THESE ATTRIBUTES
THAT ARE, YOU KNOW,
AVAILABLE TO HIM
EVERY SINGLE FRAME THEREAFTER.
HE ALSO DOES A COUPLE OF THINGS
WHERE,
“HEY, THAT PARTICLE IS TOO
SMALL. SO MY CALCULATED SIZE,
YOU KNOW WHAT,
I’M JUST GONNA GO AHEAD
AND KILL YOU
BY SETTING YOUR ATTRIBUTE
FOR WHETHER YOU’RE ALIVE OR NOT.
I’M JUST GONNA SET YOU TO DEAD.”
AND IT’S JUST AN EFFORT
TO REDUCE TRIANGLES OR SPRITES
THAT DON’T REALLY MAKE THAT MUCH
OF A DIFFERENCE TO THE LOOK,
JUST TO MINIMIZE PERFORMANCE
PROBLEMS, THAT KIND OF THING.
AND THEN, IN THE LAST STEP HERE,
HE BASICALLY JUST WRITES
ALL OF THOSE THINGS
DIRECTLY TO THE ATTRIBUTES
OF THE PARTICLE.
SO THAT HAPPENS
ON THE FIRST FRAME,
AND THEN EVERY FRAME THEREAFTER,
THERE’S BASICALLY THAT SAME
LOGIC IS RUNNING AGAIN,
EXCEPT HE’S NOT DOING ANY OF THE
CALCULATIONS FOR SURFACE AREA,
OR WHICH UV I AM ON THE MODEL.
HE’S ALREADY DONE ALL THAT MATH.
HE ONLY NEEDS TO DO IT ONCE
AND SAVE IT OFF.
SO REALLY, DOWN HERE
IN THE UPDATE SCRIPT,
WHICH IS WHAT HAPPENS
EVERY FRAME THEREAFTER,
HE JUST HAS TO SAY, “OKAY,
WHAT’S CHANGING ON THE MESH?”
WELL, HIS POSITION AS HE RUNS.
OKAY, SO EVERY FRAME
I’M GONNA SAY, “WELL, I KNOW
THAT I WAS SUPPOSED TO BE HERE,
AND NOW YOUR HAND’S OVER THERE?
JUST SET ME THERE DIRECTLY.”
IT’S KIND OF THE WAY TO DO IT.
SO IF YOU SLOWLY GO
THROUGH THIS MODULE,
THE INITIALIZATION MODULE,
TO SEE WHAT IT’S DOING,
YOU’LL THEN UNDERSTAND WHAT
THIS GUY IS DOING DOWN HERE?
>>AMANDA: AND HOW,
LIKE, EXPENSIVE OR HEAVY
IS THIS EFFECT?
>>WYETH: UM,
IT’S SOMEWHERE IN THE MIDDLE.
RIGHT NOW, IT’S ONLY ON THE CPU.
AND ACTUALLY, IT’S A GREAT THING
TO TALK ABOUT,
TAKE A LITTLE PIT STOP.
RIGHT NOW, SAMPLING SKELETAL
MESHES ONLY HAPPENS ON THE CPU.
AND THAT WILL PROBABLY
ALSO BE TRUE IN 4.22,
ALTHOUGH WE’LL SEE —
IT’S ONE OF THE ON THE
EDGE FEATURES WE’RE
STILL KIND OF TESTING
AND SEEING WHETHER OR NOT WE CAN
MAKE IT IN, SO IT MAY NOT.
WE ARE RIGHT ON THE EDGE OF
SUPPORTING STATIC AND SKELETAL
MESH SAMPLING ON THE GPU.
THAT OPENS THE —
BLOWS THE PERFORMANCE
DOORS OFF, RIGHT?
SO NOW YOU HAVE THE ABILITY
TO ASK FOR A LOT OF THINGS
WHEN YOU’RE SAMPLING
DATA ON THE GPU.
ORDERS OF MAGNITUDE
MORE PARTICLES COULD BE SPAWNED,
AND COULD BE, YOU KNOW, AFFECTED
BY A STATIC OR A SKELETAL MESH.
I’M HOPING
IT MAKES INTO 4.22.
IF NOT, YOU CAN GET IT
OFF OF THE PREVIEW BUILDS —
>>AMANDA: THE GITHUB.
>>WYETH: —
AND THE DEV BUILDS
AND STUFF LIKE THAT.
BUT WE’RE CLOSE,
WE’LL SEE IF THAT MAKES IT IN.
IT’S ON OUR LIST.
THE OTHER THING
THAT UNLOCKS IS THE ABILITY
TO NOT ONLY SAMPLE A, LET’S SAY,
A SKELETAL MESH ON THE GPU,
BUT ALSO SAMPLE
A CORRESPONDING TEXTURE.
BECAUSE SO — RIGHT NOW, NIAGARA
IS IN A SLIGHTLY AWKWARD PLACE
WHERE YOU CAN SAMPLE STATIC
OR SKELETAL MESHES ON THE CPU,
BUT YOU CAN ONLY
SAMPLE TEXTURES ON THE GPU.
AS SOON AS YOU CAN DO BOTH,
AS SOON AS YOU CAN ASK
FOR A MESH AND ASK FOR TEXTURES,
YOU CAN DO A LOT OF REALLY,
REALLY COOL STUFF.
LIKE, THAT COMBINATION
IS EXTREMELY POWERFUL.
>>AMANDA: YEAH.
>>WYETH: SO WE’RE
WORKING HARD TO UNLOCK
THAT FOR PEOPLE AS
SOON AS POSSIBLE, BUT
THAT IS VERY MUCH
HIGH ON OUR LIST OF,
“HEY, LET’S BLOW THE DOORS
OFF THIS THING.
LET’S ALLOW YOU
TO SAMPLE A MESH,
AND THEN SAMPLE A RENDER TARGET
AT THE SAME TIME,
AND DO REALTIME FLUID
SIMS WHERE PARTICLES
ARE SWIRLING OVER THE — “
>>AMANDA: OH MY
GOODNESS.
>>WYETH: — I MEAN,
THE DOORS
WILL BE BLOWN OFF FEATURE-WISE,
SO I’M REALLY EXCITED
TO SEE THAT HAPPEN SOON.
>>AMANDA: YEAH.
>>VICTOR: THIS
WAS THE INTENTION
ALL ALONG WITH NIAGARA, RIGHT?
>>WYETH: YES, THAT HAS
ALWAYS BEEN THE INTENTION IS,
WHEREVER POSSIBLE,
CPU AND GPU PARITY.
AND WE’RE GETTING CLOSER
THAN EVER.
>>AMANDA: THAT’S
FANTASTIC.
>>WYETH: THERE’S
NOTHING TECHNICALLY TO
STOP US OTHER THAN JUST
CODE TIME AND SO ON.
>>VICTOR: DOES THAT ALSO
ALLOW YOU TO SAY,
IF YOU’RE ALREADY HARD,
YOUR GPU IS WORKING HARD,
CAN YOU THEN CHOOSE TO MOVE
OVER SOME PARTICLES TO THE CPU?
DOES IT GIVE YOU
THAT THAT FREEDOM?
>>WYETH: MM-HMM.
SO ON THIS EFFECT HERE,
THIS WOULD NOT WORK
BECAUSE CURRENTLY YOU CAN
ONLY SAMPLE ON ONE.
BUT CHANGING THE EMITTER
PROPERTY FROM CPU
SIM TO GPU SIM
IS AS ALL IT TAKES.
ANY OF THE FEATURES
THAT ARE UNSUPPORTED
WILL JUST GRACEFULLY TURN OFF,
AND THEN ANY FEATURES
UNDER THE HOOD, PROGRAMMED
TO CHANGE WILL GO AHEAD
AND CHANGE.
WE HAVE SPOKEN ABOUT,
IN THE PAST,
DYNAMIC LOAD-BALANCING
BETWEEN CPU AND GPU.
WE HAVE NO PLANS
FOR THAT AT THE MOMENT,
BUT IS SOMETHING I THINK IS
INTERESTING, WHICH WOULD BE,
“WOW, CPU FRAME TIMES
ARE REALLY TAKING A HIT.
LET’S SWITCH THE SIM
FOR A COUPLE OF FRAMES
OVER TO THE GPU,
OR FOR, YOU KNOW, UNTIL THE
PERFORMANCE GETS MORE REASONABLE
AND THEN WE’LL GRACEFULLY
LET IT AUTO SWITCH BACK.”
THAT
WOULD BE REMARKABLE —
>>VICTOR: SOUNDS LIKE
LIKE BLACK MAGIC.
>>WYETH: WE SHOULD
DEFINITELY DO THAT,
WE’VE TALKED ABOUT IT
A NUMBER OF TIMES,
WE JUST HAVEN’T WRITTEN
THE FEATURE YET.
BUT THERE’S NOTHING —
THEORETICALLY,
THERE’S NOTHING STOPPING US
FROM DOING THAT,
OTHER THAN CERTAIN AREAS
IN WHICH IT WOULDN’T MAKE SENSE.
FOR EXAMPLE,
IF I HAVE A GPU COLLISION
WHERE I’M COLLIDING WITH
THE DEPTH BUFFER OF THE SCENE,
CPU WOULD NEVER HAVE ACCESS
TO THAT INFORMATION.
THAT’S A GPU ONLY IDEA.
CERTAIN THINGS WILL NOT
WORK IN THIS PARADIGM.
FOR A LOT OF SIMULATIONS,
I THINK YOU COULD
GRACEFULLY SWITCH.
YOU WOULDN’T EVEN NOTICE.
IT WOULD JUST HAPPEN.
SO YES, I THINK
THAT WOULD BE VERY COOL.
WE SHOULD DO THAT.
OKAY, SO THIS SECTION HERE —
THE THING THAT’S INTERESTING
ABOUT THIS —
BEFORE I MOVE ON
TO SOME OTHER STUFF,
IS THESE LITTLE ORBS
THAT ARE FLYING AROUND
ARE GENERATING A LITTLE EVENT
EVERY FRAME THAT SAYS,
“HERE’S WHERE I AM.
HERE’S WHERE I AM,
HERE’S HOW FAST THEY’RE MOVING,
HERE’S SOME OTHER INFORMATION
ABOUT ME.”
YOU’LL NOTICE
THAT THE LOCATION EVENT
IS AFTER THE SOLVER.
SO WHAT I MEAN BY THAT IS,
WE HAVE THIS SOLVER HERE
THAT SAYS, OKAY,
BASED ON MY CURRENT POSITION
AND HOW FAST I’M GOING,
HERE’S WHERE I’M GOING TO END UP
AT THE END OF THE FRAME.
WE DO THAT WORK, WE SOLVE TO
KNOW EXACTLY WHERE I’M GONNA BE,
RIGHT BEFORE
THE FRAME STARTS OVER,
AND THEN I SEND AN EVENT.
THAT ENSURES THAT
I’M AS ACCURATE AS POSSIBLE
ABOUT SENDING INFORMATION
ACROSS TO A DIFFERENT EMITTER.
AND THEN IN HERE,
IN THIS REPRODUCTION EFFECT,
I HAVE AN EVENT HANDLER.
THE EVENT HANDLER
HAS A RECEIVER
WHICH BASICALLY RECEIVES
THAT EVENT
AND ACCUMULATES THEIR INFLUENCE
ONTO THE PARTICLES THEMSELVES.
SO THOSE ORBS ARE SAYING,
“HEY, HERE I AM.”
THEN OVER ON THE MESH THAT IS
BEING REPRODUCED OUT OF SPRITES,
WE HAVE THIS
LISTENING MODULE,
WHICH IS LISTENING
FOR THAT EVENT,
AND IT’S ASKING
FOR ITS POSITION.
LATER ON, YOU’LL SEE IT ASK
FOR ITS VELOCITY.
IT JUST PACKS THOSE, YOU
KNOW, CALCULATED VALUES OFF
INTO SOME TEMP VARIABLES
THAT WE USE LATER.
THE IDEA HERE IS,
YOU YOU BASICALLY FIGURE OUT
WHAT THE SUM OF THOSE SPHERES
ARE AS THEY’RE RELATED
TO THEIR INFLUENCE
TO THE PARTICLES
ON THE GUY YOU’RE REPRODUCING.
AND THEN YOU CALCULATE
A DISTANCE BETWEEN THOSE SPHERES
AND THOSE PARTICLES
THAT IT’S INFLUENCING,
THAT WAY YOU GET LIKE
A NICE DISTANCE-BASED FALLOFF.
SO THAT’S WHAT’S HAPPENING
IN THIS LOGIC.
YOU GET A ROUGH COUNT
OF HOW MANY NUMBERS
ARE BEING INFLUENCED,
AND THEN YOU CACHE OFF
THAT INFLUENCE AS AN ATTRIBUTE
ON EACH ONE OF THE PARTICLES
THAT ARE BEING INFLUENCED.
AT THE VERY END
OF THIS WHOLE THING, WE SAY,
HEY, ARE YOU BEING INFLUENCED
BY THE BUDDIES
THAT ARE FLYING AROUND?
THAT’S REALLY ALL THIS MODULE
IS ANSWERING IS,
AM I RECEIVING INFLUENCE?
YES. IF SO, THEN UP IN THE
UPDATE SCRIPT FOR THE PARTICLE,
WE USE THAT VALUE TO INTERPOLATE
BETWEEN RANDOM POSITIONS
AND THE POSITION ON THE MESH.
SO, YOU KNOW, THIS — AGAIN,
THIS IS A VERY POWER
USER-Y IDEA HERE.
THERE’S A LOT OF CONCEPTS HERE.
YOU CAN SEE THERE’S EXPRESSIONS
IN HERE WHERE HE IS WRITING
HLSL DIRECTLY HERE
JUST FOR CONVENIENCE,
HE’S SENDING EVENTS,
HE’S WRITING CUSTOM MODULES
TO RECEIVE THEM,
WRITING CUSTOM MODULES
TO BLEND PARTICLE
ATTRIBUTES BETWEEN THE THE
NEW POSITION IN THE OLD ONE.
THERE’S A LOT GOING ON IN HERE
BUT,
AS YOU GET A LITTLE BIT FURTHER
DOWN INTO THE BONES OF THE TOOL,
THIS IS THE THING
THAT WILL START
UNLOCKING SOME IDEAS FOR USERS.
SO IT’S A REALLY COOL EFFECT.
I LOVE IT.
>>VICTOR: IT IS.
>>WYETH: I COULD LOOK
AT IT ALL DAY.
OKAY, SO MOVING ON,
THIS IS THE NEW EXAMPLE
THAT WE ADDED
INTO THE CONTENT EXAMPLES,
WHICH IS THAT YOU CAN NOW
SAMPLE TEXTURES ON THE GPU.
SO YOU CAN SEE HERE,
WE HAVE A TEXTURE
OF THE UNREAL ENGINE LOGO.
IT’S A REALLY,
REALLY SIMPLE EFFECT.
BASICALLY, WHAT WE DO IS
IS WHEN THE PARTICLE SPAWNS,
WE SAMPLE THIS TEXTURE.
YOU MIGHT ASK, WELL,
WHAT DID YOU USE FOR UVS
TO SAMPLE THAT TEXTURE?
THE TRUTH IS, YOU CAN PASS
ANYTHING IN.
YOU, HAVE KIND
OF TOTAL CONTROL OVER WHICH
UVS YOU WOULD USE
TO SAMPLE THE TEXTURE.
WHAT WE’RE DOING,
IN THIS EXAMPLE,
IS YOU’RE LAYING OUT
THE PARTICLES IN A GRID.
SO WE BASICALLY HAVE THIS —
JUST MOVE THIS OVER —
YOU CAN SEE HERE WE’VE GOT
THIS GRID OF PARTICLES THERE,
AND ALL OF THEM ARE JUST BEING
SPAWNED PERFECTLY IN A GRID.
AND WE COULD ALMOST CONSIDER
THOSE OUR PIXELS
FOR THE PURPOSES
OF SAMPLING THE TEXTURE.
AND THEN, ONE OF THE THINGS THAT
THIS GRID LOCATION MODULE DOES,
IF I SHOW OUTPUTS, WHICH ARE —
THEY ARE SHOWN, WHICH IS NICE,
IF I GO DOWN TO THE OUTPUTS.
IT IS OUTPUTTING A GRID UV.
SO THIS WOULD BE AS FAR
AS THE GRID LOCATION GOES,
WHERE AM I ON THIS LITTLE GRID
THAT I GENERATED,
WHAT IS MY POSITION.
TURNS OUT, THAT COURSE
CORRELATES PERFECTLY
WITH THE CONCEPT OF A
UV, LIKE, FROM 0 TO 1.
WE JUST SAVE THAT OFF
FOR YOU AS A SIDE EFFECT
OF WRITING YOUR PARTICLES
TO A GRID.
SINCE WE SAVE THAT OFF
FOR YOU,
WE CAN BASICALLY TAKE
THAT ATTRIBUTE
AND YOU CAN SPLIT OFF
THE ARRAY LOCATION ON THE GRID,
THE X-AXIS AND THE Y-AXIS,
AND MAKE THEM INTO
A LITTLE 2D VECTOR FOR YOU
AND APPLY THAT AS YOUR UVS.
SO NOW WHEREVER
I WAS ON THE GRID,
THAT’S WHERE I’M ASKING
FOR MY TEXTURE POSITION,
IF THAT MAKES SENSE.
EACH ONE IS KIND OF LIKE A PIXEL
ON THE TEXTURE.
THEN I INITIALIZE
THE PARTICLE.
I TELL IT HOW LONG
I WANT IT TO LIVE.
FOR THE PARTICLE COLOR,
I’VE JUST LINKED
THE SAMPLED TEXTURES COLOR
RIGHT TO THE COLOR ATTRIBUTE.
SO IN THE TEXTURE SAMPLER,
WHICH IS A MODULE THAT JUST ASKS
FOR TEXTURE ATTRIBUTES,
AND IT’S SO EASY, SO SIMPLE.
BASICALLY, ALL I’M DOING HERE
IS I HAVE A TEXTURE
WHICH I’VE ASSIGNED,
I GIVE IT MY UV,
AND THEN FROM THERE
I ASK FOR ITS VALUES.
SO HERE, I’M BASICALLY JUST
SAYING, “WHAT’S YOUR COLOR?”
AND IT’S JUST GOING TO GIVE ME
THE RGBA FROM THE TEXTURE.
AND THEN WHAT I DO
IS I BASICALLY JUST PACK
THAT RIGHT INTO THE COLOR.
NATURALLY, BECAUSE
THE A COMES ALONG FOR THE RIDE,
THE ALPHA, WHERE THERE’S ALPHA
IN THE TEXTURE,
THAT MEANS THE PARTICLE
IS INVISIBLE.
THE OTHER THING YOU
COULD DO, RIGHT
NOW YOU CAN SEE ALL
OF THE PARTICLES.
EVEN WHEN SELECTED, YOU CAN SEE
ALL THE PARTICLES.
>>AMANDA: RIGHT.
>>WYETH: YOU CAN ALSO
WRITE A MODULE THAT SAYS,
IF ALPHA EQUALS ZERO, KILL ME.
AND THAT WAY,
YOU WOULD PERFECTLY CUT OUT
AROUND YOUR TEXTURE
BEFORE YOU GET INTO THE BUSINESS
OF SIMULATING THEM.
THAT WOULD BE AN OPTIMIZATION.
IF YOU
WERE SPAWNING A
TON OF PARTICLES
AND YOU DECIDED NOT
TO SIMULATE THEM ALL,
JUST THE ONES THAT ARE
BEING BORN FROM THE TEXTURE,
THEN YOU CAN WRITE YOURSELF
A LITTLE BEHAVIOR TO DO THAT.
SO AGAIN,
100 PERCENT PROGRAMMABLE,
DO WHATEVER YOU WANT.
DOWN IN THE PARTICLE
UPDATE, WE JUST APPLY
SOME ACCELERATION AND
IT FALLS DOWNWARD.
THAT’S IT.
>>AMANDA: THAT’S IT,
NO BIG DEAL.
>>WYETH: THIS
ONE IS PRETTY SIMPLE,
BUT THE CONCEPT OF
SAMPLING THIS DATA
IS A LITTLE BIT MORE
OF AN ADVANCED THING,
SO WE PUT IT IN ADVANCED.
WE’LL PROBABLY END UP
MOVING SOME OF THESE
INTO DIFFERENT AREAS
AS WE GO FORWARD,
AND AS WE GENERATE
MORE OF THESE EXAMPLES.
OKAY, SO WE FINALLY MADE IT
TO THE END OF THE HALLWAY,
THAT IS GREAT.
SOME OTHER THINGS
I WANTED TO COVER
THAT I THINK
WOULD BE INTERESTING.
ONE WAS EARLY ON,
WHEN WE WERE TALKING
ABOUT THE INITIALIZED PARTICLE,
WE WERE TALKING ABOUT THE
DIFFERENT PARTICLE ATTRIBUTES.
ONE OF THOSE ATTRIBUTES
IN THE INITIALIZED
PARTICLE IS MASS.
SO I’M GONNA JUST OPEN
AND EXAMPLE REALLY QUICK.
WHAT WE HAVE DONE IS,
WE HAVE STARTED TO CONSIDER
MASS A FIRST-CLASS CITIZEN.
THIS IS ENTIRELY OPTIONAL.
YOU DON’T HAVE TO WORK
WITH MASS,
BUT WE THINK THAT IT UNLOCKS
SOME REALLY INTERESTING THINGS
AND IS, ALONG WITH UNLOCKING
THOSE INTERESTING THINGS,
IS ALSO POTENTIALLY A PRETTY
SIGNIFICANT OPTIMIZATION.
I’LL EXPLAIN
WHY IN A SECOND.
THE BASIC IDEA HERE,
AND IF YOU REMEMBER
WHEN I WAS TALKING ABOUT
THE PARTICLES BEING INITIALIZED,
FOR THIS EXAMPLE I’M BASICALLY
JUST SETTING MASS DIRECTLY.
BUT, IN THAT INITIALIZE
PARTICLE EXAMPLE,
MASS IS RIGHT THERE.
AND IT DEFAULTS TO ONE.
SO A MASS OF ONE
JUST MEANS IT CANCELS OUT.
YOU KNOW, IT DOESN’T FACTOR
INTO ANY OF THE CALCULATIONS.
BY DEFAULT, PARTICLES
JUST HAVE A MASS OF ONE,
WHICH MEANS MASS
DOES NOTHING.
WHY DO WE THINK MASS
IS INTERESTING?
THE BIGGEST REASON IS BECAUSE,
ALMOST EVERYTHING THAT WE DO
WHEN WE’RE MOVING PARTICLES
AROUND, IS THROUGH FORCES.
THE DEFINITION OF A FORCE
IS A, YOU KNOW,
IS MASS TIMES
ACCELERATION EQUALS A FORCE.
IN THE DEFINITION OF THE
CONCEPT, IS THE CONCEPT OF MASS.
EVERYTHING THAT WE DO
TO MOVE A PARTICLE,
OR INFLUENCE A PARTICLE,
OR FIGURE OUT HOW FAST
IT ROTATES AND STUFF,
IS THEORETICALLY AFFECTED
BY THIS VALUE.
THERE’S A REALISM
THAT COMES ALONG WITH THAT.
IF YOU GET YOUR NUMBERS RIGHT,
THEN A LOT OF THINGS
JUST KIND OF FALL
OUT OF THE OTHER END
OF THAT, KIND OF, FOR FREE.
SO A GOOD EXAMPLE WOULD BE,
I HAVE A BUNCH OF ROCKY DEBRIS.
IF I GO INTO MY MASS
AND I SET MY DENSITY TO ROCK,
AND WE HAVE SETTINGS
FOR DIFFERENT DENSITIES,
AND I GIVE MYSELF ROUGHLY
THE APPROPRIATE SETTINGS,
AND I PUT AN EXPLOSION IN THERE,
THE LITTLE PIECES ARE GONNA
FLY OFF REALLY VIOLENTLY
AND THEY’RE GONNA SPIN
REALLY RAPIDLY.
AND THEN THE BIGGER PIECES
ARE GONNA —
KIND OF LIKE THERE’S MORE
RESISTANCE TO THAT MOTION,
THEY’RE GONNA COME UP
MORE MORE SLOWLY,
THEY’RE GONNA TURN LESS RAPIDLY
, THEY’RE GONNA LAND
WITH A THUD, THEY’RE GONNA
REACH RESTITUTION,
THEY’RE NOT GONNA BOUNCE
AS HIGH, ALL THESE THINGS.
WHEN WE USED TO WORK IN CASCADE,
WE WOULD HAVE TO MAKE,
LIKE, FOUR
OR FIVE DIFFERENT EMITTERS
TO SATISFY THOSE
DIFFERENT IDEAS.
THE BIG HEAVY ONES
THAT MOVE SLOWLY,
AND THEN THE LITTLE TINY
PARTICULATE ONES THAT FLY OFF.
NOW, IF YOU GET YOUR NUMBERS
RIGHT,
THEN YOU CAN HAVE ONE EMITTER
THAT IS GRACEFULLY REACTING
REASONABLY WELL TO THE FORCES
THAT YOU’RE APPLYING TO IT,
AND IT JUST KIND OF WORKS.
IT JUST KIND OF DOES
THE RIGHT THING.
THIS IS THE FANTASY WHERE —
I DON’T THINK WE ARE 100 PERCENT
TO THE REALITY,
BECAUSE WE HAVE MORE
HELPER FUNCTIONS TO WRITE,
WE HAVE SOME MORE THINGS
TO DO IN THIS REGARD.
BUT IT’S DEEPLY POWERFUL.
AGAIN, IF YOU DON’T WANT
TO FACTOR MASS IN AND
YOU JUST WANT TO NOT CARE,
JUST SET IT TO ONE,
OR UNCHECK THE CHECKBOX
TO SET IT TO ALL, AND THE SIM
GOES ALONG AS NORMAL.
BUT IT IS PRETTY COOL.
I’LL SHOW YOU HOW IT
AFFECTS PARTICLES.
SO IN THIS CASE,
I HAVE THIS PARTICLE HERE
THAT HAS A MASS OF 150.
THEN WE HAVE
SOME HELPER FUNCTIONS HERE.
THIS HELPER FUNCTION
IS CALCULATE SIZE BY MASS.
AND SO NOW, I BASICALLY
HAVE DECIDED THAT MY —
THE DENSITY OF MY MESH IS BASED
ON THE DENSITY OF WATER.
THIS IS JUST ARBITRARY.
I COULD CHOOSE A DIFFERENT ONE.
I CAN SAY, “OH, YOU’RE MADE
OUT OF WOOD INSTEAD,”
AND ACTUALLY YOU CAN SEE
THE SIZE
AS IT RELATES TO ITS DENSITY
HAS CHANGED,
BECAUSE AN EQUIVALENT PIECE
OF PINE WEIGHS LESS THAN
AN EQUIVALENT BODY
OF THAT AMOUNT OF WATER.
AND SO ALREADY YOU’RE SEEING
SOME OF THESE SETTINGS AT PLAY.
AND WE HAVE FUDGE FACTORS
TOO, FOR ARTISTIC
CONTROL — IF YOU’RE
JUST NOT HAPPY, YOU CAN
ALWAYS FUDGE THINGS
AROUND A LITTLE BIT.
AT THE END OF THE DAY,
WE HAVE TRIED TO GIVE YOU
SOME BONES TO MAKE THIS GOOD
IN THE BEGINNING.
IF I CHANGE MY MASS, MY SIZE
JUST AUTOMATICALLY UPDATES.
BECAUSE NOW MY MASS HAS CHANGED,
BUT YOU’LL NOTICE
SOMETHING ELSE.
NOW IT’S SPINNING FASTER.
BECAUSE IT HAS LESS RESISTANCE
TO THAT ROTATIONAL FORCE,
NOW IT’S ACCUMULATING
THOSE FORCES MORE RAPIDLY,
BECAUSE THE MASS HAS CHANGED.
SO IF I GO UP TO 200,
IT’S YOU KNOW —
THE SAME ROTATIONAL FORCE
IS BEING APPLIED,
BUT NOW IT’S JUST, KIND OF,
MOVING A LITTLE BIT MORE SLOWLY.
WE HAVE AN INVERSE VERSION
OF THIS MODULE AS WELL.
SO IF YOU WANT TO CALCULATE
YOUR MASS BY YOUR SIZE,
WE SUPPLY THAT AS WELL.
SO, EITHER WAY,
YOU WANT TO WORK, GREAT. THE —
>>AMANDA: YOU’RE BLOWING
EVERYONES MIND RIGHT NOW.
>>WYETH: THIS ONE WE
THOUGHT REALLY HARD ABOUT.
>>AMANDA: YEAH.
>>WYETH: BECAUSE IF YOU
TALK TO PEOPLE,
EVEN PEOPLE WHO DO REALLY,
REALLY HIGH-END WORK —
LIKE GUYS AT ILM DOING WORK
IN HOUDINI ON FILM,
NOT ALL OF THEM
WANT TO WORK WITH MASS.
BUT SOME OF THEM DO,
AND THEY’RE ZEALOTS,
AND SO IT’S THIS THING
WHERE WE HAVE TO RIDE THE LINE
BETWEEN SUPPORTING THESE TWO
DIFFERENT PARALLEL WORKFLOWS
AND MAKING SURE
THEY’RE BOTH REALLY GOOD,
AND ALSO GIVING YOU
ALL THE FUNCTIONS
THAT YOU NEED
TO MAKE THIS APPROPRIATE,
YOU KNOW, FOR THIS
PARADIGM, WHICH IS A
SLIGHTLY MORE PHYSICALLY
CORRECT PARADIGM.
>>AMANDA: RIGHT.
>>WYETH: AND THAT’S
THE OTHER THING TOO,
IS THAT WE NOW HAVE —
INSTEAD OF JUST DOING
ROTATION RATE,
WE NOW HAVE A ROTATION FORCE.
THIS FACTORS MASS
INTO THAT EQUATION.
AND SO, YOU KNOW,
IF I TURN THIS UP REALLY HIGH,
NOW THIS GUY
IS REALLY STARTING TO GO.
IF I THEN GO
AND AFFECT THE MASS OF IT,
THEN IT’S GONNA, YOU KNOW,
IT’S JUST GONNA TAKE OFF.
YOU’LL ALSO NOTICE THE PARTICLE
FLIES AWAY —
I’LL JUST BACK UP A LITTLE BIT,
I’LL JUST PULL THIS DOWN
A LITTLE BIT
— THAT IS THE
CURL NOISE FORCE.
AGAIN, THIS CURL NOISE FORCE
IS ANOTHER ATTRIBUTE
WHICH IS BEING MODULATED
BY THE EFFECTIVE MASS.
SO THE HEAVIER THEY ARE,
THE LESS LIKELY THEY ARE
TO GET MOVING, SO TO SPEAK.
NOW, THERE’S
A SPECIAL CASE HERE.
I INCLUDED THIS MODULE
AS AN EXAMPLE: GRAVITY.
GRAVITY IS IRRESPECTIVE OF MASS.
YOU KNOW, IT’S THE THING WHERE,
IN A VACUUM YOU DROP A FEATHER
AND A BOWLING BALL AND THEY BOTH
LAND AT THE SAME TIME.
THAT’S KIND OF THE — GRAVITY
DOES NOT TAKE MASS INTO ACCOUNT.
THAT MEANT
WE HAD TO MOVE AWAY
FROM HOW WE USED TO DO GRAVITY,
WHICH WAS AN ACCELERATION FORCE.
IF YOU’RE USED TO PUTTING
ACCELERATION FORCE
INTO YOUR EFFECTS —
DON’T DO THAT ANYMORE.
INSTEAD, YOU WANT TO ADD
A GRAVITY FORCE,
WHICH HAS SOME ADDITIONAL
CALCULATIONS
TO FACTOR MASS
BACK INTO THE EQUATION,
SO THAT THE GRAVITY FORCE
IS EQUAL NO MATTER YOUR MASS.
THEN THE LAST THING HERE,
IN ORDER TO REALLY MAKE
THIS STUFF CORRECT,
IS THAT YOU WOULD WANT TO GO IN
AND YOU WANT TO ADD SOME DRAG.
BECAUSE THERE’S STILL THIS
CONCEPT OF AIR RESISTANCE.
THERE WE GO.
SO YOU WOULD ADD SOME DRAG,
AND THAT WOULD START TO KIND OF,
TONE DOWN ALL OF THESE
DIFFERENT THINGS.
EVEN WITH GRAVITY
YOU’RE STILL GOING TO HAVE
AIR RESISTANCE AND DRAG.
THAT’S WHAT WOULD MAKE
THE BOWLING BALL
AND THE FEATHER FALL
DIFFERENTLY OUTSIDE OF A VACUUM.
WE START TO MODEL
SOME OF THAT.
ANYWAY,
MASS IS A FIRST-CLASS CITIZEN.
WE’RE SUPPLYING A BUNCH
OF HELPER FUNCTIONS
IN ORDER TO MAKE
THAT GOOD FOR PEOPLE.
I CAN’T WAIT FOR PEOPLE
TO TRY IT
AND SEE WHERE IT’S GOOD
AND WHERE IT’S NOT GOOD.
MAYBE WE NEED
BETTER FUDGE FACTORS.
ONE THING THAT’S A GOTCHA
RIGHT NOW IS THAT,
WHEN YOU CALCULATE
THE SIZE BY MASS,
WE DON’T KNOW THE DIMENSIONS
OF THE MODEL YOU IMPORT.
SO IF YOU’RE NOT IMPORTING
A MODEL
THAT IS 1 CENTIMETER
BY 1 CENTIMETER SQUARE,
WE CAN’T FIGURE OUT YOUR SCALE
APPROPRIATELY FOR YOU,
BASED ON DENSITY.
SO IN THE VERSION 4.22,
YOU HAVE TO TYPE IN THE INITIAL
DIMENSIONS OF YOUR MODEL
AS IT WAS IMPORTED,
AND THEN ALL
THE OTHER THINGS WORK.
WE HAVE PLANS TO MAKE IT
SO THAT,
WHEN YOU AUTO IMPORT,
THAT IT KNOWS.
WE’LL DO THAT AT SOME POINT.
FOR NOW, IF YOU’RE
PLAYING WITH THIS STUFF
AND YOU WANT TO CALCULATE
YOUR SIZE BY MASS APPROPRIATELY,
YOU JUST HAVE TO MAKE SURE THAT
YOUR INITIAL MODEL DIMENSIONS
ARE SET CORRECTLY
AND THEN, THEORETICALLY,
THE TOOL SHOULD TAKE OVER
AND TRY TO DO
THE RIGHT THING FOR YOU.
BY THE WAY, THIS STUFF
WILL ALSO BE ALL FACTORED
INTO JOHN’S NEW COLLISION
CALCULATIONS
WHICH WILL BE COMING.
I CAN’T SHOW YOU
THE NEW COLLISIONS RIGHT NOW,
BECAUSE THEY’RE NOT
IN THIS EXACT BUILD.
>>AMANDA: YEAH.
>>WYETH: BUT
JOHN LINDQUIST,
WHO MADE THAT AMAZING EXAMPLE
OF THE MODULE MODEL
BREAKING UP
AND STUFF LIKE THAT,
HE HAS SPENT A VERY IMPRESSIVE
AMOUNT OF EFFORT
ON A COMPLETE REWRITE
OF COLLISIONS.
THIS ALSO INCLUDES A BUNCH
OF HELP ON THE CODE SIDE
OF EVERYONE IN THE CODE TEAM
WRITING NEW FUNCTIONS
TO MAKE SURE EVERYTHING
WORKS THE WAY IT SHOULD.
BUT, AT THE END OF THE DAY,
WE’RE GOING TO HAVE INCREDIBLY
STABLE CPU COLLISIONS,
REALLY REALLY STABLE
ANALYTICAL COLLISION PLANES,
SO LIKE A FAKE COLLISION PLANE
WILL NOW WORK CPU AND GPU.
WE’LL HAVE SCENE
DEPTH COLLISIONS THAT ARE BETTER
THAN WE’VE EVER HAD THEM
BEFORE IN UNREAL,
AND WE CAN COLLIDE WITH
THE DISTANCE FIELDS
THAT ARE IN THE LEVEL SET,
THE DISTANCE FIELDS
THAT WOULD GENERATE
WHEN YOU TURN
THAT PROJECT SETTING ON.
>>AMANDA: THAT’S
GREAT.
>>WYETH: THEY’RE REALLY
STABLE, REALLY ROBUST,
THEY HAVE A TON OF CONTROLS,
THEY FACTOR IN ALL THE STUFF
I’M TALKING ABOUT HERE WITH MASS
AND THE ROTATIONAL INERTIA,
THE RABBIT-HOLE GOES DEEP,
THANK YOU JOHN.
YOU HAVE DONE WELL.
THE ONE THING THAT
WE DO KNOW ABOUT THAT MODULE
IS THERE ARE A COUPLE OF
UI THINGS
RELATED TO IT BEING
UNCLEAR WHETHER
YOU’RE IN THE CPU MODE,
OR THE GPU MODE,
BECAUSE WE CAN’T
NECESSARILY HIDE AND SHOW
YOU ALL THOSE THINGS
ALL AT ONCE.
SO LOOK FOR THE VERSION 2 OF
THIS MODULE IN THE NEXT RELEASE
HAVING MORE SLICKNESS IN THAT,
YOU KNOW, KIND OF UI SENSE.
/FROM A FUNCTIONALITY
STANDPOINT,
DIVE RIGHT IN AND PLAY WITH IT.
>>AMANDA: NOW
THE COLLISION,
IS ALL OF THIS AVAILABLE IN THE
PREVIEW WE JUST RELEASED?
>>WYETH: IT’S NOT.
>>AMANDA: OK.
>>WYETH: IT WILL ONLY
TRULY PROBABLY MAKE IT IN RIGHT
BEFORE WE GO OUT LIVE.
>>AMANDA: OK.
>>WYETH: YEAH.
SO THE COLLISIONS ARE GREAT.
I’M EXCITED ABOUT
WHERE THAT’S HEADED.
A COUPLE OF THE OTHER THINGS —
OH SPEAKING OF DISTANCE
FIELDS ACTUALLY,
ONE OF THE OTHER
THINGS WE WILL TRY TO
GET INTO THE NEXT PREVIEW —
WE WILL SEE — IS SAMPLING
PSEUDO-VOLUME TEXTURES.
THERE’S THIS CONCEPT OF PSEUDO
VOLUME TEXTURES IN THE ENGINE.
YOU CAN GO WATCH RYAN BRUCKS’
AMAZING RAY
MARCHING DEMONSTRATIONS
AND 3D FLUID SIM DEMONSTRATIONS.
THOSE PSEUDO VOLUMES COULD BE
GENERATED INSIDE OF UNREAL
USING HIS BLUEPRINT
HELPER FUNCTIONS,
OR YOU CAN WRITE,
YOU KNOW, WE HAVE SOME PLUGINS
OR — SIDEFX
ACTUALLY WROTE THEM,
THANK YOU SIDEFX —
SOME ABILITY TO EXPORT
PSEUDO VOLUME TEXTURES
OUT OF HOUDINI AS WELL,
WHICH WE ALSO INGEST.
IF YOU WOULDN’T
MIND PLAYING THAT VIDEO,
YOU CAN SEE WE HAVE
SOME SAMPLING FUNCTIONS
TO ACTUALLY SAMPLE THESE.
SO, THIS IS MY HOMAGE
TO SIDEFX
FOR WRITING THESE FUNCTIONS
BECAUSE THAT’S THE RUBBER TOY
FROM HOUDINI.
THE IDEA HERE IS THAT
YOU WRITE A VOLUME TEXTURE OUT,
WHICH INCLUDES THE DISTANCE
TO THE NEAREST SURFACE,
LIKE THE ISO SURFACE OF THE MESH
YOU’RE GENERATING.
AND WE’RE ALSO SAVING OFF
THE INFORMATION LIKE THE NORMAL,
BASICALLY, AND WE’RE CODING
ALL THAT INTO A TEXTURE,
AND THEN NIAGARA
IS ABLE TO SAMPLE THAT,
AND IT’S ABLE TO DO
A BUNCH OF CALCULATIONS FOR,
IT IS SUPPOSED TO BE
ON THE SURFACE,
AND CAN I MOVE AROUND IT,
CAN I FLOW ACROSS IT,
CAN I BREAK FREE?
THERE’S A BUNCH OF THINGS
THAT ARE AVAILABLE TO USERS NOW.
IT WILL BE A BASIC SAMPLING
FUNCTION WHICH IS JUST,
“HEY, SPAWN AND PUT YOURSELF ON
THE SURFACE, AND
ALIGN YOURSELF.”
THIS SHOULD BE ENOUGH
TO GET PEOPLE COOKING,
AND THEN THEY CAN PLAY.
SO THANKS FOR SHOWING
THAT VIDEO.
>>AMANDA: THAT’S SO
COOL.
>>WYETH: THAT SHOULD
BE COMING.
LET’S SEE, ONE OTHER THING:
HOW AM I DOING ON TIME?
>>AMANDA: A LITTLE
BEFORE 3:00.
>>WYETH: OKAY,
PERFECT.
SO LET ME SHOW JUST A FEW
MORE THINGS HERE.
I’LL GO BACK TO THIS.
ONE OTHER THING
THAT I WANT TO TALK ABOUT,
IT’S KIND OF A TENTPOLE FEATURE
THAT WENT IN
AND IS IN THE CURRENT PREVIEW,
IS DETERMINISM.
WHAT I MEAN BY THAT IS,
IF I PICK A RANDOM NUMBER,
I’M ASKING FOR A RANDOM NUMBER.
IN THEORY,
I CAN USE A SEED VALUE
TO GET THAT NUMBER BACK
EVERY TIME.
I COULD BASICALLY
TAKE MY RANDOM —
THE FUNCTION I’M ASKING
A RANDOM NUMBER FOR
AND I COULD SEED IT
WITH A PIECE OF DATA THAT SAYS,
LIKE, “HEY I WANT A RANDOM
NUMBER BUT I’M GONNA TELL YOU
TO SEED IT WITH THE
NUMBER EIGHT.”
THEN IT WILL ALWAYS
GIVE ME A VALUE BACK
THAT CORRESPONDS
TO THE NUMBER EIGHT.
IT’S BECAUSE THERE’S A LITTLE
THIS KIND OF LINKAGE
BETWEEN RANDOMNESS
AND THE UNDERLYING VALUES
THAT GENERATE RANDOMNESS.
WE NOW FULLY SUPPORT DETERMINISM
IN NIAGARA FROM TOP TO BOTTOM.
THIS ENABLES A BUNCH OF STUFF
INCLUDING,
LIKE, SCRUBBING ON TIMELINES
AND GENERATING A CONSISTENT,
REPRODUCIBLE RESULT IN SELECT,
IN LET’S SAY,
A SEQUENCER PLAYBACK
WHERE YOU WANT THE CINEMATIC
TO BE THE SAME EVERY TIME,
WE NOW SUPPORT THAT.
LET ME SHOW YOU WHAT IT MEANS
AND HOW TO USE IT.
SO I JUST MADE A REALLY,
REALLY QUICK TEST EMITTER HERE,
IN FACT, I’LL JUST DO IT HERE
IN THE VIEWPORT.
LET’S SAY I HAVE THESE PARTICLES
THAT ARE RANDOMLY SPAWNING,
AND I BASICALLY WANT THEM TO BE
EXACTLY THE SAME EVERY FRAME.
RIGHT NOW, IF I DRAG FORWARD,
THE SIMULATION ADVANCES
BECAUSE IT KNOWS WHAT TO DO
ON THE NEXT TIME STEP.
BUT BECAUSE ALL OF
OUR RANDOM NUMBERS
ARE BEING DYNAMICALLY GENERATED
EVERY FRAME,
IF I GO BACK IN THE TIMELINE,
IT RESIMULATES THE WHOLE SIM
AGAIN UP TO THAT POINT,
BECAUSE IT DOESN’T HAVE
THE CONCEPT OF A FIXED
SEEDED VALUE TO GO BACKWARDS TO,
IF THAT MAKES SENSE.
SO NOW, ON YOUR
EMITTER PROPERTIES,
YOU CAN TOGGLE DETERMINISM.
UNLIKE CASCADE
THIS IS JUST A BLANKET THING
THAT AFFECTS ALL RANDOMNESS.
YOU DON’T HAVE TO
REBUILD YOUR EFFECT
TO SUPPORT THIS,
IT’S JUST A CHECKBOX.
NOW, THIS SIMULATION
IS COMPLETELY DETERMINISTIC.
SO IF I SCRUB BACKWARDS,
CAN REWIND THE SIMULATION
BECAUSE IT KNOWS
WHERE IT CAME FROM.
IT KNOWS THE SEED
THAT GENERATED THIS DATA.
FOR DEBUGGING,
FOR SLOW-MO PREVIEW,
FOR GETTING YOUR EFFECT
JUST RIGHT,
THIS IS INCREDIBLE,
USEFUL BEHAVIOR.
WE TRY TO GO FURTHER
THAN THIS, THOUGH,
AND GIVE THE USER CONTROL
OVER DETERMINISM.
LET’S SAY THAT I WANT
THE POSITION OF MY PARTICLES
TO BE DETERMINISTIC.
I WANT THE VELOCITY
AT WHICH THEY FLY OUT
TO BE DETERMINISTIC,
BUT I WANT THEIR COLOR
TO BE TRULY RANDOM.
LET ME GO AHEAD
AND SET THEIR COLOR,
AND THEN I’M JUST GONNA CREATE
A LITTLE RANDOM RANGE.
SO THIS IS GONNA GIVE ME
A RANDOM COLOR
ON EACH OF MY PARTICLES.
NOW, BECAUSE DETERMINISM
IS TOGGLED,
THAT COLOR STAYS CONSISTENT.
SO, EVERY TIME
I PLAY, THEY’RE ALL GONNA —
THAT PURPLE GUY
THAT FLIES OFF TO THE RIGHT
IS ALWAYS GOING TO BE THAT.
IF I GO INTO THE RANDOMNESS
SETTING FOR MY RANDOM CALL
AND SWITCH AWAY
FROM DETERMINISM
BACK TO NON-DETERMINISTIC
JUST FOR THIS RANDOM,
THEIR COLOR IS NOW COMPLETELY
RANDOM EVERY TIME I RUN IT,
BUT THE REST OF
THE SIMULATION IS NOT.
THE OTHER THING THAT’S
REALLY NICE
IS YOU CAN FIX THE
SEED IF YOU LIKE.
WE ACTUALLY
GIVE YOU THE SEED.
IF I GO TO DETERMINISM,
AND SO I WANT THIS TO BE
COMPLETELY DETERMINISTIC,
BUT I REALLY DON’T LIKE
THE COLORS I GOT,
I JUST GIVE IT ANOTHER NUMBER.
NOW I HAVE DIFFERENT COLORS,
BUT THEY’RE STILL STABLE
DIFFERENT COLORS.
SO NOW THE USER
HAS COMPLETE CONTROL
OVER THE RANDOMNESS BEHAVIOR
OF THEIR EMITTER.
>>AMANDA: THAT’S
INCREDIBLE.
>>WYETH: IT IS A TRULY
FUNDAMENTAL PART OF THE TOOL,
BASICALLY, IS THIS.
IT HAS BEEN A BIG MISSING PIECE,
AND I THINK THE WAY IT’S BEEN
IMPLEMENTED IS REALLY GRACEFUL,
AND IT’S AN EASY WAY FOR USERS
TO HAVE EXACTLY THE TYPE
OF CONTROL THEY WANT.
BY THE WAY, THIS SETTING,
SIMULATION DEFAULTS —
ALL THIS MEANS IS, “HEY,
RESPECT THE CHECK BOX.”
WHATEVER THE CHECK BOX SAYS,
THAT’S WHAT I AM,
AND THEN YOU CAN SET IT
TO BE DIRECT.
ONE NICE THING ABOUT
ONCE YOU’RE DETERMINISTIC
IS ALSO CHANGING
OTHER ATTRIBUTES.
IT DOESN’T RESET YOUR SIM.
SO IF I’M NOT QUITE HAPPY WITH,
LIKE, MY SIZES,
I CAN AFFECT MY SIZES WITHOUT
THE SIMULATION RESETTING ITSELF.
WHEN I’M NOT DETERMINISTIC,
EVERY TIME
I DRAG ONE OF THESE VALUES,
THE WHOLE SYSTEM SAYS,
I DON’T KNOW WHAT
I’M SUPPOSED TO DO.
SO NOW YOU COULD HAVE
AN EXPLOSION, EXPLODE,
GET IT RIGHT TO THE POSITION
YOU WANT IT TO FREEZE IT,
AND THEN NOODLE THE VALUES
SO YOU’RE EXACTLY PERFECT.
YOU KNOW WHAT I MEAN?
YOU GET TO BE AS ANAL AS
YOU WANT ABOUT THESE SETTINGS.
YOU CAN REALLY GET IN THERE
AND ART DIRECT SOMETHING,
WHICH IS REALLY REALLY HARD
TO DO
WITHOUT THIS TYPE OF FEATURE.
SO WE’RE SUPER EXCITED ABOUT IT.
>>VICTOR: IS THAT
CONSIDERED A MODULE AS WELL?
>>WYETH: YEAH,
SO THAT’S ONE NICE THING IS THAT
THIS IS NOT SOME INTRINSIC THING
THAT IS WRITTEN —
THAT IS LOW-LEVEL CODE
THAT CONTROLS THIS.
THIS IS ALL USER CREATED.
SO, AFTER THE FEATURE WAS MADE,
MORTON, WHO WROTE THE FEATURE,
WENT IN AND UPDATED ALL OF
OUR MODULES TO SUPPORT IT.
BUT IT’S LITERALLY JUST
A NUMBER OF —
ITS SOME IF NODES,
IT’S SOME SETTINGS,
IT’S BEING ABLE TO PASS A SEED
FROM THE USER
INTO THE RANDOM
FUNCTION ITSELF,
AND ALL OF THESE RANDOM
RANGE FUNCTIONS
ARE NOW WRITTEN COMPLETELY TO
TAKE ADVANTAGE OF DETERMINISM,
AND EVEN THE SEEDS
THAT DRIVE THEM,
THINGS LIKE THE TIME AND ALL
THESE OTHER THINGS, ARE OPEN.
SO JUST BECAUSE
THEY’RE IMPLEMENTED THIS WAY,
IF YOU WANT TO GO IMPLEMENT THEM
ANOTHER WAY, GO AHEAD.
HAVE FUN.
EVERYTHING IS IS IMPLEMENTED
HERE IN THE NODE GRAPH,
EVEN THOUGH IT IS
A LOW-LEVEL BEHAVIOR.
>>VICTOR: AND ARE THEY
PART OF THE SORT
OF A LIBRARY OF MODULES?
>>WYETH: YES,
EVERY ONE OF THESE GUYS —
SO THESE GUYS ARE CALLED
DYNAMIC INPUTS,
AND THESE LITTLE DYNAMIC
INPUTS ARE SOMETHING WHERE,
“HEY, I HAVE AN ATTRIBUTE,
LIKE A PARAMETER, LIKE A FLOAT,
AND I WANT TO HAVE A LITTLE BIT
OF GRAPH LOGIC TO ACT ON THAT.
I’M GONNA WRITE A TINY LITTLE
BEHAVIOR, WHICH I CAN SLOT IN.”
SO INSTEAD OF JUST A FLOAT,
LIKE A 1.3,
I CAN ACTUALLY RUN
A LITTLE LOGIC
TO GIVE ME A FLOAT
BETWEEN 1 AND 10 OR WHATEVER.
SO THAT’S BASICALLY
WHAT THIS IS,
AND THESE LITTLE GUYS
ARE ALL JUST LITTLE NOTE GRAPHS.
SO IT’S PRETTY GREAT.
>>AMANDA: I THINK WE NEED
TO TAKE A SHORT DIVERSION
AND LET OUR JAMMERS GO.
>>VICTOR: THEY’RE
READY.
>>AMANDA: THEY’RE
CHOPPING AT THE BIT.
>>VICTOR: TRULY
CHOMPING.
>>AMANDA: SO WE WILL COME
BACK TO WYETH IN JUST A MINUTE.
>>WYETH: OKAY,
AWESOME.
>>AMANDA: YOU CAN KEEP
YOUR QUESTIONS COMING,
IF YOU DON’T MIND GRABBING
QUESTIONS, VICTOR.
>>VICTOR: I AM.
>>AMANDA: I’LL GET YOU
SET UP WITH SOME UE4 JAM INFO.
SO WE ARE KICKING OFF
OUR WINTER UE4 JAM TODAY.
SO YOU HAVE FIVE DAYS
TO MAKE SOME PRETTY RAD GAMES,
AND WE’RE EXCITED FOR YOU ALL.
AGAIN, MANY MANY THANKS
TO ALL OF OUR SPONSORS.
IF YOU HAVEN’T JUMPED ON AND
GRABBED SOME OF THEIR RESOURCES,
TOM SHANNON’S DONE A GREAT JOB
PUTTING A PRESENTATION TOGETHER.
YOU CAN STILL GRAB A TEAM
ON CROWD FORGE.
BEN, WHO IS IN CHAT,
SO SHOUT OUT TO BEN MEARS,
HE’S FROM — HE’S THEIR GAMES
COMMUNITY MANAGER.
>>WYETH: I LOVE BEN.
I SAW HIM IN LA. GREAT DUDE.
>>AMANDA: THEY’RE GIVING
TWO MONTH LICENSES TO HOUDINI,
SO IF YOU’D LIKE
TO PLAY WITH THAT,
HE’S THE GUY THAT’S GONNA
HOOK YOU UP, AND AGAIN, PING US.
WE’RE STILL HANDING OUT ACCESS
TO ASSEMBLA REPOSITORIES
IF YOU NEED THAT.
SO SHOOT US AN EMAIL
AT [email protected]
AND WE CAN GIVE YOU
ACCESS THERE, SET UP YOUR TEAM,
AND LET YOU GET ROLLING.
GAME TEXTURES IS OFFERING
FREE ACCOUNTS
TO LET YOU GET ACCESS
TO TEXTURES,
AND SOUNDLY IS PROVIDING
THEIR LIBRARY AGAIN,
SO HUGE HUGE THANKS TO THOSE
TEAMS, ALWAYS EXCITED FOR THAT.
I FEEL LIKE MOST OF YOU KNOW
THE DRILL —
YOU’VE GOT TO MAKE A GAME,
AND IT’S GOT TO BE
FULLY PACKAGED.
WE’RE TOTALLY THROUGH
IT ITCH.IO NOW,
SO IF YOU’RE UPLOADING
YOUR GAME TO THERE,
IT’S SUPER HANDY
TO TAKE CARE OF THAT,
OR GET THOSE UPLOADED,
THAT WAY PEOPLE CAN COMMENT
ON YOUR GAME.
BUT DO REMEMBER
YOU SUBMIT YOUR GAME,
OR YOU UPLOAD YOUR GAME
TO YOUR ACCOUNT,
AND THEN YOU HAVE TO
SUBMIT IT TO THE JAM.
THAT IS A VERY,
VERY IMPORTANT STEP
THAT SOME OF YOU HAVE FORGOTTEN.
SO MAKE SURE YOU DO
BOTH OF THOSE STEPS.
IF YOU HAVE A LARGE FILE,
ITCH.IO HAS A DEFAULT SIZE OF —
I THINK IT’S 600MB,
THEY KEEP CHANGING IT.
AND IT NEEDS TO BE UNDER A GIG.
IF IT NEEDS TO BE LARGER
THAN THAT,
THERE IS A BUTLER TOOL.
NICK FISHER HAS WRITTEN A GREAT
TUTORIAL ON HOW TO DO THAT.
I THINK WE HAD HIM — HE WALKED
THROUGH IT ONE TIME ON OUR JAM,
OR ON OUR LIVE STREAMS.
DEFINITELY CHECK THAT OUT.
WE WANT TO GIVE A HUGE THANK YOU
TO INTEL.
THEY ALWAYS PARTNER WITH US.
THEY HAVE A GREAT GAME
DEVELOPER PROGRAM
IN WHICH THEY’RE TRYING TO
HELP FOLKS WITH MARKETING,
WITH JUST GENERAL
OPTIMIZATION PROBLEMS,
AND REALLY WONDERFUL
INFORMATION THERE.
YOU KNOW, WE HAVE
A GAMETEXTURES.COM RAFFLE,
SO ALL PARTICIPANTS
WITH VALID SUBMISSIONS
CAN RECEIVE ONE OF TEN
ONE-MONTH SUBSCRIPTIONS
TO GAMETEXTURES.COM.
WE ALSO HAVE THESE
REALLY RAD RACING CHAIRS.
I DON’T KNOW
IF YOU’VE SEEN THESE.
SO DXRACER HAS THESE
REALLY AWESOME CHAIRS.
I SIT IN ONE AT MY DESK,
AND THEY’RE PRETTY PHENOMENAL.
>>WYETH: THOSE
LOOK FANTASTIC.
>>AMANDA: THEY’RE
BEAUTIFUL, BEAUTIFUL CHAIRS.
THEY WERE THE ENVY
OF THE OFFICE.
I REMEMBER TWEETING
ABOUT THEM THE LAST TIME,
AND EVERYBODY’S LIKE,
“WHERE DO I GET THAT?!”
>>WYETH:
VULTURES.
>>AMANDA: YEP.
WE HAVE THREE FINALISTS
IS HOW WE DIVVY IT OUT.
THEN WE’LL HAVE
THREE SPECIAL CATEGORIES.
WE HAVE FRIENDS AND FOES,
WHICH IS THE BEST SHARED
SCREEN MULTIPLAYER GAME,
VICTOR’S NEW CATEGORY.
>>VICTOR: IT
WAS MY ADDITION.
>>AMANDA: YEAH, YOU WANT
TO TALK ABOUT IT A LITTLE BIT?
>>VICTOR: SURE.
THERE WERE A COUPLE
OF QUESTIONS ABOUT IT.
SO SHARE SCREEN MULTIPLAYER
ESSENTIALLY —
ANYTHING YOU CAN DO
WHERE SEVERAL PLAYERS
ARE PLAYING
ON ONE SHARED SCREEN,
WHETHER IT IS SPLIT SCREEN,
SHARED CAMERA, DOESN’T MATTER.
IF YOU COME UP
WITH SOMETHING EVEN WEIRDER,
ONE MONITOR,
SEVERAL PLAYERS.
THAT’S BASICALLY
THE DETAILS OF IT.
>>AMANDA: TINY AWARD FOR
A BEST GAME UNDER 100 MEGABYTES,
AND YOU’RE DOING THAT UNZIPPED.
>>VICTOR: I AM.
SO UNZIPPED —
YOU CAN USE THE
COMPRESSION TOOLS THAT EXIST
IN THE ENGINE TO LOWER
THE SIZE SO YOU’RE EXECUTABLE,
BUT IT NEEDS TO BE BELOW
100 MEGABYTE UNZIPPED.
IF YOU SEND US
A ZIP FILE THAT’S BELOW,
WE UNZIP IT SO THAT
WE CAN ACTUALLY PLAY IT
AND IT’S ABOVE, YOU ARE NOT
QUALIFYING FOR THE CATEGORY.
>>AMANDA: YEP, HE’S
MAKING THE RULES.
HE MEANS BUSINESS.
AND THEN WE ALSO HAVE
OUR SOMETHING-SOMETHING REALITY.
SO IF YOU’RE MAKING
AN AUGMENTED REALITY,
OR MIXED REALITY,
OR VIRTUAL REALITY,
ANY KIND OF XR EXPERIENCE —
THAT FALLS UNDER THAT CATEGORY.
WE HAVE OUR
THREE SPECIAL CATEGORIES,
AND THEN OUR THREE FINALISTS,
ALL GAMES ARE JUDGED ON FUN,
AESTHETICS,
AND UNIQUE USE OF THEME.
THEN OUR THREE FINALISTS
WILL BE ENTERED
INTO A GRAND PRIZE RAFFLE
FOR A BEAUTIFUL FALCON
NORTHWEST TIKI.
OOHHHHH.
>>VICTOR: JEALOUS.
>>WYETH: THAT’S
AWESOME.
>>AMANDA: SO THIS IS
A BEAUTIFUL RENDER.
WE LOVE WORKING
WITH THE TEAM OVER THERE.
THEY’RE SO GOOD TO US.
AND I’M JELLY EVERY TIME I —
LIKE THEY ALWAYS COME IN,
WE OPEN THE BOX —
I’M LIKE,
I HAVE TO MAIL IT AWAY.
>>WYETH: YOU SMELL
THE ELECTRONICS.
>>AMANDA: YEAH WE OPEN
IT UP, HAVE TO TOUCH
IT, THEN SHIP IT OUT.
SO YEAH,
WE LOVE WORKING WITH THEM.
DEFINITELY RECOMMEND
THEIR COMPUTERS.
SO, IF THERE ARE — LET’S SEE.
WE HAVE A COUPLE OF GAME
JAM QUESTIONS I’LL ANSWER.
>>VICTOR: YEAH I WAS
GONNA SAY, SOME OF THE GAME
JAMMER RELATED QUESTIONS,
I’VE GATHERED THEM ALL
AND I WILL RESPOND TO THEM
ON THE FORUM AFTERWARDS
SO WE CAN HAVE MORE TIME
WITH WYETH FOR ALL THE QUESTIONS
RELATED TO NIAGARA.
>>WYETH: THAT’S GREAT.
>>AMANDA: YEAH,
SO FOLLOW UP
ON THOSE QUESTIONS
IN THE JAM THREAD.
>>VICTOR: YEAH,
CORRECT.
>>AMANDA: NOT
THE LIVE STREAM.
I’LL DROP THOSE IN THE CHAT.
AND WE’LL GET BACK TO YOU.
BUT, SHALL WE ANNOUNCE
THE THEME REAL QUICK?
>>VICTOR:
I THINK IT’S TIME.
>>AMANDA: ARE YOU
GUYS READY?
DO YOU WANT THE THEME?
ALL RIGHT. LET’S HIT IT.
FOR VALENTINE’S DAY —
ALL’S FAIR IN LOVE AND WAR.
THERE’S YOUR THEME.
I WANTED TO GIVE A SHOUT-OUT
TO BARRY LANDES,
WHO MADE THIS BEAUTIFUL SCENE
I PULLED FROM ART STATION.
SO THANK YOU FOR LETTING ME
APPRECIATE YOUR WORK.
BUT SO — THAT’S YOUR THEME.
FOR JAMMERS,
IF YOU HAVE QUESTIONS,
GO TO THE UNREAL ENGINE FORUM.
THE WINTER UE4 JAM FORUM THREAD,
TOSS YOUR QUESTIONS,
IN THERE
AND WE WILL FOLLOW UP ALSO.
IF AGAIN,
IF YOU HAVE ASSEMBLA REQUESTS,
MESSAGE US AT THAT ALIAS,
THE COMMUNITY ALIAS.
AND YEAH, GOOD LUCK.
MAKE SURE YOU’RE TWEETING
IF YOU’RE SHARING YOUR PROGRESS,
IF YOU’RE A SOCIAL PERSON,
#UE4JAM.
WE LOVE, LOVE, LOVE BEING ABLE
TO CHECK THEM OUT ALL WEEKEND.
>>VICTOR: THAT’S
ALL WE DO ALL WEEKEND.
>>AMANDA: WHAT ARE THEY
MAKING? SO AMAZING.
>>VICTOR: WE
GET TO WATCH.
>>AMANDA: BUT YEAH,
SO JAM AWAY.
>>WYETH: JAM
AWAY.
>>AMANDA: WE WILL RETURN
TO THE WONDERFUL WYETH.
>>WYETH: OKAY.
>>AMANDA: AND NIAGARA
MAGIC.
>>WYETH: AWESOME.
>>VICTOR: ALL
RIGHT, LET’S SEE —
>>WYETH: THAT IS
A BRICK OF QUESTIONS.
LET’S SEE,
I HAVE A FEELING THAT
IF I DIDN’T
GET TO SOMETHING HERE,
WE’RE GONNA GET IT HERE.
LET’S TRY.
>>AMANDA: OUR
Q&A?
>>VICTOR: YEAH.
WILL NIAGARA
BE RELEASED AT SOME POINT?
IT’S NOT CLEAR IF IT WILL
REPLACE CASCADE OR NOT.
>>WYETH: YEAH.
SO RIGHT NOW, NIAGARA
IS IN EARLY ACCESS.
EARLY ACCESS BASICALLY MEANS
VERY ACTIVE DEVELOPMENT,
AND OFTENTIMES THAT COMES
WITH A LOT OF CHURN.
THE OTHER THING THAT CAN
POTENTIALLY COME ALONG WITH THAT
IS INVALIDATION OF ASSETS.
MEANING WE MAKE
SOME FUNDAMENTAL CHANGE,
WHICH BREAKS THE STUFF
YOU WERE USING.
WE CAN’T DO THAT
ONCE THAT’S A REAL,
YOU KNOW, RELEASED FEATURE.
SO IT’S IN EARLY ACCESS
UNTIL WE FEEL LIKE THAT
IS NO LONGER TRUE.
SO RELEASING, IN THAT SENSE,
MEANS ONCE WE EMERGE
FROM EARLY ACCESS —
WE DON’T HAVE
A CURRENT TIMELINE FOR THAT.
WE’RE JUST BANGING AWAY, MAKING
THE BEST THING WE CAN.
AT SOME POINT,
IT WILL REACH
THE STABILITY OF PERFORMANCE,
STABILITY OF FEATURE SET,
AND THE ABILITY TO PREVENT
INVALIDATION OF EXISTING STUFF.
THAT’S WHEN
WE’LL EXIT EARLY ACCESS.
AS RELATES TO CASCADE, CASCADE
AND NIAGARA
WILL LIVE
SIDE-BY-SIDE FOR YEARS.
I MEAN, THERE’S JUST NO WAY
WE BASICALLY SAY LIKE,
“HEY, NIAGARA’S OUT,
GOODBYE CASCADE.”
SO MANY PEOPLE OVER, WHAT,
14 YEARS NOW, 13 YEARS,
HAVE BEEN RELYING ON CASCADE.
SO IT WILL IT WILL LIVE,
YOU KNOW,
ON FOR QUITE SOME TIME,
JUST LIKE MATINEE
AND SEQUENCER —
EVEN THOUGH SEQUENCER NOW
CARRIES A LION’S SHARE OF STUFF,
WE WILL STILL HAVE THAT
IN THE ENGINE.
IN THE FUTURE, WE WOULD LIKE
TO MAKE A BEST EFFORT
TO POTENTIALLY PORT STUFF
IN A LIGHTWEIGHT WAY
FROM CASCADE TO NIAGARA.
WE DON’T CURRENTLY HAVE ANYTHING
WRITTEN THERE,
AND THERE’S NOTHING
ON THE ROADMAP FOR IT,
BUT I THINK THAT WOULD BE
A REALLY NICE,
GOOD-FAITH THING TO PROVIDE
TO THE COMMUNITY SOMEDAY
SO THAT IF YOU HAVE
EXISTING CASCADE THINGS,
WE CAN GET THEM
IN SOME FUNDAMENTAL WAY
OVER TO NIAGARA FOR YOU.
I THINK THAT WOULD
BE COMPELLING.
BUT WE HAVE NO PLANS
FOR THAT RIGHT NOW,
NOR DO WE HAVE AN ANNOUNCED
EARLY ACCESS EXIT DATE.
>>VICTOR: SOMETIMES
THINGS TAKE TIME.
>>WYETH: THEY
DO.
>>VICTOR: YEAH,
LET’S SEE HERE.
WHEN WILL IT BE POSSIBLE TO SET
ACTOR OR COMPONENT REFERENCES
DYNAMICALLY DURING GAMEPLAY
AS A VARIABLE?
>>WYETH: YES, I AM
SO GLAD YOU ASKED THAT.
THAT IS UNDER
ACTIVE DEVELOPMENT.
I AM UNSURE IF THAT WILL MAKE IT
INTO 4.22 BECAUSE IT —
THIS IS THIS IS LITERALLY
THE PROBLEM DU JOUR.
WE KNOW IT’S BEEN PERSISTENTLY
THE PROBLEM UP
TILL THIS POINT AS WELL,
BUT YES,
THIS IS HIGH ON THE LIST.
WE WILL FIX THIS SOON.
I DO NOT KNOW
IF WE’LL MAKE IT INTO 4.22,
BUT IT WILL BE IN SOON
THEREAFTER, FOR SURE.
AND, YOU KNOW, IN THE BEGINNING
THAT’LL BE STATIC MESHES.
AND THEN WE WILL ALSO THEN
FIX THAT
FOR SKELETAL MESHES AS WELL.
>>VICTOR: THAT’S
GREAT.
WILL YOU ADD SUPPORT FOR
INTERACTION WITH THE WIND ACTOR?
>>WYETH: THAT’S
A GOOD QUESTION.
PROBABLY NOT WOULD BE
MY ASSUMPTION.
THE REASON I SAY THAT
IS BECAUSE THOSE ARE TWO
REALLY FUNDAMENTALLY
DIFFERENT SYSTEMS,
AND RIGHT NOW OUR FEELING
IS IF YOU EXPOSE
A USER PARAMETER,
WHICH IS SOMETHING
YOU WANT THE ENGINE
TO TALK TO OUTSIDE OF THE TOOL,
WE WOULD PROBABLY DO THAT
BY HAVING BLUEPRINT
BE THE INTERMEDIARY.
SO, IN THAT SENSE,
IF YOU HAD A WIND ACTOR,
YOU WOULD WANT
A CONTAINER WRAPPER BLUEPRINT
THAT SETS THAT WIND ACTOR
PROPERTIES THAT WOULD ALSO SET
A CORRESPONDING
NIAGARA SYSTEM PROPERTY —
WOULD PROBABLY BE HOW WE WOULD
DO IT IN THE BEGINNING.
>>VICTOR: AND THAT’S
ALSO A LITTLE BIT LESS OVERHEAD.
>>WYETH: AND YEAH,
CERTAINLY NEVER SAY NEVER,
BUT WE KIND OF FEEL LIKE
IF WE’RE GONNA TAKE AN APPROACH
WHICH REALLY UNIFIES FORCES
LIKE WIND
AND,
LIKE, EFFECTORS IN THE LEVEL,
WE SHOULD DO THAT
IN A BROADER WAY,
WHICH IS REALLY DEEPLY
INTEGRATED WITH WHAT NIAGARA IS.
SO, FOR NOW,
THERE’S NO PLANS TO DO THAT.
I WILL SAY THAT,
JUST VERY QUICKLY,
AS AN ADDITION TO THE TOOLSET,
WHICH WILL BE IN 4.22,
WE DO HAVE A WIND FORCE,
SO SIMILARLY
TO THE GRAVITY FORCE.
WE ALSO HAVE A WIND FORCE
WHICH BEHAVES DIFFERENTLY
FROM ACCELERATION,
WHERE ACCELERATION, YOU KNOW,
SOMETHING SPEEDS UP
AND IT JUST KEEPS
SPEEDING UP BASICALLY.
THE WIND FORCE,
YOU GIVE IT A GOAL SPEED
AND THEN AN AIR
RESISTANCE VALUE,
AND IT WILL MOVE ITS WAY
TO THAT GOAL SPEED
AND THEN CONTINUE ON
AT THAT SPEED,
WHICH MORE CLOSELY MATCHES
HOW, KIND OF, WIND BEHAVES.
IF YOU’RE DOING BLOWING LEAVES
OR SNOW OR SOMETHING LIKE THAT,
IT’LL LOOK A LITTLE BIT
BETTER IN 4.22.
>>VICTOR: YOU HAVE ONE?
I GOT A COUPLE.
>>AMANDA: WILL NIAGARA
FULLY SUPPORT MOBILE DEVICES?
>>WYETH: YES, THAT IS
THE PLAN TO BASICALLY SUPPORT
THE UNREAL ECOSYSTEM
ALL THE WAY UP AND DOWN.
THERE MAY BE TIMES
WHERE THE FEATURE SET LAGS
A LITTLE BIT BEHIND ON MOBILE,
WHERE THE —
KIND OF — THE PROVING GROUND
FOR DEVELOPMENT IS PC,
AND THEN IT TRICKLES OUT,
BECAUSE OFTEN THAT STUFF
HAS TO BE PORTED
OR, IN SOME CASES,
EVEN REWRITTEN IN SMALL WAYS
IN ORDER TO WORK
ON SOME OF THE MOBILE DEVICES.
BUT YES, THE GOAL IS IS PARITY
ALL THE WAY UP AND DOWN,
WITHIN REASON IN THE SENSE
THAT THERE ARE —
THERE VERY WELL MAY BE VERY,
VERY OLD
OR VERY,
VERY WEAK MOBILE DEVICES
THAT DON’T SUPPORT
THE SHADING MODEL
THAT NIAGRA MIGHT RELY ON
TO GENERATE,
LIKE COMPUTE SHADERS
OR SOMETHING.
THAT MIGHT BE A HARD
FEATURE CUTOFF
FOR A DEVICE RELATED TO NIAGARA,
IN WHICH CASE YOU SHOULD BE
USING CASCADE FOR THOSE
REALLY,
REALLY LOW-END DEVICES.
>>VICTOR: IS THERE A WAY
TO SET CUSTOM STENCIL DEPTHS
TO NIAGARA PARTICLES?
>>WYETH: THERE IS NOT.
THAT COMES UP A LOT.
WE WOULD LIKE TO DO THAT.
THERE ARE SOME QUESTIONS
ABOUT EXACTLY HOW,
BECAUSE THERE’S
THIS ALPHA CONCEPT,
AND USUALLY CUSTOM STENCIL
IS BASED ON A POLYGON
OR, LIKE, A MASKED RESULT.
SO WE ARE LIMITED
TO MASS PARTICLES.
IS THERE WAY WE COULD
SUPPORT THIS ON TRANSLUCENCY?
IT’S JUST A LITTLE BIT AWKWARD,
I WILL SAY THAT.
RIGHT NOW, WE DON’T SUPPORT IT.
IT’S SOMETHING
WE’VE THOUGHT ABOUT,
BECAUSE THE REQUEST COMES UP —
BUT RIGHT NOW WE DON’T EXACTLY
KNOW THE BEST WAY TO HANDLE IT.
>>VICTOR: LET’S
SEE,
IS THERE A WAY TO IMPORT
ANIMATED POINTS FROM HOUDINI?
>>WYETH: YES.
SO I DON’T KNOW IF YOU —
SIDEFX
HAS WRITTEN A DATA INTERFACE.
AGAIN, THANK YOU SIDEFX.
THEY’VE DONE THE LION’S SHARE
OF THE WORK IN THAT REGARD.
THEY HAVE A HOUDINI NIAGARA
PLUG-IN,
WHICH IS AN OPTIONAL
INSTALL AS WELL,
AND THAT INCLUDES THE ABILITY
TO BASICALLY SAMPLE ARBITRARY
POINT ATTRIBUTES FROM HOUDINI,
AND BRING THEM IN TO NIAGARA
AND DO WHATEVER YOU LIKE
WITH THEM.
THERE ARE A BUNCH
OF TRAINING VIDEOS
ON HOW TO USE THAT
ON THE SIDEFX WEBSITE
SO YOU CAN, YOU KNOW,
TAKE A TAKE A GANDER AT THAT.
I TALK TO THOSE GUYS ALL
THE TIME AND THERE ARE, I THINK,
A NUMBER OF WAYS WE COULD
CONTINUE TO COLLABORATE
WITH SIDE EFFECTS IN THE FUTURE.
NOTHING ANNOUNCED YET,
BUT I THINK THERE’S
A CLEAR PATH FORWARD
TO CONTINUING TO ADD MORE
HOUDINI-RELATED WIZARDRY
INTO THE NIAGARA WIZARDRY
TO MAKE MORE WIZARDRY.
>>AMANDA: WIZARD,
WIZARD WIZARD.
YES, WE ALL JUST NEED
SOME UE4 —
>>VICTOR: YES,
I’M THERE.
>>AMANDA: WIZARD
HATS.
>>VICTOR: I’LL PUT IT ON
FOR THE LIVE STREAM.
IT WILL HAPPEN [LAUGHTER].
YOU SAID THAT,
THAT’S A PROMISE TO CHAT.
>>WYETH: THAT’S FINE.
I LOOK GREAT IN A WIZARD HAT.
>>VICTOR: COME ON,
I’M SURE YOU DO
WITH THE BEARD, TOO.
IF YOU ARE USING MESH
ROTATION RATE,
IS THERE AN EASY WAY
TO STOP A MESH PARTICLE ROTATING
ONCE IT HITS THE GROUND?
>>WYETH: SO THERE ARE
SOME THINGS
IN THE NEW COLLISION MODULE
WHICH SHOULD MAKE THAT EASIER.
WE HAVE SOME ROTATIONAL
INERTIA VALUES
THAT USE SOME FUDGE FACTORS
YOU CAN SET,
WHICH SHOULD BASICALLY, KIND OF,
DO THE RIGHT THING-ISH.
THE OTHER THING, IS THAT
WHEN A PARTICLE COLLIDES,
WE CACHE OFF A VALUE OF WHETHER
OR NOT IT HAS COLLIDED.
AND SO THAT COULD BE SOMETHING
WHERE YOU CAN ROLE
YOUR OWN BEHAVIOR,
SO TO SPEAK,
WHERE YOU RELY ON THAT BOOL
TO BE SET IN A SCRIPT,
YES OR NO,
HAVE I COLLIDED OR NOT.
AND THEN, IN THAT,
YOU COULD DIRECTLY
SET YOUR PARTICLE ROTATION RATE
BACK TO A SANE VALUE.
I WOULD SAY THAT THE HELPER
FUNCTIONS THAT ARE COMING
WHENEVER WE GET THE FINAL
COLLISION STUFF MERGED
IN SHOULD BE ABLE TO ACCOMPLISH
WHAT THEY’RE LOOKING TO DO.
>>VICTOR: IT’S
GREAT.
ARE THERE A SET NUMBER OF POINTS
OR MAXIMUM NUMBER OF POINTS
WE CAN SAMPLE OFF A STATIC MESH
SCALES A MESH, ETC.?
>>WYETH: NO,
ON THE CPU,
YOU’RE JUST PERFORMANCE LIMITED.
WELL, YOU’RE ALWAYS PERFORMANCE
LIMITED, THAT’S JUST COMPUTERS.
BUT CPU IS —
YOU’RE MORE LIMITED
JUST BECAUSE CPU SIMULATION
IS GENERALLY MORE HEAVYWEIGHT.
SO, IN THE ECOSYSTEM WHERE YOU
CAN ONLY SAMPLE FROM THE CPU,
IT ALL DEPENDS
ON THE PERFORMANCE
BUT IF YOU’RE
ON A HIGH-END PC,
YOU MIGHT GET UP TO
50,000 PARTICLES AND
THEN YOU REALIZE IT’S
GETTING KIND OF SLOW.
>>VICTOR: UH-HUH.
>>WYETH: IF YOU’RE
ON THE GPU
AND YOU HAVE A REASONABLE
GPU,
YOU COULD SPAWN A FEW MILLION
AND NOT EVEN NOTICE.
SO REALLY, IT JUST DEPENDS ON
THE AMOUNT OF WORK YOU’RE DOING.
IF YOU’RE JUST
SPAWNING PARTICLES
AND TELLING THEM
WHAT COLOR TO BE
AND TO FLY OFF IN A DIRECTION,
THAT’S MORE LIGHTWEIGHT
THAN DOING A BUNCH OF LOGIC
IN THE PARTICLE SYSTEM ITSELF,
YOU KNOW.
THE MORE MATH YOU DO —
AT THE END OF THE DAY,
NIAGARA IS JUST
COMPILING SHADERS.
IT’S A BIG SHADER
UNDER THE HOOD.
THE MORE MATH OPERATIONS
YOU ADD TO THAT SHADER,
THE SLOWER IT GETS.
SO THAT’S JUST KIND
OF
THE NATURE OF THE BEAST,
SO TO SPEAK.
>>VICTOR: SOUNDS
GOOD.
THEY’RE ASKING
IF IT’S POSSIBLE FOR THEM
TO GET MORE HELPER FUNCTIONS,
AND THEY ARE MAKING
ONE SPECIFIC ONE.
“CONSTRUCTING MY OWN QUATERNION
OUT OF A FOUR-VECTOR
IS NOT NICE.”
>>WYETH: YEAH,
WE DON’T EVER WANT TO WORK
WITH QUATERNION.
THOSE ARE SCARY.
NO, WE DO ACTUALLY HAVE
SOME HELPER FUNCTIONS
FOR QUATERNIONS.
I BELIEVE WE HAVE
AN EULER-TO-QUATERNION FUNCTION.
YOU GIVE IT EULER ANGLES —
YAW, PITCH,
AND ROLL,
WHICH ARE THE COMMON THINGS
THAT ARTISTS WOULD WORK IN
WITH ROTATION,
AND THAT OUTPUTS
A QUATERNION FOR YOU.
SO I THINK PROBABLY
THE BEST THING TO DO WOULD BE
IF THERE ARE ONES MISSING
WOULD BE TO START A THREAD
ON THE FORUM
AND SAY, LIKE,
“HEY THESE ARE THINGS
THESE ARE BEHAVIORS
THAT I END UP DOING A LOT
THAT I DON’T HAVE
A HELPER FUNCTION FOR.
COULD YOU WRITE ONE FOR ME?”
BUT WE HAVE A PRETTY GOOD
QUATERNION LIBRARY, ACTUALLY.
WE, YOU KNOW, FOR LERPING
AND THE S LERP,
MULTIPLYING, GENERATING THEM
FROM EULER ANGLES,
GENERATING THEM FROM
AN AXIS AT AN ANGLE,
OR COMING FROM A QUATERNION
BACK TO AN AXIS AND AN ANGLE.
SO, AS IT RELATES TO ROTATIONS,
WE HAVE A REASONABLE THING.
I THINK THE SPIRIT
OF THE QUESTION WAS,
“HEY, WE WANT MORE
HELPER FUNCTIONS
JUST FOR ALL KINDS
OF RANDOM STUFF.”
AND I THINK THAT’S A FAIR ASK.
WE USUALLY ADD THEM
AS WE RUN INTO A NEED.
SO IF WE’RE TRYING TO WORK
WITH QUATERNIONS
WHICH, AS A HUMAN, YOU REALLY
CAN’T MEANINGFULLY DO THAT WELL.
IT’S JUST NOT SOME
MENTAL MAPPING
THAT MAKES A LOT OF SENSE,
THEN WE WOULD SAY OH, WELL, THEN
I WANT TO WORK IN EULER ANGLES.
WELL, THEN LET’S WRITE
THE HELPER FUNCTION.
>>VICTOR: AND THE IDEA
IS THAT IF A USER COMES ACROSS
SOME OF THESE AND
THEY BUILD HELPER
FUNCTIONS FOR THEM,
IT’S MEANT TO BE
EASILY SHAREABLE
WITH OTHER PEOPLE, RIGHT?
>>WYETH: IT’S
A UASSET.
>>VICTOR: RIGHT.
SO THEY JUST IMPORT IT
AND THEN THEY CAN USE IT
IF IT WAS SOMETHING
THAT CAME STRAIGHT
FROM YOU?
>>WYETH: OUR FAVORITE
THING TO DO
IS TO GO MAKE A CONTENT PLUGIN.
GO TO GO TO THE PLUGINS FOLDER,
MAKE A NEW CONTENT,
MAKE A NEW PLUG-IN,
CLICK CONTENT ONLY,
GIVE IT A NAME, AND IT
JUST SITS THERE.THEN YOU
CAN PUT ANYTHING YOU
WANT TO SHARE INTO IT,
AND THEN GO BACK TO THE PLUGINS
FOLDER AND HIT PUBLISH.
IT GIVES YOU A NICE LITTLE
ZIP FILE OR WHATEVER,
OR A NICE LITTLE FOLDER —
GIVE IT TO ANYONE,
AND THEY DROP IT
IN THEIR PLUGINS
FOLDER AND THEY HAVE
ALL YOUR STUFF.
THAT’S MY FAVORITE WAY TO TRADE
STUFF AROUND AS IT
COMES TO UNREAL.
>>VICTOR: AND THAT’S
A LOT THE IDEA
BEHIND THE MODULARNESS
OF EVERYTHING
THAT’S IN THE ENGINE.
THEY’RE ALSO ASKING ABOUT A GOOD
TUTORIAL SERIES ON NIAGARA.
>>WYETH: YEAH,
SO ONE OF THE DOWNSIDES
TO US BEING IN EARLY ACCESS
IS WE DON’T START
A REALLY BIG DOCUMENTATION
UNTIL WE’RE OUT.
SO THE THERE’S A LOT
OF TRIBAL KNOWLEDGE,
THERE’S A LOT OF
PIECEMEAL KNOWLEDGE.
WE DO HAVE A SMALL BLOG
WE POSTED A COUPLE OF THINGS TO,
WE POSTED A COUPLE
OF OTHER THINGS ON THE FORUMS.
WE TRY TO DO THESE TO EDUCATE.
I DON’T THINK
THAT’S REALLY GONNA CHANGE MUCH
UNTIL WE’RE OUT OF EARLY ACCESS,
AND THEN WE ARE GONNA ABSOLUTELY
BLITZ WITH DOCUMENTATION.
SO WE’RE GONNA GO — WE’RE GONNA
GO PRETTY HEAVY-HANDED ON IT
AND REALLY, REALLY TRY TO MAKE
PEOPLE UNDERSTAND
WHY THE TOOL EXISTS AND NOT JUST
HOW TO CLICK THE BUTTONS.
BECAUSE, FUNDAMENTALLY,
THE IDEAS BEHIND NIAGARA
ARE VERY DIFFERENT FROM CASCADE.
THE WHY WOULD DO
SOMETHING IS REALLY DIFFERENT,
AND A LOT OF THE IDEAS
DON’T DON’T MAP
MENTALLY BETWEEN THE TWO.
SO WE’RE GONNA NEED
TO DO OUR DUE DILIGENCE
WHEN IT COMES TO DOCUMENTATION,
BUT THAT’S NOT REALLY
GONNA COME TILL AFTER WE’RE
OUT OF EARLY ACCESS.
>>VICTOR: LET’S
SEE.
WILL IT WORK WITH TRIANGLES
CREATED BY TESSELLATION?
AND I BELIEVE
THIS WAS IN REFERENCE
TO WHEN YOU WERE SHOWING OFF —
>>WYETH: THE STATIC MESH
SAMPLER?
>>VICTOR: I BELIEVE SO,
YES. STATIC OR SKELETAL.
>>WYETH: THAT IS
A GREAT QUESTION.
MY GUT SAYS NO.
AND THE REASON IS IS BECAUSE
A LOT OF THE WORK
WE DO UP FRONT
TO ASK FOR THOSE POSITIONS,
EVEN IF IT’S A GPU EMITTER,
ORIGINATED ON THE CPU
AND THEN GET PASSED OVER
IN BIG,
PAYLOADS OF DATA UP INTO THE
— ALMOST TEXTURES BASICALLY,
IF YOU WILL, OF DATA
JUST PACKED UP TO THE GPU,
WHICH THEN DOES THE SIM.
SO THE CPU SIDE
OF THAT EQUATION
IS NOT GOING TO UNDERSTAND
THE TESSELLATION,
WHICH IS A GPU ONLY CONCEPT.
MY GUT SAYS
THAT THAT WOULD NOT WORK.
TO BE FAIR,
I’VE NEVER TRIED THAT.
I HAVEN’T TRIED IT.
I SHOULD TRY,
IT BUT BUT I DON’T THINK
THAT WILL WORK.
>>VICTOR: IS THE RIBBON
RENDERER ON GPU
ALSO BEING WORKED ON?
>>WYETH: YEAH,
THAT’S HIGH IN THE LIST.
IT IS NOT UNDER
ACTIVE DEVELOPMENT,
I SHOULD SAY, LIKE A COUPLE OF
THE OTHER THINGS
I MENTIONED ARE,
LIKE THE COLLISION STUFF
AND A FEW OTHER THINGS,
THE STATIC
AND SKELETAL MESH SIDE.
WE HAVE PORTED OVER TIME MORE
AND MORE PIECES OF THE RIBBON
RENDERING AND GENERATION CODE
TO THE GPU AS WE’VE GONE ALONG.
SO WE’RE CLOSE NOW.
BUT WE’RE NOT EXACTLY
RIGHT THERE AT THE MOMENT,
WE’RE GONNA START
IMPLEMENTING THAT.
BUT THAT IS HIGH
ON OUR LIST,
BECAUSE WE WOULD LIKE
TO BE IN A POSITION
WHERE WE CAN GENERATE A REALLY
SUBSTANTIAL NUMBER OF RIBBONS,
BECAUSE THERE ARE A BUNCH
OF AESTHETIC LOOKS
THAT ARE REALLY APPEALING,
I THINK, WHEN YOU START TO
TALK ABOUT THAT. LIKE BEING
ABLE TO ON THE GPU, SAMPLE
SCALE TO MESH ON THE GPU,
GET ALL
THESE DIFFERENT POSITIONS,
AND THEN BASICALLY DO FUR.
AND THERE’S REALLY NO REASON
WHY YOU COULDN’T DO
SOMETHING LIKE FUR
USING A RIBBON SIM, YOU KNOW,
AND BLOW THEM AROUND WITH WIND
AND DO CURL HOLES.
AND THERE’S A NUMBER OF THINGS
THAT ACTUALLY DOES REMIND ME —
I’LL LOAD THIS
WHILE WE’RE THINKING.
>>VICTOR: DO YOU WANT
TO GRAB ANOTHER QUESTION
WHILE YOU’RE DOING THAT?
YOU ARE MULTITASKER THEN —
>>WYETH: YEAH,
PLEASE DO.
>>VICTOR: THE SAMPLE
TEXTURE,
CAN IT BE AN ANIMATED TEXTURE,
IMAGE SEQUENCE, OR A FLIPBOOK?
>>WYETH: YES. WE HAVE
A FLIPBOOK SUB-UV SAMPLER NODE
IN THE NIAGARA FUNCTIONS,
WHICH COULD DO A FLIPBOOK STYLE
LOOKUP FOR YOU,
AND IT COULD BE A RENDER TARGET.
WE’VE ALREADY
EXPERIMENTED WITH THAT,
AND IT’S REALLY
QUITE BEAUTIFUL.
YOU HAVE A RENDER TARGET DOING A
FLUID SIMULATION OR SOMETHING,
AND THEN YOU GIVE THOSE
ATTRIBUTES TO YOUR NIAGARA SIM
AND IT WORKS,
AND IT LOOKS AMAZING.
>>VICTOR: THAT’S
SUPER COOL.
>>WYETH: IF
YOU WANT TO SWITCH
OVER TO THIS SCREEN
REALLY QUICK,
I WAS GOING TO SHOW OFF,
SPEAKING OF FUR.
THIS IS ANOTHER THING
THAT WE HAVE IN 4.22
IS A PENDULUM COMPONENT.
SO, THIS IS US
STARTING TO DABBLE
A LITTLE BIT IN CONSTRAINTS —
NOT JUST FORCES,
BUT ALSO CONSTRAINTS.
SO, THIS IS A CPU
OR GPU LEVEL CONSTRAINT
THAT BASICALLY
GIVES YOU A PENDULUM,
AND THIS IS A SINGLE ONE,
JUST WORKING THE WAY
YOU WOULD EXPECT IT TO WORK.
THEN, OF COURSE, IF YOU SEED
THAT WITH SOME INTERESTING DATA
LIKE THE, YOU KNOW, POSITIONS
OF THE SPRINGS OR,
DISTRIBUTE THE POINTS
ON A SPHERE OR WHATEVER,
ONE THING KIND OF COOL
WE’RE DOING
IS WE BASICALLY HAVE A BUNCH OF
PENDULUMS ARRAYED ON THE SPHERE.
THEN WE GIVE THEM A TENSION
SO THEY KIND OF WANT TO GO BACK
TO WHERE THEY
ORIGINALLY STARTED,
WHERE THEY WERE
ORIGINALLY POINTING,
AND THEN
WE ALSO CALCULATE THE KINETIC
AND THE POTENTIAL ENERGY
OF THOSE PENDULUMS AS THEY MOVE,
AND WE USE THAT TO FEED
THE BRIGHTNESS OF
THE PARTICLES THEMSELVES.
AS MY POTENTIAL
AND KINETIC ENERGY GOES UP,
THE BRIGHTNESS OF
MY PARTICLES GO UP.
I FIGURED I’D SHOW
THAT REALLY QUICK,
BECAUSE THAT IS IN THERE.
ALL YOU HAVE TO DO
IS DROP A PENDULUM CONSTRAINT
INTO YOUR EMITTER
AND GIVE THAT A TRY.
>>VICTOR: ALL RIGHT,
WE STILL HAVE A FEW PAGES HERE.
>>WYETH: YEAH,
THAT’S GREAT.
TELL ME WHEN TO STOP. I’M HAPPY
TO ANSWER QUESTIONS FOREVER.
>>AMANDA: WE’VE SORTED
THAT OUT, DON’T WORRY.
>>VICTOR: YEAH, THEY WERE
ASKING AGAIN ABOUT
IF THEY WERE ABLE TO
GET BLUEPRINT EVENTS
OUT OF THE PARTICLE
COLLISION EVENTS
AND IF THAT IS THE PLAN, YES?
>>VICTOR: WELL, SO RIGHT
NOW,
GETTING DATA OUT OF A SIMULATION
IS VERY EXPENSIVE,
AND WE DON’T ACTUALLY
HAVE FORMAL PLAN
RIGHT NOW TO SUPPORT THAT.
THAT’S NOT TO SAY
THAT WE WILL NOT SUPPORT THAT.
IT’S JUST THAT RIGHT NOW
WE DON’T HAVE A FORMAL PLAN,
WHICH BASICALLY ENSURES
THE PERFORMANCE
IS NOT THE BIGGEST
SINGLE PROBLEM WITH THAT IDEA.
BECAUSE THEY’RE INHERENTLY —
PARTICULARLY IF YOU’RE TALKING
ABOUT A GPU SIM.
GETTING DATA BACK DOWN
TO BLUEPRINT.
I DON’T THINK WE’LL EVER DEAL
WITH THAT RABBIT HOLE.
ON A CPU SIDE SIM, IT IS
VERY MUCH THEORETICALLY POSSIBLE
TO PASS ATTRIBUTES OR EVENTS
FROM A SYSTEM OUT AS IT RELATES
TO WHAT IS EACH
INDIVIDUAL PARTICLE DOING.
THAT IS DOABLE.
BUT YOU’RE LOOKING AT
A SIGNIFICANT POTENTIAL
SET OF PROBLEMS.
SO, YEAH.
ONE THING THAT IS
MORE INTERESTING TO US
IS TO
BASICALLY DEFINE A PAYLOAD.
IN ESSENCE, AN —
EVENT SOMETHING
THAT WE COULD TELL A PARTICLE
TO SEND OVER THE FENCE SOMETHING
WE WOULD WRITE
INTO A STRUCT OR SOMETHING LIKE,
“HEY, YOUR POSITION
YOUR VELOCITY AND YOUR SIZE,
OR YOUR COLOR” OR SOMETHING.
THESE ARE THE ONLY THINGS
BLUEPRINT NEEDS TO CARE ABOUT.
WHY DON’T WE PACK THOSE
INTO A PAYLOAD
AND THEN WE’RE GONNA WHITELIST
THE PARTICLE TO SAY, LIKE, “HEY.
I’M HERE, AND THIS IS
MY VELOCITY” OR WHATEVER,
AND THEN BLUEPRINT IS GONNA GO,
“OH, THANKS” AND ACT ON IT.
WE DON’T SUPPORT THAT RIGHT NOW.
BUT THAT, I THINK,
IS A MUCH MORE REASONABLE
VERSION OF THIS CONCEPT
RATHER THAN AN ARBITRARY, HEY,
ANY DATA OUT OF OUR SIMULATION,
I DON’T THINK WE’RE EVER
GOING TO KIND OF GET THERE,
IF THAT MAKES SENSE.
SO NO PLANS TO SUPPORT
THAT RIGHT NOW,
WE THOUGHT A LOT ABOUT IT,
AND WE’RE THE FIRST ONES
TO ADMIT
HOW HIGH-VALUE THAT WOULD BE.
IF YOU COULD SPRAY
PARTICLES AROUND
AND HAVE THEM BOUNCE AROUND
AND THEN THE PARTICLE
HAS A TEMPERATURE VALUE
AND YOU SPRAY THEM INTO
A PILE OF LEAVES AND
THEY LIGHT THE LEAVES
ON FIRE, THAT’S —
NO ONE WOULD SAY
THAT’S NOT APPEALING.
OBVIOUSLY THAT’S
REALLY APPEALING.
WE JUST HAVE TO DO IT
IN A PERFORMANT WAY,
AND DO IT KIND OF GRACEFULLY.
SO WE WILL ADDRESS
THAT AT SOME POINT,
BUT THAT IS NOT ON THE CURRENT.
>>VICTOR: SO CURRENTLY
YOU WOULD DESIGN IT MORE
SO THAT THE BLUEPRINT ITSELF
IS PASSING DATA
TO THE PARTICLE RIGHT NOW?
>>WYETH: YEAH,
IT’S A ONE-WAY TICKET.
YEAH, YOU CAN GO IN
TO THE NIAGARA SIM ALL YOU WANT,
BUT BRINGING DATA BACK OUT
IS HARD. YEAH.
>>VICTOR: THAT’S
GREAT.
CAN YOU SPAWN PARTICLES
OFF OF A MATERIAL?
>>WYETH: NOT DIRECTLY.
SO, IN ORDER TO DO THAT,
YOU WOULD NEED
TO DO THE DRAW MATERIAL
TO RENDER TARGET
BLUEPRINT FUNCTION.
YOU WOULD WRITE THE RESULT
OF THE MATERIAL
TO THE RENDER TARGET,
AND THEN YOU WOULD SAMPLE
THAT USING THE SAMPLE TEXTURE
SIMILAR TO OUR EXAMPLE
IN THE CONTENT EXAMPLES.
SO, YES, IN THE SENSE
YOU COULD HAVE
A COMPLEX MATERIAL,
DOING SOMETHING
INTERESTING.
LIKE, LET’S SAY, CAUSTICS.
THEN YOU COULD USE THAT
TO HAVE YOUR PARTICLES SAMPLE
THAT AS A TEXT —
THE FINAL RESULT
IS A TEXTURE,
AND THEN DO SOME THINGS WITH IT.
>>VICTOR: SO A LITTLE
BIT OF A ROUNDABOUT WAY.
>>VICTOR: THERE’S A
LAYER
OF — INDIRECTION THERE,
BUT I THINK IT’S ACTUALLY
THE RIGHT LEVEL OF INDIRECTION,
BECAUSE YOU’RE NOT SENDING
MUCH DOWN THE PIPE.
YOU’RE JUST SAYING, “HEY, WHAT
IS THE END RESULT OF ALL THIS?”
AND THEN YOU GIVE THAT
TO THE SIMULATION,
AND THAT WILL BE
INCREDIBLY PERFORMANT.
REALLY, REALLY PERFORMANT.
>>VICTOR: SEE, I THINK
WE TOUCHED ON THAT ONE.
CAN WE ADD IN OUR OWN
DENSITY PROFILES?
>>WYETH: OH, YES.
SO RIGHT NOW, THERE’S AN ENUM,
WHICH IS A DROP-DOWN
OF DENSITIES.
YOU COULD LOCALLY
MODIFY THAT ENUM
WITH AS MANY ENTRIES
AS YOU WANT, OR YOU —
THERE IS A TYPE IN BOX
RIGHT ON THAT SIZE BY MASS,
OR MASS BY SCALE CALCULATION
FOR A USER SUPPLY DENSITY.
SO IF YOU KNOW A
DENSITY, THEN YOU CAN
TYPE THAT IN AND IT
SHOULD READ SOMEPLACE.
>>VICTOR: GREAT,
AND THAT’S FOR 4.22 AS WELL?
>>WYETH: PREVIEW.
>>AMANDA: NICE.
>>VICTOR: CAN NIAGARA
PARTICLES INTERACT
BETWEEN THEMSELVES AND USE THEM
AS LIQUID OR SAND SIMULATION,
LIKE NVIDIA FLEX OR SOMETHING
LIKE SIMPLIFIED SPH?
>>WYETH: YEAH,
WE’VE TALKED A LOT ABOUT SPH.
I THINK THERE’S A PATH FORWARD
TO US REALLY CLEANLY
AND CLEARLY TO DO SOME SORT OF
SPH OR GRAIN-STYLE APPROACH.
I DON’T KNOW ABOUT PBD OR,
I DON’T KNOW.
WE’LL GET THERE AS FAR
AS IMPLEMENTATION SIDE,
AND WHAT WE KIND OF
WANT TO SUPPORT.
BUT THAT IS ALL THEORETICALLY
POSSIBLE.
WE WOULD NEED TO WRITE
CUSTOM CODE TO DO THAT.
I THINK IN THE SYSTEM,
AS IT STANDS,
YOU WOULD NOT BE HAPPY
WITH THAT.
ONE THING THAT WOULD BE REALLY,
REALLY NECESSARY
FOR SOMETHING LIKE THAT
IS WHAT WE WOULD CALL
A SPATIAL HASH,
SO BASICALLY AN IDEA
OF A LITTLE GRID,
AND THE GRID HAS CELLS,
AND THE CELLS KNOW HOW MANY
PARTICLES ARE IN EACH CELL,
AND WHICH PARTICLES
ARE AROUND IT.
OTHERWISE, EVERY PARTICLE
HAS TO ASK EVERY OTHER PARTICLE
IN THE WHOLE SIMULATION WHERE
THEY ARE AND WHAT THEY’RE DOING,
AND THEY CALL THAT N
SQUARED SLOW,
WHICH MEANS YOU’RE
MULTIPLYING HOWEVER MANY
BY THAT NUMBER AGAIN
IN ORDER TO SEE
HOW MANY TIMES YOU HAVE TO ASK.
WHEREAS IF YOU HAVE
A LITTLE SPATIAL STRUCTURE,
SOME SORT OF LITTLE VIRTUAL
DATA STRUCTURE, YOU CAN SAY,
“HEY, I’M ME AND I JUST NEED
TO CARE ABOUT YOU 12 GUYS.”
SO I’M GONNA ASK YOU
WHAT YOUR ATTRIBUTES ARE.
THAT CAN BE INCREDIBLY
INEXPENSIVE TO DO —
ORDERS AND ORDERS
OF MAGNITUDE LESS EXPENSIVE.
WE HAVE NOT WRITTEN
A SPATIAL HASH YET.
BUT, BELIEVE ME,
THAT’S ON THE LIST.
WE WILL SOMEDAY DO THAT,
BECAUSE THAT’S REALLY,
REALLY HIGH VALUE.
AND ONCE WE START TO DO THAT,
THEN WE CAN START TALKING ABOUT
LIKE AN SPH SIMULATION
FOR FLUIDS OR WHATEVER.
>>VICTOR: IT’S
EXCITING.
>>WYETH: YEAH,
I’M REALLY EXCITED
TO GET IT SOMEDAY. THERE’S A LOT
OF STUFF THAT WOULD UNLOCK.
SO BELIEVE, IT’S ON
OUR INTERNAL ROADMAP.
>>VICTOR: YEAH,
AND A LOT OF THIS
IS JUST A MAIN FRAMEWORK TOOL?
>>WYETH: YES.
>>VICTOR: IS IT FRIENDLY
TO SOME SOME DEGREE,
AND THEN KEEP ADDING MORE
AND MORE BETTER FEATURES?
>>WYETH:
ABSOLUTELY.
YEAH, OUR BELIEF IS THAT
WE GOT TO GET THE BONES RIGHT,
AND THEN IF WE GET THE BONES
RIGHT THEN, AS WE EXPAND,
WE EXPAND IN A WAY THAT
DOESN’T BREAK THE IDEAS BEHIND
WHY WE BUILT IT
IN THE FIRST PLACE.
>>VICTOR: IS THERE A WAY
TO WORK
WITH THE NIAGARA MODULES
FROM C++?
>>WYETH: NO. WELL,
YOU CAN WRITE NATIVE FUNCTIONS
WHICH CAN BE BROUGHT
INTO THE NODE GRAPH IN C++ CODE.
SO I COULD GO WRITE C++ CODE
TO MAKE A MODULE LIKE
EULER ANGLES TO QUATERNION.
I COULD GO WRITE THAT.
THEN I’D BE ABLE
TO DROP IT IN THE GRAPH —
IF YOU’RE EXPERIENCED
PROGRAMMER, YOU CAN GO DO THAT.
BUT THE NODE GRAPH LANGUAGE —
THE WAY THE NODE
GRAPH EVALUATES IS INTO HLSL.
SO, IF YOU ARE A PROGRAMMER
AND YOU WANT TO WRITE IN CODE,
SO TO SPEAK, YOU CAN DROP
A CUSTOM NODE DOWN.
YOU CAN WRITE CODE
RIGHT IN THAT CUSTOM NODE,
AND THAT WILL EVALUATE JUST AS
IF THE NODE GRAPH ITSELF
HAD COMPILED ITSELF
DOWN INTO HLSL ITSELF.
IT WILL EVALUATE
THE SAME WAY.
>>VICTOR: THAT’S
THE SAME CUSTOM NODE
WE USE IN THE MATERIAL
GRAPH AS WELL.
>>WYETH: IT’S
THE SAME IDEA.
>>VICTOR: SAME IDEA,
YEAH.
>>WYETH: IT’S A TOTALLY
DIFFERENT IMPLEMENTATION,
BUT THE IDEA
IS BASICALLY THE SAME, YEAH.
YOU’LL NOTICE WE HAVE A
COUPLE OF COMPLEX FUNCTIONS.
LIKE WE HAVE, LIKE,
A TRANS-MATRIX
TO QUATERNION HELPER FUNCTION
OR SOMETHING —
WHICH WOULD JUST BE A REAL BEAR
TO MAKE IN THE NODE GRAPH.
THAT ONE IS ALL WRITTEN
IN A CUSTOM NODE,
JUST BECAUSE IT’S JUST CLEANER.
SOME THINGS
ARE CLEANER IN CODE,
AND SOME THINGS ARE BETTER
TO DO IN A NODE GRAPH
SO YOU CAN SEE
THE FLOW OF EXECUTION.
IT’S, ALL YOU KNOW
SIX AND ONE —
>>AMANDA: YOU
HAVE TO FIND THE
METHOD THAT WORKS
BEST FOR THE —
>>WYETH: TOTALLY.
AND EVERY PROJECT
IS GONNA DO IT DIFFERENTLY.
I COULD SEE WHOLE PROJECTS
WHERE THEY JUST WRITE
CUSTOM NODE STUFF
INTO THEIR NODE GRAPHS LIKE IT.
HAVE AT IT.
WE SUPPORT THAT JUST FINE.
LEARN HLSL, YOU’RE GOOD.
>>VICTOR: TRY TO KEEP
THE SPAGHETTI IN CHECK.
>>WYETH: MMM-HMM,
I AGREE.
>>VICTOR: THIS USER SAID
THAT HE OFTEN STARTS
WITH AN EMITTER,
AND THEN MAKES A SYSTEM
TO PUT IT IN,
AND END UP DOING
ALL MY CHANGES IN THE SYSTEM.
IS THERE A WAY TO PROPAGATE
THE CHANGES TO THE EMITTER,
OR IF THERE
A BETTER WORKFLOW FOR THIS?
>>WYETH: THERE IS NO
BETTER WORKFLOW,
AND WE FEEL YOUR PAIN.
THAT IS HIGH IN THE LIST.
WE KNOW THAT THE INHERITANCE
FLOW NEEDS A VERSION 2,
AND WE HAVE TALKED A LOT
ABOUT THAT AND, I THINK THAT —
ALTHOUGH WE DON’T HAVE
AN ANNOUNCED FRAMEWORK FOR THAT,
I THINK WE’RE GONNA WANT TO
ADDRESS THAT RELATIVELY SOON,
WHICH IS PUSHING FROM
AN EMITTER UP TO A SYSTEM,
BEING BETTER AWARE THROUGH UX,
WHEN YOU’RE IN A SYSTEM
IN AN EMITTER,
WHAT HAS BEEN INHERITED
AND WHAT HAS BEEN ADDED
THAT’S NEW AND DIFFERENT,
COLOR CODING, DISABLING,
YOU KNOW, HIDING OF DISABLED
MODULES THAT ARE INHERITED,
ALL THESE DIFFERENT THINGS.
THEN THE ABILITY —
IF YOU HAVE MODIFIED A SYSTEM
AND YOU WANT TO PUSH BACK,
YOU HAVE THE ABILITY TO DO THAT.
THERE ARE A NUMBER OF UX
AND UI CONSIDERATIONS AROUND
THAT THAT WE WANT TO SOLVE.
WE’VE TALKED AT LENGTH
ABOUT THOSE PROBLEMS,
AND WE FEEL YOUR PAIN.
AND WE KNOW THAT’S NOT
THE PERFECT WORKFLOW
FOR YOU RIGHT NOW,
AND WE HAVE PRETTY GOOD PLANS,
I THINK, TO FIX IT.
WE JUST DON’T HAVE IT IN 4.22.
>>AMANDA: GREAT.
WHAT’S NEXT?
>>VICTOR: ALRIGHT,
I’LL CONTINUE.
WOULD IT BE POSSIBLE
TO COMBINE NIAGARA
WITH SIMULATED ACTORS,
LIKE CLOTH AND CABLE ACTORS?
>>WYETH: THAT’S AN
INTERESTING QUESTION.
SO THE CABLE COMPONENT,
I THINK, AT THE END OF THE DAY,
DOES JUST GENERATE —
>>VICTOR: IT’S
A PARTICLE.
>>WYETH: WELL,
THE POINT —
THE SIMULATION OF THE POINTS
IS PARTICLE SIM.
BUT I THINK THERE IS
PARTICLE DATA THAT IS GENERATED.
SO THE QUESTION IS WHETHER
OR NOT THAT DATA IS CONSIDERED
UNDER THE HOOD OF STATIC MESH,
OR NOT, OR SKELETAL MESH,
OR SOME OTHER SORT
OF ANIMATED MESH.
PROBABLY RIGHT NOW, THERE’S NO
GOOD WAY TO ASK FOR THAT DATA.
BUT BECAUSE IT’S SO SIMILAR
TO A STATIC MESH
IN THE WAY IT’S MADE,
I THINK WRITING A DATA INTERFACE
TO SAMPLE A CABLE COMPONENT,
FOR INSTANCE, WOULD BE PRETTY
STRAIGHTFORWARD, YOU KNOW.
IT’D BE VERY SIMILAR TO THE
SAMPLING FUNCTIONS WE HAVE NOW.
I THINK IF YOU
WANTED TO DO THAT,
YOU WOULD HAVE TO GO AND WRITE
THAT DATA INTERFACE YOURSELF.
BUT I HAVE A FEELING —
I HAVE NOT WRITTEN
THAT DATA INTERFACE MYSELF,
SO MAYBE I’M DEEPLY WRONG HERE.
MY INSTINCT SAYS IT WOULD
PROBABLY NOT BE TOO COMPLICATED
TO ASK FOR THOSE
IN VERTEX LOCATIONS
AND NORMALS
FROM THAT COMPONENT,
JUST LIKE YOU WOULD
THE STATIC MESH.
>>VICTOR: I KNOW YOU
CURRENTLY CAN GET THE LOCATIONS
OF EACH INDIVIDUAL PARTICLE
OF THE CABLE COMPONENT,
BUT I THINK THAT’S EVERYTHING
THAT’S EXPOSED AS OF RIGHT NOW.
>>WYETH: YEAH. AND THEN
THE QUESTION WOULD BE,
HOW DOES NIAGARA
ASK FOR THE DATA?
>>VICTOR: RIGHT.
>>WYETH: YOU
WOULD NEED A DATA INTERFACE
TO INGEST IT
AND FEED IT TO THE SIM.
>>VICTOR: WE SHOULD
PROBABLY DO A STREAM ENTIRELY
ON THE DATA
INTERFACES.
>>WYETH: THAT’S
A GOOD IDEA.
>>VICTOR: YEAH.
>>WYETH: YOU
KNOW WHAT WE SHOULD DO
IS DO THAT ONCE WE HAVE
THE CPU/GPU PARITY
THAT I’M TALKING
ABOUT, AND THEN WE
CAN TALK ABOUT THE
PROS AND CONS.
>>VICTOR: YEAH,
SOUNDS GREAT.
LET’S SEE HERE —
>>AMANDA: THEY’RE
WONDERING —
CAN YOU ACCESS OR CHANGE
THESE SETTINGS
THROUGH BLUEPRINT AT RUNTIME?
SO FOR EXAMPLE,
CAN YOU CHANGE THE MASS?
>>WYETH: YES.
SO, IN FACT, LET ME JUST
SHOW SOMETHING REALLY QUICK.
SO BASICALLY, IF I HAVE
A PARTICLE SYSTEM.
IF I WANT SOMETHING
TO BE EXPOSED TO THE USER —
I DON’T KNOW.
WHAT WOULD BE A GOOD —
LET’S SAY WE ARE GOING TO
EXPOSE —
WELL, THIS PENDULUM
ISN’T A GREAT EXAMPLE
BECAUSE IT’S ALL, KIND OF,
THE PARAMETERS ARE ALL TUNED
FOR IT TO WORK.
LET’S SAY I WANT TO EXPOSE
SOMETHING ON THE PARTICLE SYSTEM
TO EITHER A USER
OR, LIKE, A LEVEL DESIGNER
PLACING THIS STUFF
IN THE WORLD,
OR AN EFFECTS ARTIST PLACING
THIS IN THE WORLD,
I DO THAT THROUGH SYSTEM
EXPOSED PARAMETERS.
LET’S SAY I HAVE —
LET ME SET THIS DIRECTLY.
SO I’M JUST GOING
TO SET MASS DIRECTLY,
JUST TO KIND OF DEAL
WITH YOUR EXAMPLE.
RIGHT NOW, MASS IS JUST
SET TO ONE.
IF I GO AND MAKE A PARAMETER,
MASS IS A FLOAT CAN BE ANYTHING.
SO I’M GONNA GO MAKE
A USER-EXPOSED PARAMETER,
WHICH IS A FLOAT.
THEN I’M GOING TO CALL
THIS MY MASS.
OKAY. NOW, AND I GET TO SET
A DEFAULT ON THIS VALUE AS WELL.
IF I GO DOWN TO MY MASS
WHERE I’M SETTING MASS
DIRECTLY ON THE PARTICLE,
AND I LINK IT TO THAT THING
THAT I JUST MADE,
THAT SYSTEM
USER-EXPOSED PARAMETER,
I’M NOW INTRINSICALLY LINKING
EACH PARTICLES VALUE
OF WHAT MASS
IS SUPPOSED TO BE WITH
THIS USER-EXPOSED PARAMETER.
AND SO, IF I COMPILE THIS —
IF I GO TO THIS PARTICLE
IN THE EDITOR,
MY OVERRIDE PARAMETERS HERE —
SEE MY MASS?
IT’S RIGHT DOWN THERE,
READY FOR ME TO CHANGE.
AND IF I CHANGE THIS,
IT WILL AFFECT THEM —
MY PARTICLE MASS IN THE SIM.
YOU NOTICE HOW
MASS GOT HEAVIER,
SO IT HAS A RESISTANCE
TO, YOU KNOW,
ROTATION OR WHATEVER THERE?
LIKE, YOU KNOW, IT’S TAKING
LONGER TO RETURN BACK TO PLUMB?
THAT’S A FACTOR OF THE MASS.
THIS SAME THING WHERE YOU’RE
EXPOSING SOMETHING DOWN HERE
ON THE SYSTEM, YOU CAN SET
THIS PARAMETER VIA BLUEPRINT.
YOU JUST GO SET
A NIAGARA PARAMETER,
AND YOU CAN SET A
NIAGRA SCALAR,
NIAGARA FLOAT, NIAGARA VECTOR,
NIAGARA BOOL,
ANYTHING EXPOSED HERE
AS A USER PARAMETER,
YOU JUST SET IT DIRECTLY
ON A NIAGARA SYSTEM
AND IT DOES JUST
WHAT YOU’RE ASKING.
>>VICTOR: THAT’S
GREAT.
I THINK THAT ANSWERED
THE QUESTION.
LET’S SEE, ARE THERE PLANS
TO SIMPLIFY/IMPROVE
THE BASIC WORKFLOWS
BEYOND TEMPLATES?
>>WYETH: YES. SO
THERE ARE A NUMBER OF WAYS
IN WHICH WE THINK THE STACK —
THE PRESENTATION OF THE STACK
HERE COULD BE BETTER.
THAT INCLUDES BETTER
UNDERSTANDING OF INHERITANCE,
WHAT CAME FROM EMITTERS
AND ARE INTO SYSTEMS,
COLOR CODING POTENTIALLY
OF MODULES
AND DIFFERENT BEHAVIORS
THAT ARE COMMON.
FOR INSTANCE, THINGS
DEALING WITH COLLISION
ALL HAVING A SLIGHT TINT
TO THEM OR WHATEVER.
WHITE SPACE UTILIZATION
IS SOMETHING
THAT WE WANT TO IMPROVE,
IN LINE CURVE EDITOR AND THE,
YOU KNOW, KIND OF
LIKE COLOR PICKING STUFF.
I THINK THERE’S ROOM
FOR IMPROVEMENT THERE.
THEN ALL THE STUFF
I WAS TALKING ABOUT
AS FAR AS PASSING INHERITANCE
UP AND DOWN THE CHAIN,
I THINK THAT WILL HELP
WORKFLOW A LOT.
ALSO, INSIDE OF
THOSE TEMPLATES,
MAKING MORE BEHAVIORS
IN THE TEMPLATES,
AND THEN MORE SYSTEM TEMPLATES
THAT HAVE LINKED BEHAVIORS
TOGETHER, WHERE TWO
OR THREE DIFFERENT EMITTERS
ARE ALL ACTING IN TANDEM
TO DO —
TO ACHIEVE A RESULT,
PACKING THOSE ALL INTO
A SYSTEM TEMPLATE
BEHAVIOR AND APPLYING
THAT AS WELL.
THOSE ARE, KIND OF —
THOSE ARE KIND OF
THE THE MAIN WAYS
IN WHICH WE WANT TO MOVE TO,
KIND OF, THE NEXT STEP
OF UX AND WORKFLOW.
>>VICTOR: ALL
RIGHT.
AND I THINK IT’S TIME
FOR THE LAST QUESTION.
>>WYETH: OKAY.
>>VICTOR: YEAH,
AND THIS ONE WILL BE —
I PICKED THIS ONE
BECAUSE I WAS CURIOUS
AND WE DID TALK
ABOUT A LITTLE BEFORE.
IS THERE ANY PROGRESS
WITH AUDIO SUPPORT IN NIAGARA?
>>WYETH: YEAH.
WHAT WOULD NEED TO HAPPEN
IS WE WOULD BASICALLY NEED
TO HAVE A DATA INTERFACE —
SO THE DATA INTERFACE IS
JUST PHILOSOPHICALLY
THE CONDUIT INTO NIAGARA
FROM OUTSIDE.
AND THAT MIGHT BE FROM OUTSIDE
FROM A DCC PACKAGE,
THAT MIGHT BE FROM
ANOTHER PART OF UNREAL,
LIKE THE PHYSICS SYSTEM,
OR THE SKELETAL MESH
ANIMATION SYSTEM OR,
IN YOUR CASE, THE AUDIO SYSTEM.
SO BASICALLY WHAT WE NEED TO DO,
WHICH WE HAVE NOT DONE YET
BUT WHICH, AGAIN, IS SOMETHING
WE’VE EXTENSIVELY DISCUSSED,
IS AN AUDIO DATA INTERFACE.
AND THAT WOULD BE FED
FROM THE AUDIO ENGINE.
AND WE WOULD BE ABLE
TO GET BACK WAVEFORMS
AND YOU WOULD
GET BACK INTENSITIES
AND, YOU KNOW, THE TRANSFORMS
OF THOSE INTO A SPACE
THAT MAKES SENSE
FOR A PARTICLE SIMULATION.
THERE’S NO ZERO
TECHNICAL REASON,
OTHER THAN WE JUST NEED
TO TAKE THE TIME TO WRITE IT,
THAT THAT WON’T WORK
AND BE AWESOME.
AND EVERY ONE OF US
ON THE NIAGARA TEAM
WANTS TO GO WRITE
A MUSIC VISUALIZATION.
I WANT TO DO IT IN VR, I WANT
TO DO IT WITH REAL PHYSICS,.
>>AMANDA: THAT WOULD BE
A COMPETITION,
SEE WHO MAKES THE BEST ONE.
>>WYETH: I WOULD DO IT
WITH CRAZY COLORS.
I WOULD — IF WE DO A JAM,
I’M IN THAT ONE.
>>AMANDA: ALL RIGHT.
>>WYETH: BECAUSE THAT
JUST SOUNDS LIKE SO MUCH FUN.
EVERYONE WANTS TO GET AUDIO
VISUALIZATION GOING IN NIAGARA,
AND — I THINK THEY’RE LIKE
CHOCOLATE AND PEANUT BUTTER.
I MEAN, THAT’S LIKE
A PERFECT COMBINATION.
SO NO CURRENT TRAJECTORY
FOR THAT RIGHT NOW,
BUT HIGH VALUE, HIGH DEMAND,
WE KNOW WE WANT IT,
AND THAT WOULD BE
THE WAY WE WOULD GET.
>>VICTOR: IT’S
GREAT.
THANK YOU SO MUCH
FOR COMING OUT.
>>AMANDA: YOU KNOW,
WE HAVE SO MANY PEOPLE
CHOMPING AT THE BIT THAT REALLY
WANT TO DIG IN AND USE NIAGARA.
SO FOR YOU TO COME
AND SIT ON A STREAM WITH US,
IT REALLY HELPS MOVE THEM
IN THE RIGHT DIRECTION,
AT LEAST GET PLAYING.
IT’S REALLY VALUABLE.
>>WYETH: I HOPE
SO.
I THINK 4.22,
IF YOU HAVEN’T PLAYED YET,
4.22 IS THE BEST TIME
TO START NOW,
BECAUSE A LOT OF THE ROUGH EDGES
HAVE BEEN SANDED DOWN,
AND I THINK IT’S MUCH CLOSER
TO THE TYPE OF TOOL
YOU WOULD, YOU KNOW —
YOU HAVE AN IDEA,
AND YOU CAN ACTUALLY VISUALIZE
TO THE END.
I THINK WE’RE THERE NOW,
AND NOW IT’S JUST ENHANCING
AND MAKING IT BETTER.
>>AMANDA: AWESOME.
YEAH, THANK YOU,
THANK YOU, THANK YOU.
IT MEANS A LOT TO US
AND TO THE COMMUNITY.
>>WYETH: THANKS,
EVERYBODY.
>>AMANDA: WE’VE —
I’VE TOSSED A —
GOSH,
HAVING BRAIN FARTS TODAY —
SURVEY INTO THE CHAT TODAY.
SO IF YOU’VE HAD FEEDBACK FOR US
ON HOW WE’RE DOING TODAY,
OR THINGS YOU’D LIKE
TO SEE IN THE FUTURE,
WE ALWAYS WANT TO KNOW
KINDS OF TOPICS
ARE GOING TO BENEFIT
YOU THE MOST.
SO, IF YOU LET US KNOW,
IT HELPS US SERVE THOSE NEEDS.
AND, IF YOU PROVIDE YOUR EMAIL,
WE RAFFLE AWAY A T-SHIRT
TO ONE OF THE FOLKS
THAT FILL OUT THE SURVEY.
AND SO THAT’S A SWEET WAY,
OR A SIMPLE WAY,
TO GET UNREAL ENGINE SWAG.
ALSO, CHECK FOR YOUR LOCAL UE4
MEETUPS.
THERE’S LOTS OF REALLY,
REALLY TALENTED PEOPLE
ALL OVER THE WORLD THAT ARE
WORKING IN UNREAL ENGINE.
THIS IS A GREAT WAY
TO GET TO KNOW THEM,
HELP GET FEEDBACK
ON YOUR PROJECT
IF YOU’RE HAVING PROBLEMS WITH
YOUR GAME OR PROJECT YOURSELF,
LIKE, THESE PEOPLE
CAN PROVIDE YOU HELP.
SO THEY’RE A WONDERFUL RESOURCE.
USE THEM.
AND IF YOU HAVEN’T, OR IF THERE
ISN’T ONE IN YOUR AREA,
YOU CAN ALWAYS REACH OUT TO US
AND WE’LL HELP YOU GET GOING.
YOU WANT TO TALK
ABOUT SPOTLIGHTS?
>>VICTOR: YES.
SO EVERY WEEK,
WE SHARE THREE OF OUR
COMMUNITY-MADE SPOTLIGHTS,
AND WE SPOTLIGHT THEM
AS OUR SPOTLIGHTS.
AND THERE’S A LITTLE SPOTLIGHT.
IF YOU WANT TO SEE THEM ON THE
STREAM, JUST SHARE THEM WITH US.
WE TEND TO LOOK AT THE RELEASE
AS PART OF THE FORUM,
AS WELL AS WORK IN PROGRESS.
YOU CAN ALSO CONTACT US
IN DISCORD,
OR [email protected]
IT’S A GREAT WAY
IF YOU HAVE AN ESSAY YOU WANT
TO WRITE US FOR SOME REASON.
THEY’RE HARD TO READ, SO
BE BE DELIBERATE WITH CHOICE
OF WORDS AND SENTENCES.
WE ALSO DO
A COOL LITTLE COUNTDOWN
IN THE BEGINNING OUR STREAMS,
THE LITTLE SPED UP VIDEO.
SO IF YOU WANT US TO SHOWCASE
THAT, PLEASE SEND US A VIDEO.
ONCE IT HAS BEEN SPED UP
SHOULD BE AROUND FIVE MINUTES.
>>AMANDA: WE USUALLY
RECOMMEND TAKING ABOUT
30 MINUTES OF DEVELOPMENT
AND COMPRESSING IT DOWN
TO ABOUT 5 MINUTES,
SO IT DOES HELP US
IF YOU INCLUDE YOUR LOGO,
YOUR TEAM NAME
OR YOUR STUDIO NAME,
AND THE NAME OF YOUR PROJECT
SO THAT WE CAN SHARE THAT
AND LET PEOPLE KNOW
WHAT WHAT YOU’RE WORKING ON.
>>VICTOR: THAT’S
GREAT.
IF YOU’RE STREAMING
UNREAL ENGINE ON TWITCH,
REMEMBER TO USE
THE UNREAL ENGINE TAG,
THE GAME UNREAL ENGINE.
AND THEN, OF COURSE, MAKE SURE
TO FOLLOW US ON SOCIAL MEDIA,
TWITTER,
FACEBOOK, ALL THE PLACES.
>>AMANDA: INSTAGRAM.
>>VICTOR: ALL THE PLACES
EVERYWHERE.
>>AMANDA: WE’RE ALWAYS
POSTING REALLY BEAUTIFUL
PICTURES ON INSTAGRAM,
SO THAT’S A GREAT WAY FOR
A PROJECT TO SURFACE AS WELL.
AGAIN, PLEASE #UE4JAM
IF YOU’RE TWEETING
ABOUT YOUR PROGRESS
OVER THE JAM THIS WEEKEND.
WE’RE GONNA BE AROUND TO ANSWER
QUESTIONS ON THE FORUMS,
IF YOU HAVE LAST-MINUTE
JAM QUESTIONS,
AND ANY QUESTIONS
WE DIDN’T GET TO YOU TODAY,
CAN WE SEND THEM TO YOU AND TOSS
THEM UP ON THE FORUMS, MAYBE?
>>WYETH:
ABSOLUTELY.
>>AMANDA: SO IF YOU DO
HAVE MORE QUESTIONS
THAT WE DIDN’T GET,
TO WE’LL TRY TO FOLLOW UP
ON THE FORUM POST ABOUT THAT.
SO, AGAIN, THANK YOU SO MUCH.
>>WYETH: MY
PLEASURE.
>>AMANDA: IT’S BEEN AN
ABSOLUTE TREAT,
AND I HOPE WE CAN GET JOHN
ON MAYBE,
AND ABSOLUTELY DO MORE
NIAGARA STREAMS IN THE FUTURE.
>>WYETH: I’M IN.
>>AMANDA: GREAT.
THANK YOU,
GOOD LUCK TO ALL THE JAMMERS,
AND WE’LL SEE YOU NEXT WEEK.
TAKE CARE EVERYONE.
>>VICTOR: BYE
EVERYONE.
>>AMANDA: BYE.
[MUSIC]

13 Replies to “Niagara: What’s New | Live Training | Inside Unreal”

  1. 4:57 – News
    8:47 – Start
    11:04 – Niagara changes 4.22
    11:40 – Content Examples 1.1 Simple Sprite Emitter (Initialize Particle)
    14:25 – Content Examples 2.1 Static Beam (Curl noise)
    17:54 – Content Examples 3.1 Static Mesh Sampling
    24:32 – Content Examples 3.2 Renderer Overrides
    29:40 – Content Examples 3.3 Skeletal Mesh Reproduction
    38:46 – GPU Skeleton/Texture Sampling (WIP)
    41:06 – GPU-CPU Dynamic Load balancing (TODO)
    42:05 – Content Examples 3.3 (Generate Location Event)
    44:55 – Content Examples 3.4 GPU Texture Sampling
    48:50 – Particle Mass
    57:15 – New Collisions (WIP)
    59:07 – Pseudo Volume Textures
    1:00:57 – Determinism (Seed based/pseudo random)

    1:08:00 – #UE4Jam Announce

    1:14:50 – Questions
    1:15:09 – Niagara Release? (not yet)
    1:17:06 – Setting Components dynamically? (WIP)
    1:17:47 – Wind Actor Support? (No)
    1:19:23 – Mobile Support?
    1:20:20 – Custom Stencil Depth? (not yet)
    1:21:00 – Import From Houdini? (Yes, by Houdini Niagara Plugin)
    1:22:19 – Rotation change on collision? (Yes, new collision implementation)
    1:23:15 – Sampling limit? (no, only performance)
    1:24:18 – More Helper Functions? (request one on forums)
    1:25:44 – Sharing the assets (Content Plugin)
    1:26:28 – Tutorials on Niagara? (not yet, until release from early access)
    1:27:29 – Tessellation sampling? (No)
    1:28:18 – GPU Ribbon renderer? (WIP)
    1:29:36 – Can sampled texture be animation or a flipbook? (yes)
    1:30:10 – Pendulum Component
    1:31:34 – Get BP Event out of Particle Event? (not yet, expensive)
    1:34:03 – Spawn particle from material? (yes, not directly, by render target)
    1:34:58 – Custom Density? (yes, by enum or by value)
    1:35:31 – Particle-particle interaction, liquid, SPH? (not yet)
    1:37:41 – Work on Niagara modules from C++? (by native functions, HLSL)
    1:39:12 – Move changes from System to Emitter? (WIP)
    1:40:26 – Niagara + Cloth, Cable Actors? (DIY)
    1:42:10 – Access System from BP? (Yes, User Exposed Param)
    1:44:59 – Simplify workflow with templates? (Yes, WIP)
    1:46:16 – Audio Support in Niagara? (WIP, outside to Niagara)

  2. Still quite a bit of sharp corners everywhere. I know that Epic pushing for people to use Niagara but it just doesn't seem like it's ready, doesn't?. Keep up the good progress on Niagara going Epic.

  3. A whole lot of awesome work right here! But let's be honest, the Niagara UI is sh*t 😀 No, but seriously, it is nowhere near beeing intuitive. If you want to keep it like that, pls release an in-depth (and I mean really in-depth) video about that. Everyone who is eager to use Niagara will kiss your feet. Me personally I couldn't even set up a basic particle system after 2-3 hours trying to figure out what Niagara uassets I need, where to put in my values where to program my behaviour etc. and I have some experience with writing particle systems from scratch in code. Niagara is a beast, teach us how to control it!

  4. 44:50 “Mass of one cancels out”. Doesn’t that go against the physics and real world based things that follow? Mass of one sounds like 1kg and that’s not nothing. Engineering optimizations taking priority over real world numbers?

  5. Wonderful session! Thank you very much. For the example 3.3, is it possible to make it happen across two different niagara particle systems? Such as the influencer is in one particle system and the mesh reproduced particles are in the other one?

  6. Really intrigued by this tool and I do want to use it but the truth is as such most artists barely know how to manage a simple shader or script properly I doubt very many of them will ever truly leverage the full power of this tool. Look what persistent studios had to do they believed if they presented a fully scriptable editor most people would be smart enough to pick it up, now they have had to add in another layer of work onto their UI and pipeline to make the tool more "intuitive" for artists who want the path of least resistance. Team needs to focus on making the UI and application of the tool more digestible for the lay man. Cascade has this as the UI is very intuitive and its easy to quantify parameters.

Leave a Reply

Your email address will not be published. Required fields are marked *