By modifying the spotlight cone attenuation equation I created an area light, with shadow.
And here is a working box light The difference here is the box light uses orthographic projection and doesn't have any fading on the edges, since these are only meant to shine into windows.
If I scale the box light up and place it up in the sky, it kind of looks like a directional light. And it kind of is, expect a directional light would either use 3-4 different box lights set at rad
Some of you are earning money selling your game assets in Leadwerks Marketplace. This quick article will show you how to request a payout from the store for money you have earned. First, you need to be signed into your Leadwerks account.
Click the drop-down user menu in the upper right corner of the website header and click on the link that says "Account Balance".
On the next page you can see your account balance. As long as it is $20 or more you can withdraw the balance into you
I added spotlights to the forward clustered renderer. It's nothing too special, but it does demonstrate multiple light types working within a single pass.
I've got all the cluster data and the light index list packed into one texture buffer now. GPU data needs to be aligned to 16 bytes because everything is built around vec4 data. Consequently, some of the code that handles this stuff is really complicated. Here's a sample of some of the code that packs all this data into an array.
Texture arrays are a feature that allow you to pack multiple textures into a single one, as long as they all use the same format and size. In reality, this is just a convenience feature that packs all the textures into a single 3D texture. It allows things like cubemap lookups with a 3D texture, but the implementation is sort of inconsistent. In reality it would be much better if we were just given 1000 texture units to use. However, these can be used to pack all scene shadow maps into a single
Because variance shadow maps allow us to store pre-blurred shadow maps it also allows us to take advantage of multipled textures. MSAA is a technique that renders extra pixels around the target pixel and averages the results. This can help bring out fine lines that are smaller than a pixel onscreen, and it also greatly reduces jagged edges. I wanted to see how well this would work for rendering shadow maps, and to see if I could reduce the ragged edge appearance that shadow maps are sometimes pr
Making a multiplayer game about territory conquest, like a board game.
The winner will have the most territory.
Something like risk but no dice rolls and more simple.
So far i have:
A socket server (written in go).This has the territories stored in db.
Text communication protocol (using json). For example this is a register packet: {"t":0, "p":{"name":"test"}}
Game client that can select territories (using c++ poco network libraries)
Sqlite3 for game da
Shadows with a constant softness along their edges have always bugged me. Real shadows look like this. Notice the shadow becomes softer the further away it gets from the door frame.
Here is a mockup of roughly what that shadow looks like with a constant softness around it. It looks so fake!
How does this effect happen? There's not really any such thing as a light that all emits from a single point. The closest thing would be a very small bulb, but that still has volume. Bec
After a couple days of work I got point light shadows working in the new clustered forward renderer. This time around I wanted to see if I could get a more natural look for shadow edges, as well as reduve or eliminate shadow acne. Shadow acne is an effect that occurs when the resolution of the shadow map is too low, and incorrect depth comparisons start being made with the lit pixels: By default, any shadow mapping alogirthm will look like this, because not every pixel onscreen has an exact matc
I decided to do a small party, eating some delicious food, celebrating the success of Bladequest - The First Chapter. It had over 450 downloads over within only 7 days and counting, I had the first few sales and Josh is supporting me bringing the game on steam.
This is really awesome, thank you soo much, you make it possible for me to live my dream and make me feel the fire deep in my hearth, which gives me the power and motivation to bring my upcoming games on a new exciting quality level
Hey
I know you can use for this the nice shader of Shadmar, but now if you want to try something else,
This is somewhat like you can obtain if you use a big light sphere rounding around the player. I speed up the cycle quicker for the video to see all the day/night.
I used the directional light rotation for the shadows, the color of the sky-sphere for the colorourfull effect and the color of the directional light for the luminosity, getting the no shadow night light.
Clouds/r
I'm happy with this because I spent a long time in testing how to make rain without slowing the game too much.
I wanted the rain to have "splash" effect on the ground and to stop correctly as the player could stay under a roof or hides under a big stone etc etc..
I got big problems with collision testing and very low performances when using the shaped vegetation tool.
Now that's fine, because I do not use the collision anymore, saving much performances.
Here is a little demo:
I got the remaining glitches worked out, and the deal is that clustered forward rendering works great. It has more flexibility than deferred rendering and it performs a lot faster. This means we can use a better materials and lighting system, and at the same time have faster performance, which is great for VR especially. The video below shows a scene with 50 lights working with fast forward rendering
One of the last things I added was switching from a fixed grid size of 16x16x16 t
Doesn’t the new design of Bladequest look awesome? To celebrate it I just released Bladequest - TFC 1.4.0, including the new design and a voice over for the intro and outro screen, spoken by myself, introducing the project. I think this adds a more personal touch to the game. What do you think about it?
The game is now also available on gamejolt, running very good there! Bladequest was downloaded over 100 times within 3 days, thats awesome! To celebrate that I started a sale for the GOLD Ed
In order to get the camera frustum space dividing up correctly, I first implemented a tiled forward renderer, which just divides the screen up into a 2D grid. After working out the math with this, I was then able to add the third dimension and make an actual volumetric data structure to hold the lighting information. It took a lot of trial and error, but I finally got it working.
This screenshot shows the way the camera frustum is divided up into a cubic grid of 16x16x16 cells. Red an
I was able to partially implement clustered forward rendering. At this time, I have not divided the camera frustum up into cells and I am just handing a single point light to the fragment shader, but instead of a naive implementation that would just upload the values in a shader uniform, I am going through the route of sending light IDs in a buffer. I first tried texture buffers because they have a large maximum size and I already have a GPUMemBlock class that makes them easy to work with. Becau
This is about financial stuff, and it's not really your job to care about that, but I still think this is cool and wanted to share it with you.
People are buying stuff on our website, and although the level of sales is much lower than Steam it has been growing. Unlike Steam, sales through our website are not dependent on a third party and cannot be endangered by flooded marketplaces, strange decisions, and other random events.
Every customer I checked who used a credit card has kept it
I decided I want the voxel GI system to render direct lighting on the graphics card, so in order to make that happen I need working lights and shadows in the new renderer. Tomorrow I am going to start my implementation of clustered forward rendering to replace the deferred renderer in the next game engine. This works by dividing the camera frustum up into sectors, as shown below.
A list of visible lights for each cell is sent to the GPU. If you think about it, this is really another v
Steam Workshop was a compelling idea to allow game asset authors to sell their items for use with Leadwerks Game Engine. However, the system has turned out to have some fundamental problems, despite my best efforts to work around it.
Free items are not curated, causing the store to fill with low quality content.
Some people have reported trouble downloading items.
The publishing process is pretty tedious.
The check-out process requires adding funds to Steam Wallet, a
I was having trouble with cone tracing and decided to first try a basic GI algorithm based on a pattern of raycasts. Here is the result:
You can see this is pretty noisy, even with 25 raycasts per voxel. Cone tracing uses an average sample, which eliminates the noise problem, but it does introduce more inaccuracy into the lighting.
Next I wanted to try a more complex scene and get an estimate of performance. You may recognize the voxelized scene below as the "Sponza" scene freque
Summer is here, and you know what that means! Yes, it is time for another LEGENDARY game tournament. This year the theme is "Retro Gaming". Create a modern take on an arcade game hearkening back to the days of NES, Neo Geo, Sega, or just make anything you want. Either way, you get this totally radical poster as a prize!
How does it work? For one month, the Leadwerks community builds small playable games. Some people work alone and some team up with others. At the end of the mont
Now that we can voxelize models, enter them into a scene voxel tree structure, and perform raycasts we can finally start calculating direct lighting. I implemented support for directional and point lights, and I will come back and add spotlights later. Here we see a shadow cast from a single directional light:
And here are two point lights, one red and one green. Notice the distance falloff creates a color gradient across the floor:
The idea here is to first calculate direc
I added a raycast function to the voxel tree class and now I can perform raycasts between any two positions. This is perfect for calculating direct lighting. Shadows are calculated by performing a raycast between the voxel position and the light position, as shown in the screenshot below. Fortunately the algorithm seems to work great an there are no gaps or cracks in the shadow:
Here is the same scene using a voxel size of 10 centimeters:
If we move the light a little lower
At this point I have successfully created a sparse octree class and can insert voxelized meshes into it. An octree is a way of subdividing space into eight blocks at each level of the tree:
A sparse octree doesn't create the subnodes until they are used. For voxel data, this can save a lot of memory.
It was difficult to get the rounding and all the math completely perfect (and it has to be completely perfect!) but now I have a nice voxel tree that can follow the camera around and
.thumb.png.930e14f6185274fc318c83d22a72a188.png)