• 11
• 13
• 12
• 10
• 11
• ### Similar Content

• By fleissi
Hey guys!

I'm new here and I recently started developing my own rendering engine. It's open source, based on OpenGL/DirectX and C++.
The full source code is hosted on github:
https://github.com/fleissna/flyEngine

I would appreciate if people with experience in game development / engine desgin could take a look at my source code. I'm looking for honest, constructive criticism on how to improve the engine.
I'm currently writing my master's thesis in computer science and in the recent year I've gone through all the basics about graphics programming, learned DirectX and OpenGL, read some articles on Nvidia GPU Gems, read books and integrated some of this stuff step by step into the engine.

I know about the basics, but I feel like there is some missing link that I didn't get yet to merge all those little pieces together.

Features I have so far:
- Dynamic shader generation based on material properties
- Dynamic sorting of meshes to be renderd based on shader and material
- Rendering large amounts of static meshes
- Hierarchical culling (detail + view frustum)
- Limited support for dynamic (i.e. moving) meshes
- Normal, Parallax and Relief Mapping implementations
- Wind animations based on vertex displacement
- A very basic integration of the Bullet physics engine
- Procedural Grass generation
- Some post processing effects (Depth of Field, Light Volumes, Screen Space Reflections, God Rays)
- Caching mechanisms for textures, shaders, materials and meshes

Features I would like to have:
- Global illumination methods
- Scalable physics
- Occlusion culling
- A nice procedural terrain generator
- Scripting
- Level Editing
- Sound system
- Optimization techniques

Books I have so far:
- Real-Time Rendering Third Edition
- 3D Game Programming with DirectX 11
- Vulkan Cookbook (not started yet)

I hope you guys can take a look at my source code and if you're really motivated, feel free to contribute :-)
There are some videos on youtube that demonstrate some of the features:
Procedural grass on the GPU
Procedural Terrain Engine
Quadtree detail and view frustum culling

The long term goal is to turn this into a commercial game engine. I'm aware that this is a very ambitious goal, but I'm sure it's possible if you work hard for it.

Bye,

Phil
• By tj8146
I have attached my project in a .zip file if you wish to run it for yourself.
I am making a simple 2d top-down game and I am trying to run my code to see if my window creation is working and to see if my timer is also working with it. Every time I run it though I get errors. And when I fix those errors, more come, then the same errors keep appearing. I end up just going round in circles.  Is there anyone who could help with this?

Errors when I build my code:
1>Renderer.cpp 1>c:\users\documents\opengl\game\game\renderer.h(15): error C2039: 'string': is not a member of 'std' 1>c:\program files (x86)\windows kits\10\include\10.0.16299.0\ucrt\stddef.h(18): note: see declaration of 'std' 1>c:\users\documents\opengl\game\game\renderer.h(15): error C2061: syntax error: identifier 'string' 1>c:\users\documents\opengl\game\game\renderer.cpp(28): error C2511: 'bool Game::Rendering::initialize(int,int,bool,std::string)': overloaded member function not found in 'Game::Rendering' 1>c:\users\documents\opengl\game\game\renderer.h(9): note: see declaration of 'Game::Rendering' 1>c:\users\documents\opengl\game\game\renderer.cpp(35): error C2597: illegal reference to non-static member 'Game::Rendering::window' 1>c:\users\documents\opengl\game\game\renderer.cpp(36): error C2597: illegal reference to non-static member 'Game::Rendering::window' 1>c:\users\documents\opengl\game\game\renderer.cpp(43): error C2597: illegal reference to non-static member 'Game::Rendering::window' 1>Done building project "Game.vcxproj" -- FAILED. ========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

Renderer.cpp
#include <GL/glew.h> #include <GLFW/glfw3.h> #include "Renderer.h" #include "Timer.h" #include <iostream> namespace Game { GLFWwindow* window; /* Initialize the library */ Rendering::Rendering() { mClock = new Clock; } Rendering::~Rendering() { shutdown(); } bool Rendering::initialize(uint width, uint height, bool fullscreen, std::string window_title) { if (!glfwInit()) { return -1; } /* Create a windowed mode window and its OpenGL context */ window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL); if (!window) { glfwTerminate(); return -1; } /* Make the window's context current */ glfwMakeContextCurrent(window); glViewport(0, 0, (GLsizei)width, (GLsizei)height); glOrtho(0, (GLsizei)width, (GLsizei)height, 0, 1, -1); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glfwSwapInterval(1); glEnable(GL_SMOOTH); glEnable(GL_DEPTH_TEST); glEnable(GL_BLEND); glDepthFunc(GL_LEQUAL); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable(GL_TEXTURE_2D); glLoadIdentity(); return true; } bool Rendering::render() { /* Loop until the user closes the window */ if (!glfwWindowShouldClose(window)) return false; /* Render here */ mClock->reset(); glfwPollEvents(); if (mClock->step()) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glfwSwapBuffers(window); mClock->update(); } return true; } void Rendering::shutdown() { glfwDestroyWindow(window); glfwTerminate(); } GLFWwindow* Rendering::getCurrentWindow() { return window; } } Renderer.h
#pragma once namespace Game { class Clock; class Rendering { public: Rendering(); ~Rendering(); bool initialize(uint width, uint height, bool fullscreen, std::string window_title = "Rendering window"); void shutdown(); bool render(); GLFWwindow* getCurrentWindow(); private: GLFWwindow * window; Clock* mClock; }; } Timer.cpp
#include <GL/glew.h> #include <GLFW/glfw3.h> #include <time.h> #include "Timer.h" namespace Game { Clock::Clock() : mTicksPerSecond(50), mSkipTics(1000 / mTicksPerSecond), mMaxFrameSkip(10), mLoops(0) { mLastTick = tick(); } Clock::~Clock() { } bool Clock::step() { if (tick() > mLastTick && mLoops < mMaxFrameSkip) return true; return false; } void Clock::reset() { mLoops = 0; } void Clock::update() { mLastTick += mSkipTics; mLoops++; } clock_t Clock::tick() { return clock(); } } TImer.h
#pragma once #include "Common.h" namespace Game { class Clock { public: Clock(); ~Clock(); void update(); bool step(); void reset(); clock_t tick(); private: uint mTicksPerSecond; ufloat mSkipTics; uint mMaxFrameSkip; uint mLoops; uint mLastTick; }; } Common.h
#pragma once #include <cstdio> #include <cstdlib> #include <ctime> #include <cstring> #include <cmath> #include <iostream> namespace Game { typedef unsigned char uchar; typedef unsigned short ushort; typedef unsigned int uint; typedef unsigned long ulong; typedef float ufloat; }
Game.zip
• By lxjk
Hi guys,
There are many ways to do light culling in tile-based shading. I've been playing with this idea for a while, and just want to throw it out there.
Because tile frustums are general small compared to light radius, I tried using cone test to reduce false positives introduced by commonly used sphere-frustum test.
On top of that, I use distance to camera rather than depth for near/far test (aka. sliced by spheres).
This method can be naturally extended to clustered light culling as well.
The following image shows the general ideas

Performance-wise I get around 15% improvement over sphere-frustum test. You can also see how a single light performs as the following: from left to right (1) standard rendering of a point light; then tiles passed the test of (2) sphere-frustum test; (3) cone test; (4) spherical-sliced cone test

I put the details in my blog post (https://lxjk.github.io/2018/03/25/Improve-Tile-based-Light-Culling-with-Spherical-sliced-Cone.html), GLSL source code included!

Eric

• Good evening everyone!

I was wondering if there is something equivalent of  GL_NV_blend_equation_advanced for AMD?
Basically I'm trying to find more compatible version of it.

Thank you!

• Hello guys,

How do I know? Why does wavefront not show for me?
I already checked I have non errors yet.

And my download (mega.nz) should it is original but I tried no success...
- Add blend source and png file here I have tried tried,.....

PS: Why is our community not active? I wait very longer. Stop to lie me!
Thanks !

# OpenGL Mapping OpenGL Coordinates to Screen Pixels

This topic is 1703 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

## Recommended Posts

How can I map the coordinates from an OpenGL window to a window's pixels?

For example, say I've created a 1920x1080 window, and I want to draw a certain object exactly at the pixel 360, how can I get the OpenGL coordinate value?

Also, is this even a feasible scenario? I'm coding the coordinate positioning of a bunch of objects and I want to add this option so I can, for example, do something like positioning a player's menu bar at the pixel 10 of the screen, and his inventory icon at the (width - 10).

Edit: Modern OpenGL, so I don't want to use glOrtho().

Edited by Danicco

##### Share on other sites

You can construct your own ortho matrix and load it, then it's just a simple matter of multiplying input position by ortho matrix in your vertex shader.  The documentation page for glOrtho tells you how to construct the matrix (scroll down) or you can use a matrix library to do it for you.

##### Share on other sites

If you don't want to switch from a perspective projection to a orthographic projection for the drawing of 2d elements you'll need to crunch the numbers in your projection matrix to generate a transform that converts screen coordinates to view space coordinates.  Note that it doesn't make a lot of sense to use a perspective transform to render 2d screen elements with pixel perfect alignment.  If you are dead set on a perspective transform...

// Transforming a view space point (vx, vy, vz, 1) into clip space looks like this:
|sx  0  0  0||vx|   |sx * vx     |
| 0 sy  0  0||vy| = |sx * vy     |
| 0  0 sz tz||vz|   |sz * vz + tz|
| 0  0 -1  0|| 1|   |-vz         |

// The corresponding NCD values are computed as follows:
|nx|   | (sx * vx)      / -vz |
|nx| = | (sy * vy)      / -vz |
|nz|   | (sz * vz + tz) / -vz |

// You want to go from NDC (nx, ny, nz) to view space (vx, vy, vz)
// Fortunately this is pretty simple...
vz = -tz / (nz - sz)  <-- Evaluate this first!
vx = (-vz * nx) / sx
vy = (-vz * ny) / sy
// Note that (sx, sy, sz, tz) were all pulled from your perspective transform.


Converting a pixel coordinate to NDC is a simple matter scaling and biasing one interval into another...

Range of x values in NDC:  [-1, 1]  (1 is the right of the screen and -1 is the left)

Range of y values in NDC:  [-1, 1]  (1 is the top of the screen and -1 is the bottom)

Range of x values in pixels [0, ScreenWidth-1]

Range of y values in pixels: [0, ScreenHeight-1]

I'm sure you can figure that transform out yourself.

Edited by nonoptimalrobot

##### Share on other sites

...forgot two things.

1) Here is how a perspective transform is constructed for OpenGL:  http://www.songho.ca/opengl/gl_projectionmatrix.html.  You will want to consult this while diagnosing bugs in your math.

2) The way UV coordinates are used to address pixels in a texture is not always the same as the way NDC values are used to address pixels on the screen.  I believe DirectX 11 finally made these two addressing modes consistent so the interval [-1, 1] addresses pixels on screen in the exact same way the interval [0, 1] addresses pixels in an identically sized texture.  I'm not sure what iteration of OpenGL fixed this inconsistency if it happened at all.  Search for "mapping texels to pixels" to figure out how to rectify the different addressing modes for whatever version of OpenGL you are using.

##### Share on other sites

then, use glOrtho() to make the projection matrix fit the screen, then all your vertices will be in pixels.

##### Share on other sites

The way UV coordinates are used to address pixels in a texture is not always the same as the way NDC values are used to address pixels on the screen.  I believe DirectX 11 finally made these two addressing modes consistent so the interval [-1, 1] addresses pixels on screen in the exact same way the interval [0, 1] addresses pixels in an identically sized texture.  I'm not sure what iteration of OpenGL fixed this inconsistency if it happened at all.

In a sensible API (DX10 / DX11 / GL), texture coordinates and screen coordinates should work the same way, except that NDC is from [-1,1] and textures from [0,1]

uv = ndc * 0.5 + 0.5;

pixel_Index = clamp( round(uv * num_Pixels - 0.5), 0, num_Pixels-1 );

On D3D9, the definition of pixel coordinates is stupidly shifted so that the centre of the top-left pixel lines up perfectly with the top-left edge of the screen. i.e. all the pixels are shifted by half a pixel in that direction, so you need:

uv = ndc * 0.5 + 0.5 + 0.5/num_Pixels;

GL's only stupidity in this regard is that z also ranges from -1 to +1, instead of from 0 to 1, which has no impact in this situation

Also, is this even a feasible scenario? I'm coding the coordinate positioning of a bunch of objects and I want to add this option so I can, for example, do something like positioning a player's menu bar at the pixel 10 of the screen, and his inventory icon at the (width - 10).
Ignoring projection matrices, the screen is addressed in NDC (normalized device coordinates), which range from -1 to 1.

i.e. a vertex at x=-1 will be on the left hand edge of the screen, and a vertex at x=1 will be on the right hand edge of the screen.

Say the screen is 1280 pixels wide -- that's pixel #0 to pixel #1279.

The left edge of pixel #0 corresponds to an NDC value of -1. The right edge of pixel #1279 corresponds to an NDC value of -1 (this is also the left edge of imaginary pixel #1280).

If you want a shape to cover the pixels from #10 to #20, first calculate the size of a pixel. NDC is 2 units across, but our "pixel" coordinates are 1280 units across. Therefore one pixel is 2/1280 NDC units wide.

The left edge is -1, and we want to the coordinates to a point 10 pixels right of that, and then another 10 pixels right.

p1 = -1 + 2/1280 * 10

p2 = -1 + 2/1280 * 20

If you use an ortho matrix, it will just be doing this translation (by -1) and scaling (by 2/1280) for you

##### Share on other sites

On D3D9, the definition of pixel coordinates is stupidly shifted so that the centre of the top-left pixel lines up perfectly with the top-left edge of the screen. i.e. all the pixels are shifted by half a pixel in that direction, so you need:

uv = ndc * 0.5 + 0.5 + 0.5/num_Pixels;

GL's only stupidity in this regard is that z also ranges from -1 to +1, instead of from 0 to 1, which has no impact in this situation

OpenGL never had this problem!?  Sigh.  I've been using the wrong API all these years...

##### Share on other sites

If you want a shape to cover the pixels from #10 to #20, first calculate the size of a pixel. NDC is 2 units across, but our "pixel" coordinates are 1280 units across. Therefore one pixel is 2/1280 NDC units wide.

The left edge is -1, and we want to the coordinates to a point 10 pixels right of that, and then another 10 pixels right.

p1 = -1 + 2/1280 * 10

p2 = -1 + 2/1280 * 20

If you use an ortho matrix, it will just be doing this translation (by -1) and scaling (by 2/1280) for you

That's what I did, it seemed way easier than dealing with matrices again (ugh!).

I have to recalculate the pixel size every time the screen size changes, but that's minor.

It took me some time and tries to get it correctly though, I even had some ifs to check the region portion of the screen before I noticed I just had to subtract the value from 1...

What my question was about is, I'd like to know how developers deal with images and different screen ratios/sizes.

For example, if they do this sort of calculation to make the image appear exactly as the original resource (same pixel W * H) or adjust it to the screen to show, for example, between space -1 to 0.5 (25% of the screen).

I think I've seen some games that when I change the resolution to something unusual the images do appear distorted as well, so I wasn't sure if showing the image's exact pixel size might cause some trouble later on.

Anyway, thank you very much for the replies, with this my UI code is nearly finished!

Edited by Danicco