#presentationmodel | Explore Tumblr posts and blogs

skyboxeye · 5 months ago

Text

Creating a runtime texture mod for Earthworm Jim 3D

In this post I'll share my struggles and successes with Special K and other wrapper tools in my attempts to prevent Jim's shadow from rendering. I'm running the GOG version of the game on Windows 10 with an Nvidia GeForce GTX 1070.

Running EWJ 3D with Special K

Special K is the self-appointed "Swiss Army Knife" of PC gaming in that it does "a bit of everything". In our case, this means texture modding and windowing fixes for EWJ 3D. Special K also offers upconversion of EWJ's DirectX 7 rendering calls via a DgVoodoo plugin.

Local versus global installation

We'll be using version 25.1.3.1, since (at the time of writing) subsequent releases contain input bugs impacting EWJ 3D.

Although the docs promote purely "local" Special K installations as an alternative to "global" injection performed through the Special K frontend UI, I couldn't get this working for EWJ.

I did however manage it by "converting" (a misnomer since installations created this way are actually partially global, and partially local) a global install to a local one - achieveable by holding Ctrl and Shift while click the Play button inside Special K's frontend.

This approach allows you to maintain per-game DLL and CONF files; you may prefer it if you're running other games with Special K. However I'll use a global installation throughout this guide, for simplicity.

Issues when customizing EWJ 3D's resolution via its menus

The game boots to an options menu which allows you to, among other things, change your display options: 1.) Color depth and 2.) Resolution. These settings will not persist unless we run the game in compatibility mode for Windows XP*, or thereabouts.

Oddly this menu wants to display at 640x480 no matter what resolution is selected. That is, EWJ only transitions to that resolution once it properly starts. This is typically harmless but seems to break Special K's injection of the game's process, resulting in the loss of Special K's on-screen display and possibly other things.

*This has the downside of requiring EWJ to be run as an administrator - which doesn't cooperate well with Special K, unless of course Special K frontend is also run as administrator (I don't recommend this). This is a possible motivation for running a "converted" local install, as that approach (along with purely local installs) does not require the Special K frontend.

Solution: Forcing EWJ 3D's resolution via DgVoodoo

To avoid this confounding resolution change, we can force EWJ to always run at our chosen resolution (example: 1920x1080) via DgVoodoo. First, set up DgVoodoo as a Special K plugin. Then, modify your CONF file in a text editor or via the control panel:

[DirectX] Resolution = h:1920, v:1080

This means we don't need to rely on Windows XP compability mode to both run the game in our desired resolution and reliably inject Special K. That's good news, as I (anecdotally) found EWJ crashes more often when in compability mode.

Other mandatory DgVoodoo configurations

Be sure to set the following options as well:

[GeneralExt] PresentationModel = flip_discard FullscreenAttributes = Fake

Dumping textures

Launch the game via Special K's frontend. Don't forget to insert an EWJ 3D disc before starting the game!

Thanks to our DgVoodoo setup, you should be able to edit the resolution and color depth in the options menu without losing Special K's injection. Once the game starts, open the overlay and click into Render Mod Tools.

You'll notice that for some reason, no assets are listed under Used Textures. This can apparently result from intrusive overlays, but I have a feeling that something else is going on. Highlight Selected Texture doesn't work either - presumably for the same reason.

Anyway, you'll find that you're still able to switch over to All Textures, and click Refresh, to see what the game has loaded. Find the texture you're looking to modify, make note of its format details, and click Dump Texture to Disk.

Editing textures

If you've been following this guide you'll find the DDS files inside a directory like <Special K path>\Profiles\Earthworm Jim 3D\SK_Res\dump\textures\EarthwormJim3D.exe. I tried two editing tools: Intel Texture Works (ITW) and Paint.NET. ITW doesn't Paint.NET offers support for a wide variety of formats but sadly doesn't seem to understand mipmaps.

There is also Nvidia Texture Tools Exporter (NTTE) for saving/compressing, but not editing.

If no single tool offers all of the features you need, you can combine them - for example we can edit a BC2 texture in ITW, export it to BC3, and then re-encode it as a BC2 using NTTE.

Injecting textures

Move your edited textures into <Special K path>\Profiles\Earthworm Jim 3D\SK_Res\inject\textures\EarthwormJim3D.exe and click Reload All Injected Textures. Or, restart the game.

Appendix 1: Other texture injectors?

See if we can use another texture modding tool, such as uMod or TexMod, alongside standalone DgVoodoo* upconversion of DirectX 7 -> DirectX 11 (I couldn't find any that did DirectX 7 -> DirectX 9). Other API wrappers, namely DXWrapper and WineD3D, did not perform well:

DXWrapper boots but there are severe graphical issues. I tried customizing every available option for D7->D9 in dxwrapper.ini. All did nothing or crashed the game.

WineD3D crashed unless I combined with DxWnd. After which it was very slow, and did not work besides.

Appendix 2: Modifying game data?

Instead of injecting altered textures at runtime, we can try to modify the textures.dat archive which EWJ loads from.

Appendix 3: Other Stuff

We might also need DxWnd to improve windowing - we'll see. Might be able to set hotkeys via uMod templates s.t. we don't need to visit its window at all.

There is a successor for uMod build for Guild Wars call gMod. Presumably it would have the same problem of requiring D9.

#earthworm jim #ewj3d #special k #modding #earthworm jim 3d #directx7

7 notes · View notes

qwertsypage · 8 years ago

Text

MVP pattern in iOS

The development of the mobile app has changed and evolved a lot in recent years. Thanks to the interest of the developers and the growth of the mobile platforms, every time it is getting more and more common that the development team pays more attention to create reusable components and use best practices in software development like those which already exist in desktop apps, web apps and backend apps. This interest has brought that proliferate, more diverse patterns, able to get a more testable, modularized and reusable code, which caused improvement of the app performance, number of error reduction and quality software development. And this article is about MVP pattern for iOS development.

Here at Apiumhub, we have always focused on creating quality and working software, using in an intensive way the patterns and software development techniques which worked best for each platform, adapting to the clients’ needs.

Let´s focus on explaining the MVP pattern which we have already used on other platforms and that it´s showing that it adapts relatively good to mobile technologies. Just like Android, which has become a “standard by default”.

We will explain to you how we have adapted the MVP pattern to the iOS app development, our proposition and the reasons why we believe that it is a valid alternative to other patterns and how we have plugged our own different development pieces with such iOS pattern.

The MVP pattern was invented in the 90s as a common C++ initiative from Apple, IBM, and HP as an alternative to the MVC pattern. It is an acronym from Model, View, Presenter, which are the vital components of this pattern. There are different implementations of this pattern and some important variances like Supervising Controller or Passive View.

The main difference between the MVP pattern and other UI ones is the full independence between view and model, in other words, the view doesn’t know that a model exists and the other way around.

In our case, at Apiumhub, we have adopted a variance of this pattern, implemented in a framework named Claymore. (here is an example in C#)

Pure MVP pattern

Just like in all the definitions of the MVP pattern, in our case, it has 3 separated and clearly differentiated parts but with some peculiarities:

The view

The view is a layout which task is to render the UI and to react to the user events. In the case of iOS, the View will consist of a Protocol that exposes the methods of the user’s events and a ViewController that is responsible for materializing and rendering the UI components and capturing the events that pass to the next component of the pattern, the presenter.

The Presenter

It is responsible for making a connector between the events emitted by the view and connecting them with the model, specifically with the services of the model. Here in Apiumhub, we understand the presenter as a piece of software that connects View with Model, but that lacks logic, the whole state of the data of the view and its behavior is handled in the service and through the presenter, again that returns the transformed data or responds to an event as appropriate. In iOS, usually, the presenter is a class that receives in the init method the view and the service and connects the needed methods. The presenter is normally being used inside an extension class from the main ViewController and it happens when the connection settings are done.

The Model

It is the system that contains the logic of the business and it is made up by different software pieces depending on the complexity of the app. In a “Domain oriented” system we will have to structure the layers of the tactic DDD, with some variations coming from the particularity of every front-end app. In the mobile apps, the main parts of the model that we perceive here in Apiumhub are:

1. The services: they are responsible for executing the logic of the business (if there is one) within the domain objects of the App and if it´s necessary to call the repository (o gateway) to have access to the external services or local database. In the iOS case, the service will be made out of a Class and a Protocol. The Class will contain the implementation of the methods exposed by the protocol.

2.The entities: they are the domain objects. They contain logic that reflects the application status. Normally, these objects are kind of DTOs because the logic of the transactions would be in the server, however, there are some exceptions. These objects should never arrive in the view, however, sometimes exceptions can be done when we are talking about simple data transfer objects without logic. Normally, entities are represented as a Class.

3.The repository: They call the external services (APIs or other services) or to local databases if the app has them. Just like the services will be made out of a Class and a Protocol.

4. DTO o PresentationModel: These are the objects which are given back from the service and represent the state of a view after the execution or any state change from the app. Usually, they are built from one or more entities. In this case, we will use Structs to carry out the representation of this type of objects, since when representing states of a view, there should be no hierarchy between them.

The main feature of this “Pure” MVP pattern is that the Presenter has no logic and acts like a common plug connector. This allows the presenter to act as an isolated component and it can be re-used again in more than part of the app.

Some of the advantages of the presenter are:

It is a component that expresses directly its intention and responsibility without adding logic that could make us think that does more than one task at the same time.

The presenter centralizes the flow of the events, that help us to:

Debug, in the opposite it gets more complicated, especially if you work with binding systems.

It is easier to trace the origin of the events, the relations between an event and the service responsible for managing it are known at a glance.

Avoiding “hidden” chain of events because they lack logic and handle the state of the data in the service

The same component can be reused in different context and services.

You don’t strictly need a test, especially in statically typed environments, because being essentially declarative makes it difficult to introduce errors by logic or change of state of the data

Some of the global features that this pattern brings to the table are:

The state of the data its always managed from a model level, more specifically in the service layer, when not managed in the server.

Chain of events is avoided, usually an iteration from a user it´s considered an event

Since we avoid event chains, the number of calls to the server are minimized, because the logic and the state of the data is solved at the level service.

Reduce the coupling and increase the cohesion because each software piece has clear responsibilities and strength to distribute the logic between the model and the View.

Improves the use of the unit test in order to verify the correct functionality of each software pieces.

To sum up, adapting this MVP pattern in Apiumhub, allowed us to be able to do it extensible to a more variety of platforms, create a more modulated system with the clear responsibility of the components, which allowed the coverage of the test to be bigger and reusable.

Thanks to all these features, here at Apiumhub, we believe that it adapts and meets our needs, that doesn’t mean that we keep the pattern in continuous evolution and improve it with new features that are introduced in each platform. This allows us to compare this pattern with others that are already being used in the iOS architectures such as Viper, MVVM, Clean Architecture and more that we will try to evaluate in the next article.

If you are interested in mobile development, I highly recommend you to subscribe to our monthly newsletter by clicking here.

If you found this article interesting, you might like…

iOS Objective-C app: sucessful case study

Mobile app development trends of the year

Banco Falabella wearable case study

Mobile development projects

Viper architecture advantages for iOS apps

The post MVP pattern in iOS appeared first on Apiumhub.

MVP pattern in iOS published first on http://ift.tt/2w7iA1y

0 notes