How to Upgrade Game Graphics for Remasters: From Built-in to URP/HDRP

In decade-old game remaster projects, textures at 512×512, diffuse maps without metallic/roughness, meshes with 15,000 polygons — all on the Built-in Render Pipeline. Our task: migrate to URP or HDRP, raise quality to modern PBR standards without breaking gameplay and keeping system requirements reasonable. This isn't "repainting textures" — it's systematic work on technical debt in art production.

What Are the Problems of Legacy Graphics in Remasters?

The Built-in → URP transition isn't automatic. Unity's Edit > Rendering > Render Pipeline Converter converts materials from Standard to Lit (URP), but that's baseline conversion. Custom shaders in GLSL or ShaderLab without Surface Shader API need rewriting from scratch into HLSL or porting to ShaderGraph. The major loss: Unity's Standard shader in Built-in supports Specular workflow (albedo + specular + gloss), while URP Lit only supports Metallic workflow (albedo + metallic + smoothness). The specular → metallic conversion is non-trivial: old materials often had physically incorrect specular values that looked "nice" in the old renderer but wrong in PBR. The conversion must account for the dielectric F0 of 0.04; legacy specular values often deviated from physically correct PBR.

Specific situation: Stone walls had specular colour (0.2, 0.2, 0.2) with glossiness 0.3 — a soft sheen. After conversion, metallic = 0.0, smoothness = 0.3 — walls appear more matte due to the physical F0 calculation for dielectrics. Manual tweaking of smoothness and adding Detail Normal Map is needed to compensate.

How to Upscale Textures Without Quality Loss?

512×512 textures in a remaster for modern 1440p/4K monitors look poor. Options:

• AI upscaling via Gigapixel AI or Stable Diffusion with img2img (ControlNet tile). Gigapixel gives x4 without artifacts on tileable textures — 512 → 2048 in minutes. But for organics (character skin, plants) the result is unstable — requires manual touch-up.
• Full PBR rework: an artist creates a new texture set of 4 maps (Albedo, Normal, Metallic/Roughness, AO) in Substance 3D Painter, using the old texture as colour reference. This is correct for key assets but unrealistic for an entire game.
• Baking normal maps from old geometry. If low-poly and high-poly versions exist — bake in Marmoset Toolbag or xNormal with correct cage offset. Old normal maps often have UV-seam spreading issues — visible seams on edges. Proper UV mapping and cage offset are critical for normal map baking. We apply anisotropic filtering and correct MIP map generation to avoid aliasing.

AI upscaling is 5x faster than manual rework for background textures. For a project with 1000 textures, this translates to savings of over $40,000 compared to full manual rework. Retopology can reduce polygon count by 60% while maintaining visual quality.

When to Use Retopology vs LOD?

If the game stays on the same platform, aggressive retopology isn't needed. But if the original was made for 7th-gen consoles (PS3/Xbox 360), meshes often have non-functional topology: triangles without edge flow. When adding new animations or blend shapes — facial animation is impossible. For remasters with updated cutscenes: retopology of key characters, adding blendshape rig, setting up LOD Group with LOD0/LOD1/LOD2.

How to Rewrite Shaders for the New Renderer?

Old Particle System effects on Built-in Material need rewriting into VFX Graph (URP/HDRP). VFX Graph runs on GPU, supports lit particles with normal maps and PBR lighting — a qualitative leap for fire, smoke, magic. ShaderGraph for reworking custom shaders: old 200-line HLSL shader (Vertex-Fragment) → visual node graph. Debugging and iterating is easier, results compile for all platforms. More details at Render Pipeline Converter.

Step-by-Step Refactoring Process

1. Audit and planning: assess asset volume, technical debt, target platforms.
2. Material conversion: auto-convert via Render Pipeline Converter, manually tweak non-physical values.
3. Texture rework: AI upscaling for background textures, manual PBR rework for key assets.
4. Retopology and LOD setup: optimize key characters and objects for performance.
5. Shader rewriting: port custom shaders to ShaderGraph and effects to VFX Graph.
6. Profiling and optimization: monitor FPS, draw calls, memory usage.
7. Release and post-release support, as with any Unity remaster.

What's Included in the Work

Our graphics refactoring service covers URP/HDRP conversion, PBR texture upscaling, shader rewriting with HLSL to ShaderGraph, mesh optimization through retopology, and VFX Graph implementation. Specifically:

• Graphics pipeline audit: determine asset volume, technical debt, target platforms.
• Material conversion: automatic + manual tweaking of non-physical values.
• Texture rework: AI upscaling, manual touch-up, normal map baking.
• Retopology and LOD setup for key characters and objects.
• Rewriting custom shaders and effects under ShaderGraph/VFX Graph.
• Profiling and optimization: check FPS, draw calls, memory.
• Support until release, 3 months post-release maintenance.

Timelines

Typical project costs range from $10,000 to $100,000 depending on asset count and complexity. For example, AI upscaling can reduce total project cost from $50,000 to $10,000.

We'll assess your project — contact us for a free consultation. Our team has 7+ years of experience in remasters and delivered 50+ graphics refactoring projects. We guarantee compatibility with target platforms and quality expectations. Get a consultation now.

Manual pre-release preparation as a source of delays

We automate the entire pre-release pipeline for mobile and XR games. A studio is about to release a game — a week before the date, the manager remembers they need to build an AAB, sign it, and upload to Google Play. The build engineer manually starts the build, waits an hour, forgets to enable IL2CPP, the build crashes on Android 12. Rebuilding takes another hour. Simultaneously, the icon needs to be redesigned to meet new Google requirements. As a result, the release is delayed by three days. Experience shows: manual pre-release preparation is the primary source of delays and bugs that do not manifest on the developer's machine.

How to set up CI/CD for mobile game builds?

Pipeline tools

GameCI — open-source Docker images for Unity builds, running on GitHub Actions, GitLab CI, or any other CI provider. Key components: unity-builder (builds for the target platform), unity-test-runner (runs Unity Test Framework before build), unity-return-license (returns the license — critical for Pro). Unity Cloud Build is simpler but less flexible and expensive for frequent builds. Fastlane is the standard for final steps: signing, uploading to stores, metadata.

Typical pipeline

jobs:
  test:
    name: Run Unity Tests
    uses: game-ci/unity-test-runner@v4
    with:
      unityVersion: 2022.3.20f1
      testMode: playmode

  build-android:
    name: Build Android
    needs: test
    uses: game-ci/unity-builder@v4
    with:
      targetPlatform: Android
      androidKeystoreBase64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
      androidKeystorePass: ${{ secrets.KEYSTORE_PASSWORD }}
      androidKeyaliasPass: ${{ secrets.KEY_PASSWORD }}

  upload-to-play:
    name: Upload to Google Play (Internal Track)
    needs: build-android
    uses: r0adkll/upload-google-play@v1
    with:
      serviceAccountJsonPlainText: ${{ secrets.SERVICE_ACCOUNT_JSON }}
      packageName: com.yourcompany.yourgame
      releaseFiles: build/Android/*.aab
      track: internal

Secrets, not variables — all keys in CI secrets. AAB instead of APK has been mandatory for several years. Tracks: internal → closed → open → production. Promotion — manual or Fastlane supply promote.

iOS specifics

Unity builds an Xcode project, then xcodebuild. Need Distribution Certificate and Provisioning Profile (App Store). Fastlane Match solves the problem of certificate synchronization within the team:

lane :build_ios do
  match(type: “appstore”, readonly: true)
  build_app(workspace: “Unity-iPhone.xcworkspace”,
            scheme: “Unity-iPhone”,
            export_method: “app-store”)
  upload_to_testflight
end

App Store Connect API Key replaces login/password, does not break with 2FA.

Step-by-step pipeline setup

1. Audit Unity PlayerSettings (Graphics APIs, Scripting Backend, stripping).
2. Create CI configuration with GameCI — define test, build, and deploy jobs.
3. Integrate Fastlane for code signing and store uploads.
4. Store all secrets (keystore, certificates, API keys) in encrypted CI variables.
5. Run a test release on internal track, verify end‑to‑end.

Each step includes validation: build must pass on a clean runner, not just a local machine.

Why does App Store reject about a third of first submissions?

Apple rejects 30–40% of first submissions from new studios. Common reasons:

Practice: before submission, go through the App Store Review Guidelines from start to finish — 2–3 hours, saving 2–3 weeks of resubmission loops.

Google Play is more lenient: typical reasons — outdated targetSdkVersion, excessive permissions, incorrect Data Safety Form.

Deliverables of pre-release preparation

We deliver the following for your game release:

• CI/CD pipeline configured (GameCI + Fastlane, Unity Cloud Build — turnkey)
• Metadata and marketing assets (screenshots, icons, feature graphics)
• Store submission guidance with documentation of all accesses and credentials
• 72‑hour post‑release monitoring (Crashlytics, ANR rate, user reviews)
• Pipeline documentation and team training session (hands‑on)
• Age rating configuration (IARC, ESRB, PEGI, CERO) and localization of store metadata

Pipeline automation replaces the manual work of an entire department. For example, setting up Continuous Integration via GameCI and Fastlane reduces pre‑release preparation time threefold — from 8 working hours to 2.5.

Our pre-release workflow: from audit to store submission

Impact of pipeline automation on timelines and budget

Manual game release incurs significant engineering and testing costs. CI/CD automation pays for itself within the first two months, reducing release costs by 40–60%.

Result: we reduce the commit‑to‑publish cycle by 6–8 times. For projects with frequent hotfixes, this is the difference between a week‑long user wait and a one‑day fix. We guarantee the pipeline works reliably after setup. Our engineers hold Unity Certified Professional credentials.

Typical savings: $2,500–$5,000 per month on engineering time eliminated by automation — $30,000–$60,000 annually on a mid‑size project.

Post‑release: monitoring and updates

Crash rate < 1% (Firebase Crashlytics), ANR rate < 0.47% (Play Console) — otherwise visibility restrictions. Phased rollout is mandatory: first 10%, then 50%, then 100% of users.

Our track record: 30+ mobile game releases, 5+ years on the market. CI/CD automation pays for itself within the first two months, reducing release costs by 40–60%.

Timeline

Setup takes from 2 days (simple mobile game with existing Unity project) to 2 weeks (complex multi‑platform project with custom CI runners). We calculate exact hours during a free pipeline audit.

Contact our engineers for a free pipeline audit and a timeline estimate. Submit a request — we will analyze your pipeline and offer a solution within 2 days. Get a consultation from an engineer who has shipped 30+ titles.