Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.

Messages - JeGX

Pages: 1 2 3 [4] 5 6 ... 51
Layout is a simple stacking box layout library. It's useful for calculating layouts for things like 2D user interfaces. It compiles as C99 or C++. Layout has no external dependencies, but does use stdlib.h and string.h for realloc and memset.


How to use Layout:

Code: [Select]
#include "layout.h"

// Let's pretend we're creating some kind of GUI with a master list on the
// left, and the content view on the right.

// We first need one of these
lay_context ctx;

// And we need to initialize it

// The context will automatically resize its heap buffer to grow as needed
// during use. But we can avoid multiple reallocations by reserving as much
// space as we'll need up-front. Don't worry, lay_init_context doesn't do any
// allocations, so this is our first and only alloc.
lay_reserve_items_capacity(&ctx, 1024);

// Create our root item. Items are just 2D boxes.
lay_id root = lay_item(&ctx);

// Let's pretend we have a window in our game or OS of some known dimension.
// We'll want to explicitly set our root item to be that size.
lay_set_size_xy(&ctx, root, 1280, 720);

// Set our root item to arrange its children in a row, left-to-right, in the
// order they are inserted.
lay_set_contain(&ctx, root, LAY_ROW);

// Create the item for our master list.
lay_id master_list = lay_item(&ctx);
lay_insert(&ctx, root, master_list);
// Our master list has a specific fixed width, but we want it to fill all
// available vertical space.
lay_set_size_xy(&ctx, master_list, 400, 0);
// We set our item's behavior within its parent to desire filling up available
// vertical space.
lay_set_behave(&ctx, master_list, LAY_VFILL);
// And we set it so that it will lay out its children in a column,
// top-to-bottom, in the order they are inserted.
lay_set_contain(&ctx, master_list, LAY_COLUMN);

lay_id content_view = lay_item(&ctx);
lay_insert(&ctx, root, content_view);
// The content view just wants to fill up all of the remaining space, so we
// don't need to set any size on it.
// We could just set LAY_FILL here instead of bitwise-or'ing LAY_HFILL and
// LAY_VFILL, but I want to demonstrate that this is how you combine flags.
lay_set_behave(&ctx, content_view, LAY_HFILL | LAY_VFILL);

// Normally at this point, we would probably want to create items for our
// master list and our content view and insert them. This is just a dumb fake
// example, so let's move on to finishing up.

// Run the context -- this does all of the actual calculations.

// Now we can get the calculated size of our items as 2D rectangles. The four
// components of the vector represent x and y of the top left corner, and then
// the width and height.
lay_vec4 master_list_rect = lay_get_rect(&ctx, master_list);
lay_vec4 content_view_rect = lay_get_rect(&ctx, content_view);

// master_list_rect  == {  0, 0, 400, 720}
// content_view_rect == {400, 0, 880, 720}

// If we're using an immediate-mode graphics library, we could draw our boxes
// with it now.

// You could also recursively go through the entire item hierarchy using
// lay_first_child and lay_next_sibling, or something like that.

// After you've used lay_run_context, the results should remain valid unless a
// reallocation occurs.
// However, while it's true that you could manually update the existing items
// in the context by using lay_set_size{_xy}, and then calling lay_run_context
// again, you might want to consider just rebuilding everything from scratch
// every frame. This is a lot easier to program than tedious fine-grained
// invalidation, and a context with thousands of items will probably still only
// take a handful of microseconds.
// There's no way to remove items -- once you create them and insert them,
// that's it. If we want to reset our context so that we can rebuild our layout
// tree from scratch, we use lay_reset_context:


// And now we could start over with creating the root item, inserting more
// items, etc. The reason we don't create a new context from scratch is that we
// want to reuse the buffer that was already allocated.

// But let's pretend we're shutting down our program -- we need to destroy our
// context.

// The heap-allocated buffer is now freed. The context is now invalid for use
// until lay_init_context is called on it again.

English forum / Re: Render Target is Texture Array
« on: June 19, 2016, 05:44:55 PM »
I just added the support of texture 2d array in render target. The new GeeXLab (Windows version) should be released shortly.

Geeks3D's GPU Tools / Re: furmark diff results at diff times, why?
« on: June 17, 2016, 03:34:11 PM »
It's weird because usually, FurMark gives consistent results. Maybe the GPU throttled down for some reasons (check the core clock with GPU Shark or GPU-Z to see if there's throttling). Not easy to give you an answer.

English forum / Re: Render Target is Texture Array
« on: June 17, 2016, 01:26:30 PM »
Render targets with texture 2D arrays are not supported in current GeeXLab.
But I will try to add this support in the next update (the Windows version will be updated first).


We hope you’ve been enjoying your time playing DOOM! It’s been less than a month since launch, but the team at id Software has been hard at work preparing to deploy DOOM’s next game update, which will arrive later this month.


For DOOM’s next game update, we will be releasing the patch notes later this month, which will include several improvements and features. We thought it was important to share some of those improvements with you now:
-  Added Photo Mode for taking in-game screenshots
- Added Classic DOOM weapon placement/view model option (1st person view option)
- Added new Snapmap features (including skybox windows) and AI pathing and logic fixes.
- Fixed various bugs including players accidentally triggering Dev Mode and Trophy/Achievement bugs (IDKFA, Every Nook and Cranny).



Linux Mint 18, codenamed Sarah, is based on Ubuntu 16.0.4 and is a long term support (LTS) until 2021. Beta versions (Cinnamon + MATE) are available from this link:

More information about these beta versions:
- Linux Mint 18 “Sarah” MATE – BETA Release
- Linux Mint 18 “Sarah” Cinnamon – BETA Release

Microsoft has created its own FreeBSD image. Repeat. Microsoft has created its own FreeBSD image

Microsoft has created its own version of FreeBSD 10.3 to make it available and supported in Azure.

Redmond is not keeping its work on FreeBSD to itself: Anderson says “the majority of the investments we make at the kernel level to enable network and storage performance were up-streamed into the FreeBSD 10.3 release, so anyone who downloads a FreeBSD 10.3 image from the FreeBSD Foundation will get those investments from Microsoft built in to the OS.”


3D-Tech News Around The Web / C/C++ pointers abuse
« on: June 08, 2016, 05:49:04 PM »
For those who have a hard time in understanding C/C++ pointers...

By the way, it's well-known hack to abuse pointers a little called tagged pointers. In short, if all your pointers points to blocks of memory with size of, let's say, 16 bytes (or it is always aligned on 16-byte boundary), 4 lowest bits of pointer is always zero bits and this space can be used somehow. It's very popular in LISP compilers and interpreters.

- part 1 - C/C++ pointers: yet another short example
- part 2 - C/C++ pointers: yet another abuse
- part 3 - C/C++ pointers: pointers abuse in Windows kernel

It's 2016 and we're still stuck with various shading languages - the current contenders being HLSL for Direct3D, and GLSL for OpenGL and as the "default" frontend language to generate SPIR-V for Vulkan. SPIR-V may become eventually the IL of choice for everything, but that'll take a while, so right now, you need to convert HLSL to GLSL or vice versa if you want to target both APIs.

I won't dig into the various cross-compilers today - that's a huge topic - and focus on the language similarities instead. Did you ever ask yourself how your SV_Position input is called in GLSL? Then this post is for you!


Another article that can be useful: How to Compute the Position and Normal in the Vertex Shader in OpenGL (GLSL) and Direct3D (HLSL)


As Reset development heads into the home stretch (September/October target for release) and Alpo continues working on gameplay and content, I’ve been adding missing features, fixing bugs and optimizing. One of the major remaining things was to complete the atmosphere technology. We’ve felt from the start that the world outside the gameplay area is also important for immersion. We want the player to feel like they’re on a planet and not just on an island.

- Youtube:
- Blog post:

This is chapter XIII(b) from “beta” Volume 2 of the upcoming book “Development&Deployment of Multiplayer Online Games”, which is currently being beta-tested.

There are quite a few common wisdoms when it comes to C++ and games. As it always the case when facing a bunch of common wisdoms, some of them have their merits, some are obsolete-beyond-belief, and some are just taken from a very different context and are not really applicable. Let’s take a look at the most popular ones.


x64dbg is a x64/x32 debugger that is currently in active development.

The debugger (currently) has three parts:
- Bridge

DBG is the debugging part of the debugger. It handles debugging (using TitanEngine) and will provide data for the GUI.

GUI is the graphical part of the debugger. It is built on top of Qt and it provides the user interaction.

Bridge is the communication library for the DBG and GUI part (and maybe in the future more parts). The bridge can be used to work on new features, without having to update the code of the other parts.

    Intuitive and familiar, yet new user interface
    C-like expression parser
    Full-featured debugging of DLL and EXE files (TitanEngine)
    IDA-like sidebar with jump arrows
    IDA-like instruction token highlighter (highlight registers etc.)
    Memory map
    Symbol view
    Thread view
    Content-sensitive register view
    Fully customizable color scheme
    Dynamically recognize modules and strings
    Import reconstructor integrated (Scylla)
    Fast disassembler (capstone)
    User database (JSON) for comments, labels, bookmarks etc.
    Plugin support with growing API
    Extendable, debuggable scripting language for automation
    Multi-datatype memory dump
    Basic debug symbol (PDB) support
    Dynamic stack view
    Built-in assembler (XEDParse)
    View your patches and save them to disk
    Built-in hex editor
    Find patterns in memory


The M/o/Vfuscator (short 'o', sounds like "mobfuscator") compiles programs into "mov" instructions, and only "mov" instructions. Arithmetic, comparisons, jumps, function calls, and everything else a program needs are all performed through mov operations; there is no self-modifying code, no transport-triggered calculation, and no other form of non-mov cheating.


The SUBfuscator post-processor - translates M/o/Vfuscated C into only sub instructions:

3D-Tech News Around The Web / Re: VLC media player 2.2.4 released
« on: June 06, 2016, 02:38:36 PM »
Added to the Download Zone.

3D-Tech News Around The Web / Re: Download Zone - Latest Updates
« on: June 06, 2016, 02:31:20 PM »
I added the latest version of CDBurnerXP to the DL list. I scanned it with AVG and found nothing. Seems clean.

English forum / kx framework for OpenGL and Vulkan demos
« on: June 04, 2016, 05:10:46 PM »
kx is a new Lua framework for GeeXLab that provides useful functions for your OpenGL / Vulkan demos. In this first version, the main functionality is to display statistics (framerate, frame time, GPU load, etc.)

The latest code sample pack contains demos that have been updated with this framework (see the code sample pack changelog for more info).

An empty demo with the kx framework:

English forum / How to use the gh_font module in Lua (and Python)
« on: June 04, 2016, 03:53:25 PM »
Here is an article that explains how to use the gh_font module to load True Type Fonts and display 2D texts:

English forum / GeeXLab 0.12.1 released
« on: June 04, 2016, 03:24:16 PM »
A new version of GeeXLab has been released for Windows platforms (32 and 64-bit).

More information:


Pages: 1 2 3 [4] 5 6 ... 51