DEV Community: sami ourrak

How I structured my Graphics API (PiGEF)

sami ourrak — Fri, 23 May 2025 09:55:04 +0000

Hi guys, in this post, we're discussing the structure of performance, material, and Free.

Performance

It uses threads to derive the screen resolution and applies the formula (resolution) x 2 = threads.

❗ It exclusively uses GPU threads.

If you don't like the default settings, you can personalize yours, but we don't recommend it.
Material

It's a comprehensive library with a dataset, OCS, references, and light.

Data Set where all files are stored.

OCS refers to the Objects Colors Set. It pertains to those who manage the map (texture). You have two options: 1. Select from the API, or 2. Create your own. For a quicker process, we recommend option 1 for modification files and option 0 if not.
Reference

Where all the tags are stored, and if needed, it directly calls the Data Set for execution. Here are all the tags:

S(file name) indicates the shape.

M(file name or API library) denotes the map.

D(-100+100) represents the vergence.

R(0-100) refers to the reflection.

E(0-100) indicates the emissions.

Quick explanation:

0-1 signifies False and True. In setting A, the first part refers to transparency, and the second part is translucency. D from -100 to -1 is left 👈, and from +1 to 100 is right 👉.

❗ All tags and settings must be in order; otherwise, a syntax error will occur.

Thanks for reading! If you want full-on nerd 🤓, click here👇.

PiGEF: How work performance, material, and free

sami ourrak — Wed, 14 May 2025 15:02:11 +0000

Hi guys, welcome to my new post! We're discussing my next-gen API graphics.
Performance
Work with threads and cores; the number of threads and cores is determined by the screen resolution. For example, if the screen resolution is 4K, it's multiplied by 2, resulting in 8 chunks (devices). The GPU has 4 cores, so we divide each core by 2, ensuring that each thread works on a single chunk. When the grade set and color set are combined, we complete the puzzle (screen) to display the picture, or you can personalize yours, though it is not recommended.
Material
It’s a large library, and it can be heavier than including physics.
In material:
Data Set, OCS, reference, and light.

The Data Set contains all data: shape, color, dioprime, light... Imagine that Hube links to every data point in the material category. When something is in view, the Data Set calls all necessary data.
OCS, or Object Color Set, is responsible for the texture of the object. We can modify the map (texture) or choose a map from the PiGEF library, but for efficiency and speed, it truly requires precision. We indicate this with V (verify); if it’s modified, it’s 1; if not, it’s 0. In the script, we use True and False instead.
Dioprime refers to the dilation of light and is very useful for objects without spherical surfaces, particularly when you don't apply real physics (simple physics) in lens work. You can set it from -100 to 99 on the left, 0 in the middle, and 1 to 100 on the right.
Light will be discussed in the next section (because we'll talk about physics and time-lapse science). Reference It stores all data under a nickname, but you may wonder about the difference between Data Set and References in structure. The Data Set calls and prepares all data (which uses RAM if heavy), while the reference is merely the nickname and settings for each data point, which loads very quickly. We have: S (Shape); M (Map); A (Appearance); D (Dioprime); E (Emissions); and V for verification. Every reference should be in order; otherwise, a syntax error can occur, especially if you use recursion, which takes time to resolve. Now for the caliber or settings: S (file name) M (file name or API library number) A[0-1(0-100) 0-1(0-100)] D (-100 to 100) E (0-100). For those who don't know, A (Appearance): the first parameter is 0-1 (0-100) for transparency; 0 is false and 1 is true, while the second parameter is density, referring to translucence and other settings related to transparency. Thanks for reading! Follow and give a heart, and if you have questions, feel free to comment.

PiGEF: A GPU-accelerated open-source Graphics Extension

sami ourrak — Fri, 09 May 2025 13:58:28 +0000

This library and rendering engine are efficient, faster, and don't need overkill hardware.
So here is how it works:
We use a grade system from black (darker) to white (lighter) is identified and rendered by number 0 = black to 255 = white. If it is lighter, we do the white (125-255), and if not lighter but darker, we do the dark (000-124). Why? Because if we do a traditional strategy, it will lose performance and slow down it but if we do something like 20s, whichh will use like 128mb of VRAM place of GB, then we combine the grade with the color set grade.
A color set it's who takes care of color, and with two categories,r, the cool one,r blue and purple, and the warm one, red and yellow. For blinding, it should be at the exact pixel and make a different platform to optimize the first one red, then the yellow... When the is stick between them, the grade makes the emissions red be more white or pinker.
Then the final part material setits's care about quality and rendering and is heavy, for that, we use a reference for M001 is steel. If it is in the view of the player is called, then execute, but how is work when it is called we use data more. Grey is hard...
Advice: Please don't delete a folder in the library if you delete a color set; say goodbye to the color stuck in black and white.
For the next post, it is performance, more details, how work material, reference, and free.