https://github.com/mmp/pbrt-v3/blob/6b6 ... et.cpp#L43

Statistics: Posted by andersll — Mon Jul 27, 2015 5:56 pm

]]>

]]>

]]>

]]>

mattpharr wrote:

The second edition had Kelemen-style MLT; the third will have Hachisuka's improved variant (now running on top of BDPT with MIS.)

Unfortunately we don't have VCM stuff or APPM in there. Basically, we can't add any more pages to the book, plus those algorithms are particularly tricky to implement. So the return on pages consumed didn't make sense--we'd have to have cut too much other content to include them.

There's always the 4th edition.

Thanks,

Matt

dr_eck wrote:I took a quick run through the comments in the BDPT integrator but couldn't determine if you have implemented Georgiev's VCM or Hachisuka's near-equivalent. I'm under the impression that these are really important contributions. Are they included? Will they be?

How about Markov Chain Monte Carlo?

Will you discuss Kelemen-style MLT versus Veach-style? (Or did I miss that because I'm still at v1.0 of your book?)

How about Adaptive Progressive Photon Mapping? (I only see SPPM in the code comments.)

PBRT is a great book. I'd love to have a copy that include all of the best available algorithms.

The second edition had Kelemen-style MLT; the third will have Hachisuka's improved variant (now running on top of BDPT with MIS.)

Unfortunately we don't have VCM stuff or APPM in there. Basically, we can't add any more pages to the book, plus those algorithms are particularly tricky to implement. So the return on pages consumed didn't make sense--we'd have to have cut too much other content to include them.

There's always the 4th edition.

Thanks,

Matt

I'm not sure how the 4th edition would solve the page count problem. Perhaps a second volume that addresses "Advanced PBRT Techniques" is called for. It could be the basis for a second semester course.

Statistics: Posted by dr_eck — Wed Jul 22, 2015 3:48 pm

]]>

]]>

[1] I am not a C++ expert, but isn't this line here redundant?

inline uint32_t LeftShift3(uint32_t x);

https://github.com/mmp/pbrt-v3/blob/mas ... vh.cpp#L81

EDIT:

[2] The depth in flattenBVHTree(BVHBuildNode *node, int *offset, int depth)

https://github.com/mmp/pbrt-v3/blob/mas ... h.cpp#L614

looks like there is no propose / use of that variable.

[3] At https://github.com/mmp/pbrt-v3/blob/mas ... h.cpp#L273

I was confused in that switch / fall break, then I notice that in PBRT source code from book 2, you have a comment that helps understand the fall and make the things more clear.

EDIT2: I added this issues into the github system.

Statistics: Posted by mrluzeiro — Tue Jul 21, 2015 7:39 am

]]>

thanks for clarification

considering "correct" interpolation, I'm still aware of why you think that multiple slerp is correct?

its transform(t) is proportional to t^n which seems wrong to me

Statistics: Posted by MohamedSakr — Tue Jul 21, 2015 4:01 am

]]>

These matrices are below:

1 0 0 0

0 1 0 0

0 0 1 0

0 0 0 1

and

1 0 0 0

0 -1 0 0

0 0 -1 0

0 0 0 1

Interpolating between these results an incorrect matrix.

For example using t = 0.5, The result is

1 0 0 0

0 0 0 0

0 0 0 0

0 0 0 1

This matrix crush all shapes to one dimensional shapes.

Therefore we should not use the linear interpolation and we can use spherical linear interpolation as one way.

* Note that in the above example, two quaternions are perfectly parallel, therefore we cannot define a plane in which an interpolated quaternion sweeps. In this case we might need to give an axis on which interpolation is considered.

Statistics: Posted by shocker_0x15 — Tue Jul 21, 2015 2:00 am

]]>

]]>

for loop should be using <=

so if we are at pixel_x = 11, filter radius = 0.5

xmin = 11 - 0.5 - 0.5 = 10

xmax = 11 - 0.5 + 0.5 + 1 = 12

loop from 10 to 12 (int i = xmin; i <= xmax; ++i)

Statistics: Posted by MohamedSakr — Mon Jul 20, 2015 8:25 pm

]]>

shiqiu1105 wrote:

It looks like all the ray tracing renders I found online uses bump mapping, including me tuba mitsuba, PDRT and in all of the graphics courses taught at the Universies too.however real-time graphics uses normal mapping which is supposed to be better than bump mapping in terms of the ability to perturbed and normals. I wonder what is the reason behind this trend.

It looks like all the ray tracing renders I found online uses bump mapping, including me tuba mitsuba, PDRT and in all of the graphics courses taught at the Universies too.however real-time graphics uses normal mapping which is supposed to be better than bump mapping in terms of the ability to perturbed and normals. I wonder what is the reason behind this trend.

Hi,

Definitely have a look at luxrender and/or SLG (GPU luxrender). I'm pretty sure they support both normal maps and bump maps.

Cheers

Statistics: Posted by ultimatemau — Mon Jul 20, 2015 4:36 pm

]]>

implicitly meaning spherical linear interpolation? if you mean simple linear interpolation, it is wrong.

I know that

Slerp(M1, M2, t) * Slerp(M3, M4, t)

is the obviously correct calculation and the result from this is what I want. However, this require two slerp calculations.

Unfortunately

Slerp(M1M3, M2M4, t) is not equal to Slerp(M1, M2, t) * Slerp(M3, M4, t).

Statistics: Posted by shocker_0x15 — Mon Jul 20, 2015 11:04 am

]]>

shocker_0x15 wrote:

It seems that Slerp(M1, M2, t) * Slerp(M3, M4, t) is not equal to Slerp(M1M3, M2M4, t).

It seems that Slerp(M1, M2, t) * Slerp(M3, M4, t) is not equal to Slerp(M1M3, M2M4, t).

let's consider both cases and check which one is true :

a) Slerp(M1, M2, t) * Slerp(M3, M4, t)

M = (t * M1 + (1 - t) * M2) * (t * M3 + (1 - t) * M4); //this looks wrong, as M will be proportional to t^N, where N is the object depth in hierarchy.

b) Slerp(M1M3, M2M4, t)

M = t * M1M3 + (1 - t) * M2M4; //this looks correct, as the term M1M3 represents the global transform at time t = t1, and M2M4 represents the local transform a time t = t2

from (a) and (b) , they are not equal., (b) is the correct approach.

so easiest and most robust solution, store t1 and t2 global transform in the object class, like this you won't calculate it when doing motion blur "just 1 Slerp calculation"

Statistics: Posted by MohamedSakr — Sun Jul 19, 2015 1:30 pm

]]>

MohamedSakr wrote:

everything should be "flat"

everything should be "flat"

As you say I firstly convert the hierarchy to a flat object list.

What I want to know is whether it is possible to convert hierarchical animated transforms to one animated transform or not.

Statistics: Posted by shocker_0x15 — Sun Jul 19, 2015 2:45 am

]]>