Albedo | NET library targeted at making Reflection programming | Reflection library

You are missing the Blend instruction to tell the pipeline how to mix the rendered colors with the old ones. In addition to that you have a duplicate #pragma instruction.

The Subshader tag only tell the pipeline when to render your objects. Usually you want to render opaque objects first so you can skip hidden transparent objects.

Here you can find infos about how to define Blending for transparent objects: https://docs.unity3d.com/Manual/SL-Blend.html

All you need to change is:

Updated 2022-03-08: Pseudo-code in my original post used plt.contourf() to plot the data. That does not work with raster image data saved in 'IMG_TIR1' dataset. Instead, plt.imshow() must be used. See detailed answer posted on 2022-03-07 for the complete procedure.

All 'IMG_name' datasets are raster image data. I modified the code to show a simple example that reads the HDF5 file with h5py, then plots the image data with matplotlib and cartopy on a Geostationary (original satellite) projection. I picked cartopy based on this comment on the Basemap site: "Deprecation Notice: Basemap is deprecated in favor of the Cartopy project." I'm sure it can be modified to use Basemap to plot and NetCDF to read the HDF5 file.

Updated code below:

The problem is that some of the parameters to pvfactors_timeseries need to be arrays, Series, etc, not scalars like you are using. This usability issue has already been noticed should be fixed in the next pvlib release (0.9.1, not yet released); see https://github.com/pvlib/pvlib-python/issues/1332

This modified version of your code runs without error:

The problem is exactly as I described in my very first comment. The values you get for p (which become your albedo image) range from 0 to 1998.34. When you store that in a byte, you're just getting the low-order 8 bits, which wrap around.

If you change this:

Turns out my code here is correct. My issue was that I was crossing the wrong vectors so my camera's view matrix was wrong.

Simplest solution is to just remove them as properties and calculate the model pos based on the object to world transform and then use your offset to set the impact origin.

That way you don't need to set those parameters in c#, it should "just work".

According to the documentation, you need to use WorldNormalVector(IN, o.Normal) instead of IN.worldNormal if you modify o.Normal;

And, to apply the normal to only one side, you can simply use a neutral normal (.5,.5,1) for the other sides and use the same lerp trick you do with the albedo:

It looks like your "TargetTexture" is giving you back a height map. Here is a post I found about how to turn a height map into a normal map. I've mashed the code you had originally together with the core of that forum post and output the normals as color so you can test and see how this works:

I create a framebuffer with mutlisample texture attachments to draw on and a framebuffer with normal texture attachments for copying result.

There's your problem; that's not going to actually work.

Doing a multisample resolve before your lighting passes makes no sense. You're effectively blending between two positions on different objects. That's not going to produce a meaningful result.

If you're going to do multisampling in deferred rendering, you have to use per-sample shading in the fragment shader and read each sample (with texelFetch on sampler2DMS) to do your lighting passes. You would also be writing to a multisample image.

Only that last image is the one that gets the multisample resolve operation done on it.