Wednesday, January 30, 2013

M51 Texture Maps

Finished all the M51 texture maps.  I ended up removing the secondary galaxy from the upper right corner.  The dust is created using the red channel of the infrared image of the galaxy.  I also painted a brownish-black color map for the dust to create variation.  Some tweaks may still need to be made, but they're at a point where I can start experimenting with particles.

Combo of layers w/ some tweaking.
Blue/Yellow Stars
Pink Nebulae
Brown-Black Dust

Tuesday, January 29, 2013

S106: Inner Edges Fixed

I fixed the ugly edges of the top pink particles of S106 by unpremultiplying by the alpha.  This made all of the edges the original pinkish hues instead of black.  It looks much better now :-).

Sunday, January 27, 2013

2nd Image Map

Finished the 2nd image map- blue and yellow stars.  Combined it with the nebula map, and everything looks pretty good.  Dust layer is next up!

Blue and yellow stars
Image map combo

Friday, January 25, 2013

Whirlpool Galaxy Texture Images

In order to have as many options as possible for the disk component of the galaxy, I'm separating the stars, nebular gas, and dust into different image maps, meaning the blue/yellow stuff, the pink stuff, and the brown/black stuff.  Here's the first of the 3 texture images- the nebular gas.

Friday, January 18, 2013

Comparing Splats and Maya Geometry

A quick comparison of the skim cam move using the splat technique vs. the 2.5D technique in maya.  Camera settings weren't perfectly aligned, so images aren't perfectly in sync.  Will rectify later.

S106 Skim Cam Compared to Maya from Kendall Litaker on Vimeo.

Wednesday, January 16, 2013

S106 & Stars

I wrote a short python script to extract the position of the stars in the original maya file. Dr. Summers will be providing me with the brightness values for the stars shortly, which will increase the realism. For now, I created white, opaque splats at all the positions. In order to nest the nebula within the star field, I took the total nebula set (~5M particles) and made them black. This way the stars can be rendered in a separate layer and composited in using a simple add function. Right now the falloff isn't being calculated correctly, but it does give the idea of what it might look like later.

S106 Close Up w/ Pseudo-Stars from Kendall Litaker on Vimeo.

New Camera Moves

Close Up Cam:

S106 Close Up from Kendall Litaker on Vimeo.

Skim Cam:

S106 Skim Through from Kendall Litaker on Vimeo.

Skim vs. Maya Comparison:

Tuesday, January 15, 2013

Up Close!

Animation coming later... for now, here's a still from the skim cam!

Full Comp- not sure about the black patches...
3 layers
2 layers
1 layer

Playing with the edges of the top

The top still seems to be too harsh around the edges of the holes.  I've played with the clamping on the transparent particles to see if I can get a softer effect.  I like the alpha^2 method the best.

a = a
a = a^2
a = a^3

First Animation of S106!

675 Frames.
1920 x 1080 Resplution.
5,076,103 Particles.

First Render of S106 (Thesis Work) from Kendall Litaker on Vimeo.

Render Information:

MESH                               AVG TIME/FRAME(sec)            TOTAL TIME(hrs)
Transparent                   30.35                                             5.69
Opaque                          11.85                                             2.22
Transparent                   14.31                                             2.68
Opaque                          7.39                                               1.39

Monday, January 14, 2013

Comping Stuff Together

Here are the comped layers.  I tried clamping the edge alpha more to see if I could get rid of the icky black edges... its a little better now at alpha^5 and alpha^6.

3 Layers: Low opaque, low transparent, top opaque

alpha^4 edges
alpha^5 edges
alpha^6 edges

All 4 Layers: low opaque, low transparent, top opaque, top transparent


Each Layer

So in total, I ended up with the following amounts of splats for each layer of the nebula.  (NOTE: PDF2 = quadratic, PDF3 = cubic)

Opaque:                           402,166
Transparent:                  3,715,018
Trans w/ PDF2:              1,295,449
Trans w/ PDF3:              980,540

Opaque:                           778,473
Transparent:                  7,812,353
Trans w/ PDF2:              2,600,015
Trans w/ PDF3:              1,950,661

Here's each layer from the render code:

Low Opaque
Low Transparent (PDF2)
Top Opaque
Top Transparent (PDF2)

Experimenting with the render code parameters

I started playing with the render code parameters to see if I could get a reasonable render out that was similar to maya.  The main alteration was in the exposure setting.  It was at 0.005 initially.  I changed it to 0.1, and now the opaque layer of particles seems closer to what I expected.  Here's some progress stills.

Initial Render: exposure = 0.005
exposure = 1.0
exposure = 0.5
exposure = 0.1
Alpha: the edges are brighter b/c of the curved edge build up

Full Top Opaque

Finished the top opaque layer!  Here's a render out of maya...

Friday, January 11, 2013

Full Low Opaque

I was able to render out a quick test of the low opaque set in maya.  Looks pretty good.  However, I discovered that the particles curved up around the edges, so I had to add a check in the code to make sure this wouldn't happen (basically some vector math- anything that has +- 0.75 or lower in the y axis of a unit vector between the two points is tossed).  Will need to recull, but here's a little tidbit!

Note the curved edges...

Top View

Wednesday, January 9, 2013

Low Mesh Check

So I had a small bug in the generator code, which caused the low set to be truncated in the y direction.  Other than that, everything appears to be working fine.  Opaque and transparent particles are looking the way they should.  Looks like we're ready to move on to a complete set of particles for the nebula!!

Both, from above
Both, from side
Low, opaque
Low, transparent
Low, transparent, side

Tuesday, January 8, 2013

Radius Modification Code

Added the radius modification code to determine splat size prior to sending the data to the renderer.  Got the same results as before in maya!  Also ran that through the render code, and got a different result, but should be tweaking due to the differences in how the code is run.

Render Code

Combining the Two Together

I finally combined the 2 layers together, and I think I finally have something I can work with!  The weird border edge is because the transparent set had a larger bounding box in the X and Z axes than the opaque set.  Easy fix in my generator.cpp code.  The transparent layer is too solid from the side view, but that just means some monkeying with the radius and alpha falloff values.  The method seems to be working ok.  Just need to check it with the low mesh. 

Top view, opaque and transparent.
Side view, opaque and transparent.
Both layers over a background.

Transparency Layer Check

I double checked my settings on the transparency layer as well.  Turns out the original alpha still muddies up the transparent areas despite the line of sight estimation.  I fixed this by using the same equation as the opaque layer to remap the initial alpha values prior to running the alpha calculation code (new_alpha = (old_alpha)^4).
Initial alpha results.
Remapped alpha results.

Opaque Layer Solutions!

My next test consisted of 2 separate particle sets, an opaque layer and a transparent layer.  For the opaque layer, I still needed to address the falloff into the transparent areas- they needed to be transparent enough that there wouldn't be any weird black junk like there was before.  

To fix this, I remapped the original alpha value using this equation: new_alpha = (old_alpha)^4.  This seemed to create the look I wanted. 

With the quadric falloff applied.
On a background- note the speckliness

After that, I needed a way to soften the falloff into transparency- I was getting a sprinkling of more opaque particles, creating a speckled look.  By manipulating the radius size based on the alpha amount, I was able to soften up the edges.  I tried both going larger with the radius and getting smaller (all the way to 0).  I like the larger method better.

Radius goes to 0 as alpha gets smaller.
Radius gets larger as alpha gets smaller.