I'm in the process of modifying Pacific General for this very purpose.

The process is VERY complicated with direct X in this game:

http://www.ninjaplease.com/

also see my attempts to do this with a few other 5-star directx based games in the left hand pane of my site.

--ninjaplease

ninjaplease wrote:

I'm in the process of modifying Pacific General for this very purpose.

How did you do that, exactly? It seems you modified the game codes instead of tinkering with DirectX, am I correct?

Also, in 3D games, increasing the resolution means scaling up (smoothing up) the resolution, while what you did with those 2D games is more like "zooming out" the game screen; is there any way (probably tinkering with DirectX) to scale up the resolution of 2D games while retaining the original game screen size? You know, something like "software video scaler" or such.

2D games are mostly composed of 2D images. You can't show these at higher resolution unless you'd resample them. But (true) 3D games are composed of dots in space that describe the 3d objects - higher resolution is a matter of math, how you transform the 3d coordinates to the 2d monitor coordinates and how you render the resulting objects.

gulikoza wrote:

2D games are mostly composed of 2D images. You can't show these at higher resolution unless you'd resample them.

Exactly what I mean.

Now, correct me if I'm wrong, but after seeing the screenshots, it seems to me that ninjaplease's "higher resolution modding" doesn't resample the game screen --it's more like "zooming out".

My question is: how difficult it is to mod DirectX (or creating a display utility) that can resample all DirectX games to resolution of choice? Imagine playing 2D games like Fallout in higher resolution --not larger map, but true higher resolution where the entire game screen is resampled to higher resolution.

Hardware-wise, how taxing a real-time 2D resampling is?

Just resampling won't make it look better, depending on the algorithm it might even be worse (blurry, ...). You'd have to apply some advanced image processing, like the scalers dosbox has 😀. I'd say this is pretty much impossible to do with directx, unless it's running in an emulator...

There are Direct3D wrappers, right? Presumably if it is possible to translate the Direct3D APIs into OpenGL or Glide or whatever, it ought to be possible to modify them in the process. Not that I would think it would be easy.

Jorpho wrote:

There are Direct3D wrappers, right?

There are? What I already knew is MiniGL, which is (IIRC) a wrapper to translate OpenGL into GLide.

But that's interesting; if we can wrap Direct3D --translating it into OpenGL or such, is it possible to wrap 2D DirectX graphic into Direct3D or OpenGL? You know, utilizing the horse power of the GPU to perform real-time 2D scaling.

Kreshna Aryaguna Nurzaman wrote:

Jorpho wrote:

There are Direct3D wrappers, right?

There are? What I already knew is MiniGL, which is (IIRC) a wrapper to translate OpenGL into GLide.

I guess they would be a little pointless in a way. Perhaps I only read of them being discussed on a theoretical level.

On the other hand, I think Cedega (WineX) works by translating DirectX calls into OpenGL.

Jorpho wrote:

On the other hand, I think Cedega (WineX) works by translating DirectX calls into OpenGL.

Bingo! Then I believe it is (at least theoritically) possible to treat a game's 2D screen as a big rectangular polygon, and then applying texture scaling/filtering to the 2D screen.

Now, if only such thing is possible in Windows. Translating DirectX calls to 3D API, I mean.

http://sourceforge.net/projects/dxglwrap

Can't see the point. Would be simpler to decompile a D3D game exe to find out what calls it's making to which dlls and then hack them accordingly. Also what you're proposing isn't actually raising resolution per se, it's actually keeping it the same but scaling the pixels/texel plane up, that would produce the Zoom-In effect you're looking for.

Have a look at a rather famous Emulation project for the ORIGIN Ultima VII games, "Exult" - http://exult.sourceforge.net/ - to get a working idea of what I'm explaining. Essentially the original game was made to run @ 320x200 but with Exult you can play the game up to any given res and the pixels will be scaled accordingly yet if you want you can keep the pixels at their native res and even have the viewport displayed upto 1024x768, making much more of the map visible than was possible originally.

dh4rm4 wrote:

Can't see the point. Would be simpler to decompile a D3D game exe to find out what calls it's making to which dlls and then hack them accordingly.

Well I think the point is making a (relatively) game-independent solution, instead of decompiling each and every individual game.

dh4rm4 wrote:

Also what you're proposing isn't actually raising resolution per se, it's actually keeping it the same but scaling the pixels/texel plane up,

It is actually raising the resolution --the principle is similar to a line doubler / video scaler.

Actually no. In Windows when you scale resolution up, the fixed size objects made of bitmaps shrink down. This is what you refer to as 'zooming out'. Line Doublers do not increase resolution they just copy scanlines and multiply them across blank spaces in between. http://en.wikipedia.org/wiki/Line_doubler

Video Scalers with 3:2 pulldown, such as is included in many expensive modern progressive TVs and DVD player also do not increase resolution - they interpolate fields so that one progressive field is displayed instead 2 "half frame" fields for one frame of footage.

Maybe I've misunderstood you but your references don't seem to relate to scaling a 2D playfield to a larger screen area but maintaining the same effective resolution.

Also, for 2D games my theory of hacking the DirectX DLLs could apply for those games that use them in the same way. This is essentially what wrappers do - they emulate common functions or "calls" for one layer and reroute them to system specific functions for the target OS/layer.

dh4rm4 wrote:

Actually no. In Windows when you scale resolution up, the fixed size objects made of bitmaps shrink down. This is what you refer to as 'zooming out'.

Yes, hence the need of rescaling to keep the size fixed.

dh4rm4 wrote:

Line Doublers do not increase resolution they just copy scanlines and multiply them across blank spaces in between. http://en.wikipedia.org/wiki/Line_doubler

Video Scalers with 3:2 pulldown, such as is included in many expensive modern progressive TVs and DVD player also do not increase resolution - they interpolate fields so that one progressive field is displayed instead 2 "half frame" fields for one frame of footage.

I know, and a video scaler actually does more jobs than increasing the resolution, but I'm talking about the resolution scaling part. Many today's LCD screens include built-in scaler to scale the image to various screen resolutions.

dh4rm4 wrote:

Maybe I've misunderstood you but your references don't seem to relate to scaling a 2D playfield to a larger screen area but maintaining the same effective resolution.

Yup.

dh4rm4 wrote:

Also, for 2D games my theory of hacking the DirectX DLLs could apply for those games that use them in the same way. This is essentially what wrappers do - they emulate common functions or "calls" for one layer and reroute them to system specific functions for the target OS/layer.

I see, although I'm actually thinking about a 'dedicated' wrapper instead of DLL hacks.

So why don't you take the source from the DxtoGL wrapper that Dosfreak posted and apply your theory?

Oh and line doublers aren't scalers. Line doublers don't increase resolution they pad out interlace errors.

What does resolution mean?

🤣, seriously? 😜

dh4rm4 wrote:

So why don't you take the source from the DxtoGL wrapper that Dosfreak posted and apply your theory?

Because I ain't no programmer --I'm merely discussing the possible mechanisms of scaling up the resolutoin, which happens to be the purpose of this thread.

There's no reason you couldn't learn...