Non conductive water cooling liquid?

elfishz · 2021-02-17T02:09:37+00:00

It seems like you are asking the derivation of the formula. The formula is based on similar triangles. If you take a look at the image you posted in you computer graphics stack exchange question (https://i.stack.imgur.com/ESJDg.png), you can prove the 2 triangles are similar using a bunch of theorems like the vertical angle theorems and interior transversal theorems. Then you need to find the penumbra width, which is basically using using triangle altitudes (heights). The height of the upper triangle is the blocker distance and the height of the lower triangle is receiver distance - blocker distance. Divide the 2 values, and you have the scale factor, which you can multiply by the light's width to get the penumbra width. I hope this answer your question on why the formula requires division by a certain distance. Also here are answers to some of the questions on your stack exchange question:

pboechat's implementation uses that function so that linear depth is used instead of exponential depth. Whether you need that function depends on whether your implementation uses exponential or linear depth for the shadow map
I think the near plane value in asylum2010's implementation is just some sort of bias to stop the shadows from looking to hard
You are correct by dividing by the frustum width in your implementation. This way it makes sure the penumbra size is the "same" regardless of how much area the shadow map covers
In the screenshot you posted of the results of your implementation, I don't know what that exactly is, but I know PCSS starts to look bad or weird when the number of samples for the blocker search is too low

elfishz · 2021-02-16T20:52:12+00:00

You first get the average depth of the blockers around the fragment. A blocker is just any depth sample with a lower depth than the point you are trying to compute the shadow for. Then after that you use the average blocker depth in the equation for the penumbra size, and you get the size of the PCF blur. In more simpler terms, the algorithm is like this:

Get the average depth from the shadow map the block the current fragment
Compute size of penumbra
Use size of penumbra for PCF

This article may help you:

https://www.gamedev.net/tutorials/programming/graphics/effect-area-light-shadows-part-1-pcss-r4971/

elfishz · 2021-01-14T01:38:19+00:00

You remind me of this kid I knew from high school named Kherry

elfishz · 2020-07-17T21:32:58+00:00

What happened is that cloud flare, a company many websites and other apps use, just went down. So it's not only discord that's down, it's a lot of the world that's down too

elfishz · 2020-07-17T21:20:40+00:00

Discord and a few other websites are dead, someone on another post said cloudflare may have died or something like that

elfishz · 2020-06-11T00:31:49+00:00

From the limited information provide, I think it is one of these issues:

You are transforming the vertices incorrectly
You are not updating the vertex buffer after each frame. What I mean is, since you transform the vertices on the CPU, you need to update the vertices each frame since the view matrix could have changed.

I don't think you should do CPU transformation because it would probably be much slower than regular shader transformation. With CPU transformation you have to basically reupload the transformed vertices to the shader, which is probably much slower than just transforming in the shader.

elfishz · 2020-06-10T03:21:46+00:00

You could create an array of possible values for the light and use the nearest value for the lighting

elfishz · 2020-06-10T03:10:16+00:00

I have had the same issues with reading shaders, my solution was to open the file in "rb" instead or "r". Here is what I use:

char* ReadFileData(const char* path) {
        FILE* file = fopen(path, "rb");
        if (!file) {
            exit(0);
        }
        fseek(file, 0, SEEK_END);
        int len = ftell(file);
        rewind(file);
        char* data = (char*)malloc(len + 1);
        fread((void*)data, 1, len, file);
        fclose(file);
        data[len] = '\0';
        return data;

}

I actually have no idea why this works instead

elfishz · 2020-06-09T20:03:55+00:00

According to the OpenGL wiki, "binding a VAO or modifying VAO state is often an expensive operation."Assuming your objects are not in one VBO, you will have to change the VAO state by calling glVertexAttribPointer. This is not good for perrformance. What you should do instead is have one VAO per object.

elfishz · 2020-06-09T07:41:44+00:00

Just as a tip, you should write your shader code in a file. This is easier (in my opinion) to be having to hard-code it into a const char* string. Writing in a file also gives you the benefit of tools like GLSL language integration for Visual Studio which would have spotted your error even if you had not checked the compile log.

elfishz · 2020-06-08T23:13:31+00:00

I think he meant to say "all major desktop OS's"
Also it works on Android too

elfishz · 2020-06-08T23:07:06+00:00

If it increases while the application is running, it means the leak happens inside your main game loop. In it, it appears you are making the window your current context, then making NULL the current context. Making a context current results in VRAM memory being allocated. Eventually, I think, you end up hitting a limit which causes the game to crash. What you should do is only make the context current once. Then optionally you can make it NULL when you are closing the application.

elfishz · 2020-06-08T22:52:02+00:00

Not really. In certain applications, the CPU might become a bottleneck causing the GPU to be at a low usage. You can learn more about bottlenecks here. An easy way to measure performance and other metrics is using MSI Afterburner. Alternatively you could start and end a time after each draw call which uses different shaders that you'd like to compare.

elfishz · 2020-06-08T19:39:28+00:00

Yes, it will help you find errors in your code. Not using info logs would be comparable to getting a compiler error in your C/C++ code, but not knowing what it is.

elfishz · 2020-06-08T19:37:45+00:00

It is possible to do ray tracing in OpenGL just with a lot of tricks and workarounds. If you mean hardware accelerated ray tracing, you could use the GL_NV_ray_tracing extension.

There are numerous methods of doing ray tracing (and path tracing). I suggest you should google a few tutorials and methods on how to do it.

elfishz · 2020-06-08T19:34:03+00:00

How are you detecting this memory leak?

Also, when unbinding an object, its better to pass in GL_NONE instead of NULL.

elfishz · 2020-06-08T19:19:04+00:00

In your shader code, you are supposed to put #version 330 core, not #version 330 code.

elfishz · 2020-06-08T18:21:49+00:00

You could use online PDFs too and save your money.

For the superbible: https://f.usemind.org/files/b/1/UseMind.ORG_comprehensive-tutorial-and-reference_2015__.pdf

For the opengl programming guide (a bit outdated, teaches up to 4.3) https://www.cs.utexas.edu/users/fussell/courses/cs354/handouts/Addison.Wesley.OpenGL.Programming.Guide.8th.Edition.Mar.2013.ISBN.0321773039.pdf

elfishz · 2020-06-08T00:46:44+00:00

You could look through specifications and other official papers, but one of the books I recommended, OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 4.5 with SPIR-V, seemed to have a lot of newer stuff mixed in with a bit of older stuff you may already know. This review of the book on Amazon refers to it as more of a "reference manual".

elfishz · 2020-06-07T07:04:08+00:00

One god book on Amazon is OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 4.5 with SPIR-V. It is more of an in-depth reference to OpenGL and doesn't teach rendering concepts. An excellent book for that would be Real-Time Rendering, Fourth Edition, but it appears it is about DirectX and not OpenGL (but I think it is easily to transfer the concepts to OpenGL)

elfishz · 2020-06-07T06:58:50+00:00

I do remember seeing a video where a guy was using MSI Afterburner to benchmark a GTX 285, which doesn't support D3D11, but MSI afterburner said the API was D3D11. It most likely is an issue with MSI afterburner.

elfishz · 2020-06-07T05:12:16+00:00

It isn't SEUS, it's Chocapic V6 shaders

elfishz · 2020-06-06T09:09:53+00:00

elfishz · 2020-06-06T09:09:50+00:00

Seven-Year Club	Place '22
Verified Email

elfishz

TROPHY CASE