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 ... 48
Never tested EVGA's PSUs but they have good reputation and the Supernova 750 G2 should do the job perfectly.

Downloads added:

- VS2015 Redistributable Update 3 (32-bit):

- VS2015 Redistributable Update 3 (64-bit):

yes it looks like a PSU issue. If FurMark resets your PC instantaneously, it's often caused by the PSU. Thermaltake has good PSUs but I already had some issues with them. The best are Corsair's. Try the Corsair AX760i. I have the AX860i and it's fantastic PSU. It handles all my graphics cards without problems (some of them can draw up to 500W!) and is very quiet.

Let us know.

3D-Tech News Around The Web / PC GPU Performance Hot Spots
« on: August 11, 2016, 03:13:45 PM »
Game developers shipping titles for PC and consoles are faced with many interesting rendering optimization challenges. The GPU cost of techniques like tile-based lighting or the CPU cost of the rendering API are going to impact performance very differently based on which platform is being used.


In this article I’ll be giving a select overview of some of the most impactful performance optimizations and considerations I’m frequently encountering when analyzing PC games. I won’t be diving deep into each topic; instead each section is meant to be a starting point and I’ll be providing references to existing material which will go into much more detail.


Quadrilateral Cowboy is a first-person video game about hacking and heists. Quadrilateral Cowboy uses a modified version of id Software's idTech4 engine. It uses iodoom3 as its code base (source).

- Quadrilateral Cowboy source code (ZIP)

- Quadrilateral Cowboy release trailer

3D-Tech News Around The Web / The Linux Kernel Hidden Inside Windows 10
« on: August 06, 2016, 10:34:04 AM »
Architectural overview of the Windows Subsystem for Linux:

- The Linux Kernel Hidden Inside Windows 10 - 60-page PDF

- Pico Process Overview

- Windows Subsystem for Linux Overview

Pico processes and drivers provide the foundation for the Windows Subsystem for Linux, which runs native unmodified Linux binaries by loading executable ELF binaries into a Pico process’s address space and executes them atop a Linux-compatible layer of syscalls.

3D-Tech News Around The Web / AGAA: Aggregate G-Buffer Anti-Aliasing
« on: August 06, 2016, 09:50:11 AM »
We  present  Aggregate  G-Buffer  Anti-Aliasing  (AGAA),  a  new
technique for efficient anti-aliased deferred rendering of complex
geometry using modern graphics hardware.  In geometrically com-
plex situations where many surfaces intersect a pixel, current ren-
dering systems shade each contributing surface at least
once per pixel.  As the sample density and geometric complexity increase,
the shading cost becomes prohibitive for real-time rendering. Under
deferred shading, so does the required framebuffer memory.  Our
goal is to make high per-pixel sampling rates practical for real-time
applications by substantially reducing shading costs and per-pixel
storage compared to traditional deferred shading.  AGAA uses the
rasterization pipeline to generate a compact, pre-filtered geometric
representation inside each pixel.   We shade this representation at
a fixed rate, independent of geometric complexity.  By decoupling
shading rate from geometric sampling rate, the algorithm reduces
the storage and bandwidth costs of a geometry buffer, and allows
scaling to high visibility sampling rates for anti-aliasing.  AGAA
with  2  aggregates  per-pixel  generates  results  comparable  to 
32X MSAA,  but  requires  54%  less  memory  and  is  up  to  2.6X

15-page PDF:

If you’re reading this and you’re a software developer, you’re probably running some services locally. Redis, Memcached, and Elasticsearch are software products that many rely on. What you might not know, is that these locally running services are accessible by any website you visit, making it possible for bad guys to steal the data you have locally!


Nvidia has constantly evolved the architecture of their GPUs in each generation to enhance performance and power-efficiency. While the company has discussed the changes in the programmable shader cores for the Maxwell and Pascal generation, which have generally eliminated or reduced scheduling logic and placed a greater burden on the compiler. However, Nvidia’s architects have avoided disclosing details about the fixed function graphics hardware – in some cases denying changes.

Starting with the Maxwell architecture, Nvidia high-performance GPUs have borrowed techniques from low-power mobile graphics architectures. Specifically, Maxwell and Pascal use tile-based immediate-mode rasterizers that buffer pixel output, instead of conventional full-screen immediate-mode rasterizers. Using simple DirectX shaders, we demonstrate the tile-based rasterization in Nvidia’s Maxwell and Pascal GPUs and contrast this behavior to the immediate-mode rasterizer used by AMD.

- article
- youtube video

The past year or two has marked a considerable shift in the graphics industry, one spurred on not just by faster hardware and ever demanding games, but by the evolution of two new graphics API’s: Microsoft’s DirectX 12 and Khronos Group’s Vulkan. Both API’s were created for a modern computing era, an era filled with multi-core CPU’s, ever more complex usages of GPU computing and the emergence of Virtual Reality.

Vulkan differs from Microsoft’s DirectX 12 in a number of key ways, the most obvious being Khronos Groups steadfast approach to being multi-vendor, multi-platform. Vulkan allows developers a familiar API structure whether they’re creating for a high end PC running Windows, Linux or even porting their engines to mobile platform such as Android.

We managed to snag an interview with Tom Olson (Director of Research over at ARM and chair of the Vulkan Working Group) and Neil Trevett (Vice President of Mobile Ecosystem at Nvidia and elected President of the Khronos Group).


I also noticed this kind of permanent downclocking with the GTX 1080. The only way to restore full clock speed was to unload / load the graphics driver (a reboot is fine). The downclocking was the result of overclocking tests with FurMark...

Gigabyte GTX 1080 XTREME is a nice card...  ;)

A behind-the-scenes look into the latest renderer technology powering the critically acclaimed DOOM. The lecture will cover how technology was designed for balancing a good visual quality and performance ratio. Numerous topics will be covered, among them details about the lighting solution, techniques for decoupling costs frequency and GCN specific approaches.

Slides (PDF) | source

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.

General Discussion / 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

Pages: [1] 2 3 ... 48