Using GPU Commands and GL Together

Introduction

This document is a collection of notes regarding the methods of generating commands that can be directly interpreted by the GPU and the use of those commands together with DMPGL.

If you need more information about the direct generation of commands, see the following documentation:

• DMPGL2.0 System API Specifications, Chapter 5 (DMPGL20_system_API_specification.pdf).

Maintaining Consistency of Internal States When DMPGL API Mixed with Directly Generated Commands

Assumptions:

• The internal states are mirrors of the GPU register settings, maintained by the DMPGL driver as local data (as a collection of structures). Providing that you are only using the DMPGL API, the internal states and the states of the GPU registers are essentially the same.
• The internal states are not changed by directly generated commands (they cannot be changed this way).

Command Issuance by the DMPGL Driver

• Command Issuance by Validate
• Command issued when glDrawArrays, glDrawElements or nngxValidateState is called.
• The DMPGL divides the internal states into a number of categories, and flags are used to manage whether each has been updated (See Specification: State Flags).
• When the update flag is standing for a given category, an overwrite command is issued to update those GPU registers.
• Almost all commands are issued this way.

• Command Issuance by Call to DMPGL API Itself
• Inside the DMPGL API , there are functions for which commands are issued immediately upon calling. (See Table 5-3 in the System API Specifications) These belong to the NN_GX_STATE_OTHERS state. This is a special state (explained below).

The Timing of Internal State Updating

Basically speaking, when a DMPGL API function is called that requires state updating, if it is possible to compare and confirm the updating of the current internal state, then the actual process of updating the internal state is carried out and the state update flag is raised.

→ In other words, when commands are directly generated without using the DMPGL API, they must not issue an update the internal state.

For the DMPGL API functions belonging to NN_GX_STATE_OTHERS, if there is an update to the internal state a command is issued and afterward the internal state is updated. (The exception is glViewport, where the command is issued without making the comparison with the internal state.)

For the API functions listed below, the update flag stands for the dependent state (NN_GX_STATE_FACES).

• glEnable, glDisable
• param is GL_COLOR_LOGIC, GL_BLEND、GL_DEPTH_TEST, GL_EARLY_DEPTH_TEST_DMP, GL_STENCIL_TEST
• glDepthFunc
• glEarlyDepthFuncDMP
• glColorMask
• glDepthMask
• glStencilMask

Moving Between DMPGL API Calls and Directly Generated Commands

How to Safely Move From Calls to DMPGL API Functions to Direct Generation of Commands

• Validate all states.
• Validation is done by calling nngxValidateState(NN_GX_STATE_ALL, *) or executed internally by glDrawArrays, glDrawElements.
• You must perform this validation if, for simplicity, you want to directly generate commands with the assumption that the settings as configured by the DMPGL API are applied to the GPU.
• Regardless of whether you are moving from calls to the DMPGL API, you can prevent the occurrence of unforeseen problems by first validating and making sure the state flags are all down before you generate direct commands.

How to Safely Move From Direct Generation of Commands to Calls to DMPGL API Functions

Due to the direct generation of commands, the register settings in the GPU and the internal states maintained in the DMPG driver layer may not be exactly the same.

In order for the GPU to correctly process the results of calls to the DMPGL API, the two must be made to match.

Broadly speaking, there are two ways of doing this before moving to the call of DMPGL API functions.

1. Issue commands to force the updating of all states. In other words, specify nngxUpdateState(NN_GX_STATE_ALL) and validate. This is the surest way, but you also end up issuing unnecessary commands (for registers that have already been overwritten).
2. If the directly generated commands have been already clearly divided out, forcedly raise the update flag for just the states that pertain to those commands, and then validate. This method minimizes the issuance of commands, but the application needs to manage which states pertain to which directly generated commands and whether there are any dependent states.

You can modify method (2) to suppress the redundant issuance of commands. By defining nngxSetCommandGenerationMode(NN_GX_CMDGEN_MODE_UNCONDITIONAL), commands will be issued regardless of the result of the comparison with the internal state. However, the influence of this mode is limited to the following settings. (For details, see section 4.10 in the specifications.)

• Uniform settings for the reserved fragment shader.
• Integer uniform settings for the vertex shader.
• LUT data settings
• DMPGL API belonging to the NN_GX_STATE_OTHERS state.

To update the state flags relating to these settings, it is no longer necessary to use nngxUpdateState.

Notes

Other notes regarding the NN_GX_STATE_OTHERS state.

When Creating Command Cache

• For API functions that result in command issuance when they themselves are called, there is a problem if the generated command is simply saved for use.
• The API functions that were referred to in The Timing of Internal State Updating earlier in this document have NN_GX_STATE_FBACCESS raised, so they must be validated by nngxValidateState(*) and saved to cache including the command being issued.
• You can made do by passing NN_GX_STATE_ALL as the argument to nngxValidateState, or if there are no other targets to validate you can just pass NN_GX_STATE_FBACCESS.

About Command Output Mode

By specifying NN_GX_CMDGEN_MODE_UNCONDITIONAL with nngxSetCommandGenerationMode before calling the pertinent API function, the command will be issued regardless of the result of the comparison with the internal state.

The Behavior of nngxUseSavedCmdlist and nngxUpdateState(NN_GX_STATE_OTHERS)

If NN_GX_STATE_OTHERS has been specified for the statemask argument, the commands will be issued all at once at validation time for all API functions that result in command issuance when they themselves are called. In addition, the update bit will raise automatically for the dependent state NN_GX_STATE_FBACCESS.

CONFIDENTIAL