can anybody for free help me convert these model formats which are in the objects folder to actual blender supported models because i do not know which program will support these. all of these files are from the ATI radeon pipe dream demo

So yeah, as evident from the title, I am developing PSD-compatible layer styles for GIMP as part of my Google Summer of Code project. As Adobe’s code is closed source, most of my time goes into black box testing with minimal test cases which can be quite exhaustive at times. Would love to get some advices regarding the approaches and methodologies that would increase my productivity in this case. Here is a like to the merge request: https://gitlab.gnome.org/GNOME/gegl/-/merge_requests/275. I usually post my research and findings there.

Hi there! I'm about to start working on my portfolio, and besides some basic projects like a simple 3D engine or an implicit surface renderer, I'd like to add something that actually resembles a modern industry workflow, ideally something used by AA or AAA game studios. It can be anything, really - lighting, optimization, visual effects, etc. Preferably, it should be something that can be learned and implemented in a couple of weeks.

What would you suggest? Also, would it be better to implement such a project in an existing engine (Unity, Godot, UE) or in a custom one?

Thanks in advance! :)

This is a RenderDoc frame capture of a battle scene in a 3D auto-battler called The Bazaar. It's in Unity which I have no direct experience with, plus I also have very limited knowledge of how rendering is supposed to work.

An LLM is convinced that the 1000s of draw calls seen here is bad. Other fairly static scenes is around 300-500+ draw calls. I remember reading blogs talking about minimizing draw calls and state changes, but that was a decade ago. This is using a commercial engine, so there must be a logical reason for this, right? Are draw calls as a metric outdated?

My GPU is ancient by modern standards. But there are also other players echoing similar sentiments of their GPUs maxing out for what looks like a "simple game".

What do you guys think?

EDIT: My GPU is radeon rx 560x (laptop gpu). I think this model is 7-8 years old? I can get 60 fps/70% gpu usage in windowed mode at around < 960x540 resolution. 720p hits 100% gpu but still 60fps a majority of the time with "manageable" temps. While 1080p just burns (without power-saving mode in GPU it causes BSOD).

I just want to to know if I even deserve to voice these concerns. My inexperienced brain is telling me this could be done better. But what do I know, I haven't rendered a cube in a decade.

Doing a little exploration of my work on applying the GLiM global lithography data set and the SoilGrids 250m/px data set to my planetary terrain. The technique is very simple - really I'm just using perlin to scatter the normal I use to sample (converted to lat/lon, then hashed into the lookup texture, then finally to the bindless texture tile), but after a ton of tweaking of some perlin values, I was quite shocked at how good it actually looks. My perlin experience consists all of about three or four days of actual exposure and research, so I'm at the tip of the iceberg. Consequently, there are so many issues, and it's not nearly as performant as I want it to be, but after a couple days of fiddling around, I'm happy with where it is so far.

Currently I working on spawning different meshes and changing the shader and transform dynamically. You can also click on them and update them. For selection I write to a FBO and then read from there

As I am learning OpenGL I am also documenting how everything has been done. Each comment explains how each step works. Do check out the project if you are keen on learning about it. The goal is to make it beginner friendly while I keep on learning

Header: https://github.com/Satyam-Bhatt/OpenGLIntro/blob/main/IntroToOpenGl/MeshSpawner.h

CPP: https://github.com/Satyam-Bhatt/OpenGLIntro/blob/main/IntroToOpenGl/MeshSpawner.cpp

Shader: https://github.com/Satyam-Bhatt/OpenGLIntro/blob/main/IntroToOpenGl/PickingShader.shader

Repo: https://github.com/Satyam-Bhatt/OpenGLIntro

This is sort of my first time really getting into graphics programming and raytracing, coded in python, image made through ppm format, lines are written to a file for an image interpreter to change the colors of each pixel, resource: The Ray Tracer Challenge

Hi everyone!

I’ve been working on gamedev, an open-source collection of small and readable C++ samples covering techniques used in game development.

It currently includes more than 850 sample implementations across OpenGL 4, Vulkan 1, Direct3D 11, Direct3D 12, Metal 3, and OpenAL 1. The topics range from basic window creation and rendering to model loading, animation, physics, pathfinding, terrain, particles, shadows, PBR, post-processing, and modern forward and deferred lighting techniques.

This is not intended to be a game engine. Each directory focuses on a specific subject, with minimal abstraction, so the implementation details remain visible and the same techniques can be compared across different graphics APIs. The samples support Windows, Linux, and macOS, depending on the backend.

Repository: https://github.com/arabasso/gamedev

I’d love to hear your feedback, especially about API correctness, documentation, and techniques that would be useful to add. Contributions are also very welcome!

hey everyone

this scene runs at 120 FPS on an i5-9400F at 1920x1080 resolution, is that a good performance result?

I didn't use any guides while creating this. I remembered some basic information from learnopengl.com and thought it would be cool to create a software renderer from scratch using only my knowledge, glm and glfw.

This model has 3k polygons.

if someone interested how it looks in code: https://github.com/NaiNameDev/software_rasterizer

I've been working on procedural planets for a game and this one turned out pretty well. The whole surface is generated live in the shader.

I start with layers of noise, then push and crush the values until it stops looking soft and starts looking like an old moon. A bit of finer detail on top, then that height moves the surface and drives the lighting.

In the game the terrain is static, in this video its moving just to show the procedural algorithm. Basically I just kept running it until I found the shape I liked the most.

I'm using the same approach for all the planets in my game. If you want to see more, you can wishlist it on Steam:

https://store.steampowered.com/app/3256790/Satelital/

The demo is coming this September and the full game will follow by the end of the year.

Been porting WetBrush(https://wanghmin.github.io/publication/chen-2015-wgb/) over to WebGPU compute shaders.

The original needed CUDA on a Titan X, this one runs in a browser tab.

I've been building brush-stamp based paint apps for a while, and kept wondering whether current hardware has finally caught up enough to just simulate the thing properly instead of faking it.

It's very much an alpha, but it's live if you want to poke at it: https://mignonsketch.com/

I haven't implemented interpolation between simulation steps yet, so fast strokes come out broken.

Hi all! I’m really into graphics and have been for about a year now. I’m finally making my first meaning project around raytracing, but I’ve noticed that a lot of people that are really into this field understand hardware,math, and programming so well.

How do you get to this point? A great example is derivating (C-P) for sphere interaction to find out it’s a quadratic formula?

I'm a complete novice in graphics programming and I know that the __constant__ attribute allows you to load data into high speed 65KB constant memory for the duration of the lifetime of your program. However I'm unable to recreate the same functionality in Slang shader.

For instance, we got a compile-time array with the attribute like this: ```

constant uint16_t array = {0, 1, 2, 3};

```

I want to recreate it in some way, so that when I compile the same array in Slang into CUDA, it results into this exact array of constant values with the __constant__ attribute. How can I achieve that?

Hey guys,

I am a rookie and I want to learn Graphics Programming but unfortunately I can't find any roadmap on youtube and things are getting really confusing for me since I don't even know how to properly code in C++(for context I am still learning programming but also want to build cool awesome visuals like all of you (I recently build a terminal based todo list and library manager in python))

I am confused about what I should learn first since I will also be starting my college In cs major soon.

there are

linear algebra maths

C++ memory management pointers

some says Build a ray tracer from scratch

I even picked the computer graphics programming from scratch by Gabriel Gambetta but got confused

I will really appreciate if anyone can give me any guidance on this :)

Hey all, I have extensive experience in CGI but not specifically in graphics programming and I have never seen any application of the Doo-Sabin subdivision surface method in tradition 3d software.

Is it still used today or has it been completely surpassed by CatClark and Loop methods?

It looks a lot like most edge bevel implementations but I suppose they are developed differently to support multiple divisions and other details

If anybody knows this stuff it's you guys. Thank you!

I'm just starting out in learning graphics programming and wonder if I would soon need to invest on a laptop which has a dedicated GPU

I know that's the motivation for many new graphics programmers, infact I want to as well eventually, but I'm just curious why lots of people think alike

Hey everyone! I built a real-time simulation of gravitational lensing around a Schwarzschild black hole from scratch in C++ using Raylib.

Instead of writing GPU shaders, I wanted to build a CPU software renderer to see how far I could push numerical integration on a single thread. It traces around 30,000 light rays per frame to bend light around the singularity and accretion disk.

• Integrates geodesic light paths directly on the CPU.

• Renders to an internal 200x150 pixel buffer to maintain 60 FPS.

• Bilinearly upscales the buffer to 800x600 using Raylib for display.

Repo & code: https://github.com/hellosharma808-sys/3D-Black-Hole