US20170091058A1 - Method and apparatus for testing compatibility of 3D engine - Google Patents
Method and apparatus for testing compatibility of 3D engine Download PDFInfo
- Publication number
- US20170091058A1 US20170091058A1 US15/117,029 US201515117029A US2017091058A1 US 20170091058 A1 US20170091058 A1 US 20170091058A1 US 201515117029 A US201515117029 A US 201515117029A US 2017091058 A1 US2017091058 A1 US 2017091058A1
- Authority
- US
- United States
- Prior art keywords
- engine
- capability
- graphics card
- simulated
- api
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/22—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing
- G06F11/2205—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing using arrangements specific to the hardware being tested
- G06F11/2236—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing using arrangements specific to the hardware being tested to test CPU or processors
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/22—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing
- G06F11/26—Functional testing
- G06F11/261—Functional testing by simulating additional hardware, e.g. fault simulation
Definitions
- the present disclosure relates to the field of computers, and in particular, to a method and an apparatus for testing the compatibility of a 3D engine.
- step S 102 to step S 114 shown in FIG. 1 generally, different graphics cards are selected to perform hardware testing, to determine whether a graphics card to be tested is compatible with a 3D engine.
- different models of graphics cards need to be searched for, and a large number of hardware testing environments need to be built for testing; and then information about a tested problem is fed back for development and repair.
- such a solution of testing the compatibility of a 3D engine has many defects:
- a testing period is relatively long.
- a client with memory of several GBs needs a relatively long time when copying, inserting and removing a graphics card, reinstalling a driver, and configuring a network environment, which is also inappropriate to a quick procedure.
- Embodiments of the present invention provide a method and an apparatus for testing the compatibility of a 3D engine, so as to at least solve the technical problem that a hardware testing environment needs to be repeatedly built to test the compatibility of a 3D engine with different graphics cards.
- a method for testing the compatibility of a 3D engine including: acquiring a hardware capability parameter of a graphics card to be simulated, the hardware capability parameter recording a capability supported by the graphics card; running a predetermined 3D engine according to the hardware capability parameter; and determining, according to a result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated.
- the running a predetermined 3D engine according to the hardware capability parameter includes: determining whether a capability implemented by an application programming interface (API) that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter; and determining, if the capability implemented by the API is the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is normal; or determining, if the capability implemented by the API is not the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is error.
- API application programming interface
- the determining, according to a result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated includes: determining, if the result of running the 3D engine is normal, that the 3D engine is compatible with the graphics card to be simulated; or determining, if the result of running the 3D engine is error, that the 3D engine is incompatible with the graphics card to be simulated.
- the determining whether a capability implemented by an API that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter includes: returning, by using a preset API, when the 3D engine is run, if it is determined that the API needs to be invoked currently, the capability implemented by the invoked API; and determining whether the returned capability is the capability that is supported by the graphics card and recorded by the hardware capability parameter.
- the method further includes: outputting information for identifying the API and information about the capability if the result of running the 3D engine is error.
- the method further includes: establishing a graphics card information database, where the graphics card information database records models and hardware capability parameters of multiple graphics cards including the graphics card to be simulated, where the acquiring a hardware capability parameter of a graphics card to be simulated includes: acquiring the hardware capability parameter of the graphics card to be simulated from the graphics card information database.
- an apparatus for testing the compatibility of a 3D engine including: an acquiring unit, configured to acquire a hardware capability parameter of a graphics card to be simulated, the hardware capability parameter recording a capability supported by the graphics card; a running unit, configured to run a predetermined 3D engine according to the hardware capability parameter; and a determining unit, configured to determine, according to a result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated.
- the finning unit includes: a first determining module, configured to determine whether a capability implemented by an API that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter; and determine, if the capability implemented by the API is the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is normal; or determine, if the capability implemented by the API is not the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is error.
- a first determining module configured to determine whether a capability implemented by an API that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter; and determine, if the capability implemented by the API is the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is normal; or determine, if the capability implemented by the API is not the capability that is supported by the graphics card and recorded by the hardware capability parameter
- the determining unit includes: a second determining module, configured to determine whether the result of running the 3D engine is normal; and determine, if the result of running the 3D engine is normal, that the 3D engine is compatible with the graphics card to be simulated; or determine, if the result of running the 3D engine is error, that the 3D engine is incompatible with the graphics card to be simulated.
- the first determining module includes: a returning submodule, configured to return, by using a preset API, when the 3D engine is run, if it is determined that the API needs to be invoked currently, the capability implemented by the invoked API; and a first determining submodule, configured to determine whether the returned capability is the capability that is supported by the graphics card and recorded by the hardware capability parameter.
- the apparatus further includes: an output unit, configured to: after it is determined, according to the result of naming the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated, output information for identifying the API and information about the capability if the result of running the 3D engine is error.
- an output unit configured to: after it is determined, according to the result of naming the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated, output information for identifying the API and information about the capability if the result of running the 3D engine is error.
- the apparatus further includes: an establishing unit, configured to establish a graphics card information database before the hardware capability parameter of the graphics card to be simulated is acquired, where the graphics card information database records models and hardware capability parameters of multiple graphics cards including the graphics card to be simulated, where the acquiring unit includes: an acquiring module, configured to acquire the hardware capability parameter of the graphics card to be simulated from the graphics card information database.
- a virtual graphics card is simulated according to hardware capability parameters of different graphics cards, and a predetermined 3D engine is run on the virtual graphics card, so that the objective of testing the compatibility of 3D engines of different graphics cards is achieved, testing the compatibility by searching for a large amount of hardware and building a large number of hardware testing environments as in the prior art is avoided, and the technical problem that a hardware testing environment needs to be repeatedly built to test the compatibility of a 3D engine with different graphics cards is solved, thereby achieving technical effects of testing the compatibility of the 3D engine with different graphics cards in a hardware testing environment built once, and shortening a testing period of the compatibility.
- FIG. 1 is a flowchart of a method for testing the compatibility of a 3D engine in the prior art
- FIG. 2 is a flowchart of an optional method for testing the compatibility of a 3D engine according to an embodiment of the present invention
- FIG. 3 is a flowchart of another optional method for testing the compatibility of a 3D engine according to an embodiment of the present invention
- FIG. 4 is a flowchart of still another optional method for testing the compatibility of a 3D engine according to an embodiment of the present invention
- FIG. 5 is a flowchart of yet another optional method for testing the compatibility of a 3D engine according to an embodiment of the present invention
- FIG. 6 is a schematic diagram of an optional output result of testing the compatibility of a 3D engine according to an embodiment of the present invention.
- FIG. 7 is a schematic diagram of a graphics card information database established in an optional test of the compatibility of a 3D engine according to an embodiment of the present invention.
- FIG. 8 is a flowchart of an optional method for testing the compatibility of a 3D engine according to an embodiment of the present invention.
- FIG. 9 is a schematic diagram of an optional apparatus for testing the compatibility of a 3D engine according to an embodiment of the present invention.
- FIG. 10 is a schematic diagram of another optional apparatus for testing the compatibility of a 3D engine according to an embodiment of the present invention.
- FIG. 11 is a schematic diagram of still another optional apparatus for testing the compatibility of a 3D engine according to an embodiment of the present invention.
- a method for testing the compatibility of a 3D engine is provided.
- a 3D engine functions as a bottom-layer tool to support development of higher-layer graphics software, and 3D engines are classified into real-time 3D engines and off-line 3D engines according to whether a result can be computed in real time by a mainstream computer.
- Real-time 3D pictures on a personal computer (PC) and a game machine are generated through computation by a 3D engine, and 3D pictures applied to a movie are realized by using an off-line 3D engine, so as to achieve a realistic effect.
- the 3D engine includes, but not limited to, at least one of the following functions: data management, a renderer, and interaction.
- a game that is offered as a real-time game may use a rasterized rendering algorithm, and for such a design, parameters related to geometry-level data include, but not limited to, refractive index, change rate in texture coordinate space, and change rate in tangent space.
- parameters related to geometry-level data include, but not limited to, refractive index, change rate in texture coordinate space, and change rate in tangent space.
- the method for testing the compatibility of a 3D engine in this embodiment includes:
- the hardware capability parameter records a capability supported by the graphics card, where the capability supported by the graphics card may include, but not limited to, a cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and a projected density profile (D3DTEXTURECAPS_PROJECTED) capability.
- a cube texture D3DTEXTURECAPS_CUBEMAP
- a projected density profile D3DTEXTURECAPS_PROJECTED
- the hardware capability parameter of the graphics card to be simulated may be, but not limited to, stored in the form of a Caps database.
- the Caps database of graphics cards includes, but not limited to, models of the graphics cards, attributes of the graphics cards, values of the attributes of the graphics cards, and whether the graphics cards support a certain capability, where attributes of a graphics card in this embodiment includes, but not limited to, at least one of the following: a core frequency, a texture fill rate, a pixel fill rate, a shader, a video memory frequency, and a video memory width.
- attributes of a graphics card whose model is ATI Radeon HD 3800 Series in the Caps database of graphics cards include: a maximum texture width (MaxTextureWidth) being 8192, and a maximum texture height (MaxTextureHeight) being 8192.
- the graphics card of this model can support the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and can also support the projected density profile (D3DTEXTURECAPS_PROJECTED) capability, but the graphics card of this model does not support an ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability.
- D3DTEXTURECAPS_CUBEMAP cube texture
- D3DTEXTURECAPS_PROJECTED projected density profile
- the graphics card of this model does not support an ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability.
- step S 302 to step S 308 shown in FIG. 3 using the graphics card A to be simulated as an example, hardware capability parameters of the graphics card A to be simulated, for example, a core frequency of f, a video memory width of B, supporting a capability X, and not supporting a capability Y, are acquired, and then testing is performed.
- hardware capability parameters of the graphics card A to be simulated for example, a core frequency of f, a video memory width of B, supporting a capability X, and not supporting a capability Y, are acquired, and then testing is performed.
- the 3D engine implements the required capability by invoking an API.
- the 3D engine invokes APIs: API_ 1 , API_ 2 , and API_ 3 , to implement a capability M, a capability N, and a capability P corresponding to the APIs.
- the root cause of a compatibility issue may be further located, for example, information for indicating incompatibility may include, but not limited to, an API and a capability in the Caps database.
- information for indicating incompatibility may include, but not limited to, an API and a capability in the Caps database.
- information for indicating incompatibility is output: incompatible with API_ 2 , and/or, incompatible with the capability N in the Caps database; and then, the information for indicating incompatibility is fed back, making it convenient for a developer to quickly fix the problem.
- the capability parameter corresponding to the capability that needs to be implemented by the API invoked by the 3D engine is learned according to the test result of running the 3D engine, and the capability parameter is compared with the hardware capability parameter of the graphics card A to be simulated, to determine whether the 3D engine is compatible with the graphics card A to be simulated.
- different virtual graphics card data is simulated, and the data is used to test the compatibility of a 3D engine, to determine whether the 3D engine is compatible with a graphics card to be simulated, so that the problems of a long testing period and low efficiency caused by insertion and removal of a graphics card, driver reinstallation, and repeated building of a large number of hardware testing environments in the prior art are avoided, and different models of graphics cards are tested in the case of building a testing environment once, thereby shortening the testing period, and accelerating a testing procedure.
- step S 204 of running a predetermined 3D engine according to the hardware capability parameter includes:
- S 402 Determine whether a capability implemented by an API that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter.
- the 3D engine invokes APIs: API_ 1 , API_ 2 , and API_ 3 , to implement the capability M, the capability N, and the capability P, to determine whether the capability that needs to be implemented by the 3D engine is the capability supported by the graphics card and recorded by the hardware capability parameter.
- the 3D engine invokes APIs: API_ 1 , API_ 2 , and API_ 3 , to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability).
- M for example, the maximum texture width (MaxTextureWidth) is 8192
- the capability N the projected density profile (D3DTEXTURECAPS_PROJECTED) capability
- the capability P for example, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability.
- Caps database of graphics cards that the graphics card A to be simulated can support the foregoing capabilities, and it is determined that the result of running the 3D engine is normal.
- S 406 Determine, if the capability implemented by the API is not the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is error.
- the 3D engine invokes APIs: API_ 1 , API_ 2 , and API_ 3 , to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability).
- the capability M for example, the maximum texture width (MaxTextureWidth) is 8192
- the capability N the projected density profile (D3DTEXTURECAPS_PROJECTED) capability
- the capability P for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability.
- a capability implemented by an API invoked by a 3D engine is a capability supported by a graphics card to be simulated, to obtain whether a result of running the 3D engine is normal, thereby obtaining a result of testing the compatibility of the 3D engine, so that a tester can obtain, by only simulating different models of graphics cards in a physical configuration environment and comparing capabilities, the result of testing the compatibility of the 3D engine, thereby saving a lot of time in building an environment, and shortening a testing period.
- step S 206 of determining, according to the result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated includes:
- S 1 Determine, if the result of running the 3D engine is normal, that the 3D engine is compatible with the graphics card to be simulated.
- the graphics card A to be simulated can support the corresponding capability M, capability N, and capability P when the 3D engine invokes the APIs, it is determined that the result of running the 3D engine is normal, and further, a test result indicating that the 3D engine is compatible with the graphics card A to be simulated may be obtained; however, if it is determined that the result of running the 3D engine is error, a test result indicating, that the 3D engine is incompatible with the graphics card A to be simulated is obtained.
- step S 402 of determining whether a capability implemented by an API that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter includes:
- a function corresponding to the foregoing API for returning the implemented capability may be preset before or in the function corresponding to the foregoing preset API that needs to be invoked, so that before the function corresponding to the foregoing API that needs to be invoked is invoked, the foregoing preset function corresponding to the API is invoked first to return the capability implemented by the invoked API.
- the 3D engine currently needs to invoke APIs: API_ 1 , API_ 2 , and API_ 3 , to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability), and information about the capability M, the capability N, and the capability P implemented by the APIs currently invoked by the 3D engine may be returned by the using the preset API.
- API_ 1 for example, the maximum texture width (MaxTextureWidth) is 8192
- the capability N the projected density profile (D3DTEXTURECAPS_PROJECTED) capability
- the capability P for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability
- the API invoked when the 3D engine is run is remolded by using the preset API, the capability implemented by the API invoked by the 3D engine is learned, and the foregoing capability is returned.
- capabilities that correspond to the APIs currently invoked by the 3D engine and are returned by using the preset API are the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability), and it is determined whether the foregoing capabilities are capabilities supported by the graphics card A to be simulated recorded by the hardware capability parameter.
- M for example, the maximum texture width (MaxTextureWidth) is 8192
- the capability N the projected density profile (D3DTEXTURECAPS_PROJECTED) capability
- the capability P for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability
- a capability implemented by an API that currently needs to be invoked when a 3D engine is run is learned by using a preset API, and is further compared with a capability that is supported by a graphics card and recorded by a hardware capability parameter, and whether the 3D engine is compatible with the graphics card to be simulated is obtained, thereby acquiring invoking information completely from the third party when the 3D engine is run, and automatically testing the compatibility of the graphics card with the 3D engine.
- step S 206 of determining, according to the result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated the method further includes:
- the root cause of a compatibility issue may be further located and output, for example, information for indicating incompatibility may include, but not limited to, an API and a capability in the Caps database.
- Bench3D is a tool for testing the capability and the compatibility of the 3D engine in this embodiment, where a test result output by the Bench3D includes: a DXDebug view, and information about an identified API and information about a capability in the Caps database when the result of running the 3D engine is error can be known from the view.
- the foregoing information may include: a sequence number (for example, 23850), a time (for example, 20:11:45:577), and Debuginfo (for example, Direct3D9: Texture in a virtual device D3DFMT_R16F format does not support D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING), foregoing example is merely exemplary, which is not limited in this application.
- the graphics card A to be simulated if it can be known from the Caps database of graphics cards that the graphics card A to be simulated does not support the corresponding capability M when the 3D engine invokes the API, it is determined that the result of running the 3D engine is error, and further the information about the identified API and the information about the capability in the Caps database are output.
- the output information may include the following information: a sequence number is 23850, a time is 20:11:45:577, and Debuginfo is Direct3D9: Texture in a virtual device D3DFMT_R16F format does not support D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING.
- the method before the acquiring a hardware capability parameter of a graphics card to be simulated, the method further includes:
- the graphics card information database records models and hardware capability parameters of multiple graphics cards including the graphics card to be simulated.
- a relatively complete graphics card information database (the Caps database of graphics cards) is established.
- different models of graphics cards are included, for example, ATI Radeon HD 3800 Series, NVDIA GEForce 9500 GT, and RADEON X700 SE; different graphics card attributes and values corresponding to the attributes are included, for example, a graphics card A to be simulated whose model is ATI Radeon HD 3800 Series is used as an example, and the graphics card A to be simulated includes the following information: a value of a maximum texture width (MaxTextureWidth) is 8192, and a value of a maximum texture height (MaxTextureHeight) is 8192; and in addition, whether the graphics card of this model supports some capabilities is further included, for example, the graphics card A to be simulated whose model is ATI Radeon HD 3800 Series is still used as an example, and the graphics card
- the acquiring a hardware capability parameter of a graphics card to be simulated in step S 202 includes: S 804 : Acquire the hardware capability parameter of the graphics card to be simulated from the graphics card information database.
- the hardware capability parameter records the capability supported by the graphics card, where the capability supported by the graphics card may include, but not limited to, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and the projected density profile (D3DTEXTURECAPS_PROJECTED) capability.
- the capability supported by the graphics card may include, but not limited to, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and the projected density profile (D3DTEXTURECAPS_PROJECTED) capability.
- a hardware capability parameter of the graphics card A to be simulated is acquired from the graphics card information database (the Caps database of graphics cards), for example, the maximum texture width (MaxTextureWidth) is 8192, and the maximum texture height (MaxTextureHeight) is 8192.
- the graphics card can support the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and can also support the projected density profile (D3DTEXTURECAPS_PROJECTED) capability, but the graphics card does not support the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability.
- a graphics card information database is established, and a hardware capability parameter of a graphics card to be simulated is acquired from the established graphics card information database, to implement simulation of a virtual graphics card, and further complete testing of a 3D engine without repeatedly building a large number of hardware testing environments, thereby saving a lot of testing costs, and shortening a testing period.
- the computer software product is stored in a storage medium (such as a read-only memory (ROM)/a random access memory (RAM), a magnetic disk, or an optical disc) and includes several instructions for instructing a terminal device (which may be a mobile phone, a computer, a server, a network device, or the like) to perform the methods described in the embodiments of the present invention.
- a storage medium such as a read-only memory (ROM)/a random access memory (RAM), a magnetic disk, or an optical disc
- a terminal device which may be a mobile phone, a computer, a server, a network device, or the like
- an apparatus for testing the compatibility of a 3D engine is further provided.
- a 3D engine functions as a bottom-layer tool to support development of higher-layer graphics software, and 3D engines are classified into real-time 3D engines and off-line 3D engines according to whether a result can be computed in real time by a mainstream computer.
- Real-time 3D pictures on a PC and a game machine are generated through computation by a 3D engine, and 3D pictures applied to a movie are realized by using an off-line 3D engine, so as to achieve a realistic effect.
- the 3D engine includes, but not limited to, at least one of the following functions: data management, a renderer, and interaction.
- a game that is offered as a real-time game may use a rasterized rendering algorithm, and for such a design, parameters related to geometry-level data include, but not limited to, refractive index, change rate in texture coordinate space, and change rate in tangent space.
- parameters related to geometry-level data include, but not limited to, refractive index, change rate in texture coordinate space, and change rate in tangent space.
- the apparatus for testing the compatibility of a 3D engine in this embodiment includes: an acquiring unit 902 , a running unit 904 , and a determining unit 906 .
- the acquiring unit 902 is configured to acquire a hardware capability parameter of a graphics card to be simulated, the hardware capability parameter recording a capability supported by the graphics card.
- the hardware capability parameter records the capability supported by the graphics card, where the capability supported by the graphics card may include, but not limited to, a cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and a projected density profile (D3DTEXTURECAPS_PROJECTED) capability.
- a cube texture D3DTEXTURECAPS_CUBEMAP
- a projected density profile D3DTEXTURECAPS_PROJECTED
- the hardware capability parameter of the graphics card to be simulated may be, but not limited to, stored in the form of a Caps database.
- the Caps database of graphics cards includes, but not limited to, models of the graphics cards, attributes of the graphics cards, values of the attributes of the graphics cards, and whether the graphics cards support a certain capability, where attributes of a graphics card in this embodiment includes, but not limited to, at least one of the following: a core frequency, a texture fill rate, a pixel fill rate, a shader, a video memory frequency, and a video memory width.
- attributes of a graphics card whose model is ATI Radeon HD 3800 Series in the Caps database of graphics cards include: a maximum texture width (MaxTextureWidth) being 8192, and a maximum texture height (MaxTextureHeight) being 8192.
- the graphics card of this model can support the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and can also support the projected density profile (D3DTEXTURECAPS_PROJECTED) capability, but the graphics card of this model does not support an ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability.
- D3DTEXTURECAPS_CUBEMAP cube texture
- D3DTEXTURECAPS_PROJECTED projected density profile
- the graphics card of this model does not support an ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability.
- step S 302 to step S 308 shown in FIG. 3 using the graphics card A to be simulated as an example, hardware capability parameters of the graphics card A to be simulated, for example, a core frequency of f, a video memory width of B, supporting a capability X, and not supporting a capability Y, are acquired, and then testing is performed.
- hardware capability parameters of the graphics card A to be simulated for example, a core frequency of f, a video memory width of B, supporting a capability X, and not supporting a capability Y, are acquired, and then testing is performed.
- the running unit 904 is configured to run a predetermined 3D engine according to the hardware capability parameter.
- the 3D engine implements the required capability by invoking an API.
- the 3D engine invokes APIs: API_ 1 , API_ 2 , and API_ 3 , to implement a capability M, a capability N, and a capability P corresponding to the APIs.
- the determining unit 906 is configured to determine, according to a result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated.
- the root cause of a compatibility issue may be further located, for example, information for indicating incompatibility may include, but not limited to, an API and a capability in the Caps database.
- information for indicating incompatibility may include, but not limited to, an API and a capability in the Caps database.
- information for indicating incompatibility is output: incompatible with API_ 2 , and/or, incompatible with the capability N in the Caps database; and then, the information for indicating incompatibility is fed back, making it convenient for a developer to quickly fix the problem.
- the capability parameter corresponding to the capability that needs to be implemented by the API invoked by the 3D engine is learned according to the test result of running the 3D engine, and the capability parameter is compared with the hardware capability parameter of the graphics card A to be simulated, to determine whether the 3D engine is compatible with the graphics card A to be simulated.
- different virtual graphics card data is simulated, and the data is used to test the compatibility of a 3D engine, to determine whether the 3D engine is compatible with a graphics card to be simulated, so that the problems of a long testing period and low efficiency caused by insertion and removal of a graphics card, driver reinstallation, and repeated building of a large number of hardware testing environments in the prior art are avoided, and different models of graphics cards are tested in the case of building a testing environment once, thereby shortening the testing period, and accelerating a testing procedure.
- the running unit 904 includes:
- the 3D engine invokes APIs: API_ 1 , API_ 2 , and API_ 3 , to implement the capability M, the capability N, and the capability P, to determine whether the capability that needs to be implemented by the 3D engine is the capability supported by the graphics card and recorded by the hardware capability parameter.
- the capability implemented by the API is the capability that is supported by the graphics card and recorded by the hardware capability parameter, it is determined that the result of running the 3D engine is normal.
- the 3D engine invokes APIs: API_ 1 , API_ 2 , and API_ 3 , to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability).
- M for example, the maximum texture width (MaxTextureWidth) is 8192
- the capability N the projected density profile (D3DTEXTURECAPS_PROJECTED) capability
- the capability P for example, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability.
- Caps database of graphics cards that the graphics card A to be simulated can support the foregoing capabilities, and it is determined that the result of running the 3D engine is normal.
- the capability implemented by the API is not the capability that is supported by the graphics card and recorded by the hardware capability parameter, it is determined that the result of running the 3D engine is error.
- the 3D engine invokes APIs: API_ 1 , API_ 2 , and API_ 3 , to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192) the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability).
- M for example, the maximum texture width (MaxTextureWidth) is 8192
- the capability N the projected density profile (D3DTEXTURECAPS_PROJECTED) capability
- the capability P for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability.
- a capability implemented by an API invoked by a 3D engine is a capability supported by a graphics card to be simulated, to obtain whether a result of running the 3D engine is normal, thereby obtaining a result of testing the compatibility of the 3D engine, so that a tester can obtain, by only simulating different models of graphics cards in a physical configuration environment and comparing capabilities, the result of testing the compatibility of the 3D engine, thereby saving a lot of time in building an environment, and shortening a testing period.
- the determining unit 906 includes:
- a second determining module configured to determine whether the result of running the 3D engine is normal; and determine, if the result of running the 3D engine is normal, that the 3D engine is compatible with the graphics card to be simulated; or determine, if the result of running the 3D engine is error, that the 3D engine is incompatible with the graphics card to be simulated.
- the graphics card A to be simulated can support the corresponding capability M, capability N, and capability P when the 3D engine invokes the APIs, it is determined that the result of running the 3D engine is normal, and further, a test result indicating that the 3D engine is compatible with the graphics card A to be simulated may be obtained; however, if it is determined that the result of running the 3D engine is error, a test result indicating that the 3D engine is incompatible with the graphics card A to be simulated is obtained.
- the first determining module includes: a returning submodule and a first determining submodule.
- the returning submodule is configured to return, by using a preset API, when the 3D engine is run, if it is determined that the API needs to be invoked currently, the capability implemented by the invoked API.
- a function corresponding to the foregoing API for returning the implemented capability may be preset before or in the function corresponding to the foregoing preset API that needs to be invoked, so that before the function corresponding to the foregoing API that needs to be invoked is invoked, the foregoing preset function corresponding to the API is invoked first to return the capability implemented by the invoked API.
- the 3D engine currently needs to invoke APIs: API_ 1 , API_ 2 , and API_ 3 , to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability), and information about the capability M, the capability N, and the capability P implemented by the APIs currently invoked by the 3D engine may be returned by the using the preset API.
- API_ 1 for example, the maximum texture width (MaxTextureWidth) is 8192
- the capability N the projected density profile (D3DTEXTURECAPS_PROJECTED) capability
- the capability P for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability
- the API invoked when the 3D engine is run is remolded by using the preset API, the capability implemented by the API invoked by the 3D engine is learned, and the foregoing capability is returned.
- the first determining submodule is configured to determine whether the returned capability is the capability that is supported by the graphics card and recorded by the hardware capability parameter.
- capabilities that correspond to the APIs currently invoked by the 3D engine and are returned by using the preset API are the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability), and it is determined whether the foregoing capabilities are capabilities supported by the graphics card A to be simulated recorded by the hardware capability parameter.
- M for example, the maximum texture width (MaxTextureWidth) is 8192
- the capability N the projected density profile (D3DTEXTURECAPS_PROJECTED) capability
- the capability P for example, the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability
- a capability implemented by an API that currently needs to be invoked when a 3D engine is run is learned by using a preset API, and is further compared with a capability that is supported by a graphics card and recorded by a hardware capability parameter, and whether the 3D engine is compatible with the graphics card to be simulated is obtained, thereby acquiring invoking information completely from the third party when the 3D engine is run, and automatically testing the compatibility of the graphics card with the 3D engine.
- the apparatus for testing the compatibility of a 3D engine in this embodiment further includes:
- an output unit 1002 configured to: after it is determined, according to the result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated, output information for identifying the API and information about the capability if the result of running the 3D engine is error.
- the root cause of a compatibility issue may be further located and output, for example, information for indicating incompatibility may include, but not limited to, an API and a capability in the Caps database.
- Bench3D is a tool for testing the capability and the compatibility of the 3D engine in this embodiment, where a test result output by the Bench3D includes: a DXDebug view, and information about an identified API and information about a capability in the Caps database when the result of running the 3D engine is error can be known from the view.
- the foregoing information may include: a sequence number (for example, 23850), a time (for example, 20:11:45:577), and Debuginfo (for example, Direct3D9: Texture in a virtual device D3DFMT_R16F format does not support D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING), and the foregoing example is merely exemplary, which is not limited in this application.
- a sequence number for example, 23850
- a time for example, 20:11:45:577
- Debuginfo for example, Direct3D9: Texture in a virtual device D3DFMT_R16F format does not support D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
- the graphics card A to be simulated if it can be known from the Caps database of graphics cards that the graphics card A to be simulated does not support the corresponding capability M when the 3D engine invokes the API, it is determined that the result of running the 3D engine is error, and further the information about the identified API and the information about the capability in the Caps database are output.
- the output information may include the following information: a sequence number is 23850, a time is 20:11:45:577, and Debuginfo is Direct3D9: Texture in a virtual device D3DFMT_R16F format does not support D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING.
- the apparatus for testing the compatibility of a 3D engine in this embodiment further includes:
- an establishing unit 1102 configured to establish a graphics card information database before the hardware capability parameter of the graphics card to be simulated is acquired, where the graphics card information database records models and hardware capability parameters of multiple graphics cards including the graphics card to be simulated.
- the graphics card information database records models and hardware capability parameters of multiple graphics cards including the graphics card to be simulated.
- a relatively complete graphics card information database (the Caps database of graphics cards) is established.
- different models of graphics cards are included, for example, ATI Radeon HD 3800 Series, NVDIA GEForce 9500 GT, and RADEON X700 SE; different graphics card attributes and values corresponding to the attributes are included, for example, a graphics card A to be simulated whose model is ATI Radeon HD 3800 Series is used as an example, and the graphics card A to be simulated includes the following information: a value of a maximum texture width (MaxTextureWidth) is 8192, and a value of a maximum texture height (MaxTextureHeight) is 8192; and in addition, whether the graphics card of this model supports some capabilities is further included, for example, the graphics card A to be simulated whose model is ATI Radeon HD 3800 Series is still used as an example, and the graphics card
- the acquiring unit 902 includes: an acquiring module 1104 , configured to acquire the hardware capability parameter of the graphics card to be simulated from the graphics card information database.
- the hardware capability parameter records the capability supported by the graphics card, where the capability supported by the graphics card may include, but not limited to, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and the projected density profile (D3DTEXTURECAPS_PROJECTED) capability.
- the capability supported by the graphics card may include, but not limited to, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and the projected density profile (D3DTEXTURECAPS_PROJECTED) capability.
- a hardware capability parameter of the graphics card A to be simulated is acquired from the graphics card information database (the Caps database of graphics cards), for example, the maximum texture width (MaxTextureWidth) is 8192, and the maximum texture height (MaxTextureHeight) is 8192.
- the graphics card can support the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and can also support the projected density profile (D3DTEXTURECAPS_PROJECTED) capability, but the graphics card does not support the ⁇ palette (D3DTEXTURECAPS_ALPHAPALETTE) capability.
- a graphics card information database is established, and a hardware capability parameter of a graphics card to be simulated is acquired from the established graphics card information database, to implement simulation of a virtual graphics card, and further complete testing of a 3D engine without repeatedly building a large number of hardware testing environments, thereby saving a lot of testing costs, and shortening a testing period.
- sequence numbers of the foregoing embodiments of the present invention are merely for description, and do not represent the superiority or inferiority of the embodiments.
- the disclosed client may be implemented in other manners.
- the described apparatus embodiments are merely exemplary.
- the unit division is merely logical function division and may be other division in actual implementation.
- multiple units or components may be combined or integrated into another system, or some features may be ignored or not performed.
- the displayed or discussed mutual couplings or direct couplings or communication connections may be implemented through some interfaces.
- the indirect couplings or communication connections between the units or modules may be implemented in electronic or other forms.
- the units described as separate parts may or may not be physically separate, and the parts displayed as units may or may not be physical units, may be located in one position, or may be distributed on multiple network units. Some or all of the units may be selected to achieve the objectives of the solutions of the embodiments according to actual needs.
- functional units in the embodiments of the present invention may be integrated into one processing unit, or each of the units may exist alone physically, or two or more units may be integrated into one unit.
- the integrated unit may be implemented in a form of hardware, or may be implemented in a form of a software functional unit.
- the integrated unit When the integrated unit is implemented in a form of a software functional unit and sold or used as an independent product, the integrated unit may be stored in a computer-readable storage medium.
- the computer software product is stored in a storage medium and includes several instructions for instructing a computer device (which may be a PC, a server, a network device, or the like) to perform all or some of the steps of the methods described in the embodiments of the present invention.
- the foregoing storage medium includes: any medium that can store program code, such as a USB flash drive, a removable hard disk, a ROM, a RAM, a magnetic disk, or an optical disc.
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
- Testing, Inspecting, Measuring Of Stereoscopic Televisions And Televisions (AREA)
Abstract
Description
- The present disclosure relates to the field of computers, and in particular, to a method and an apparatus for testing the compatibility of a 3D engine.
- Currently, in a conventional solution of testing the compatibility of a 3D engine, for example, in step S102 to step S114 shown in
FIG. 1 , generally, different graphics cards are selected to perform hardware testing, to determine whether a graphics card to be tested is compatible with a 3D engine. In such a testing method, different models of graphics cards need to be searched for, and a large number of hardware testing environments need to be built for testing; and then information about a tested problem is fed back for development and repair. However, such a solution of testing the compatibility of a 3D engine has many defects: - 1. There are some difficulties for building a hardware environment because some graphics cards are difficult to be found, and a large amount of hardware leads to high costs; as a result, the building of a large number of hardware testing environments is difficult to implement.
- 2. A testing period is relatively long. A client with memory of several GBs needs a relatively long time when copying, inserting and removing a graphics card, reinstalling a driver, and configuring a network environment, which is also inappropriate to a quick procedure.
- 3. Generally, information fed back by a compatibility test usually only describes a phenomenon (such as a screenshot or a testing environment), helps little in locating a reason, and is also inconvenient for building a testing environment in the terms of development, finally leading to some long-time insolvable compatibility issues.
- For the foregoing problems, no effective solution is provided yet currently.
- Embodiments of the present invention provide a method and an apparatus for testing the compatibility of a 3D engine, so as to at least solve the technical problem that a hardware testing environment needs to be repeatedly built to test the compatibility of a 3D engine with different graphics cards.
- According to an aspect of the embodiments of the present invention, a method for testing the compatibility of a 3D engine is provided, including: acquiring a hardware capability parameter of a graphics card to be simulated, the hardware capability parameter recording a capability supported by the graphics card; running a predetermined 3D engine according to the hardware capability parameter; and determining, according to a result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated.
- Optionally, the running a predetermined 3D engine according to the hardware capability parameter includes: determining whether a capability implemented by an application programming interface (API) that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter; and determining, if the capability implemented by the API is the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is normal; or determining, if the capability implemented by the API is not the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is error.
- Optionally, the determining, according to a result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated includes: determining, if the result of running the 3D engine is normal, that the 3D engine is compatible with the graphics card to be simulated; or determining, if the result of running the 3D engine is error, that the 3D engine is incompatible with the graphics card to be simulated.
- Optionally, the determining whether a capability implemented by an API that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter includes: returning, by using a preset API, when the 3D engine is run, if it is determined that the API needs to be invoked currently, the capability implemented by the invoked API; and determining whether the returned capability is the capability that is supported by the graphics card and recorded by the hardware capability parameter.
- Optionally, after the determining, according to a result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated, the method further includes: outputting information for identifying the API and information about the capability if the result of running the 3D engine is error.
- Optionally, before the acquiring a hardware capability parameter of a graphics card to be simulated, the method further includes: establishing a graphics card information database, where the graphics card information database records models and hardware capability parameters of multiple graphics cards including the graphics card to be simulated, where the acquiring a hardware capability parameter of a graphics card to be simulated includes: acquiring the hardware capability parameter of the graphics card to be simulated from the graphics card information database.
- According to another aspect of the embodiments of the present invention, an apparatus for testing the compatibility of a 3D engine is provided, including: an acquiring unit, configured to acquire a hardware capability parameter of a graphics card to be simulated, the hardware capability parameter recording a capability supported by the graphics card; a running unit, configured to run a predetermined 3D engine according to the hardware capability parameter; and a determining unit, configured to determine, according to a result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated.
- Optionally, the finning unit includes: a first determining module, configured to determine whether a capability implemented by an API that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter; and determine, if the capability implemented by the API is the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is normal; or determine, if the capability implemented by the API is not the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is error.
- Optionally, the determining unit includes: a second determining module, configured to determine whether the result of running the 3D engine is normal; and determine, if the result of running the 3D engine is normal, that the 3D engine is compatible with the graphics card to be simulated; or determine, if the result of running the 3D engine is error, that the 3D engine is incompatible with the graphics card to be simulated.
- Optionally, the first determining module includes: a returning submodule, configured to return, by using a preset API, when the 3D engine is run, if it is determined that the API needs to be invoked currently, the capability implemented by the invoked API; and a first determining submodule, configured to determine whether the returned capability is the capability that is supported by the graphics card and recorded by the hardware capability parameter.
- Optionally, the apparatus further includes: an output unit, configured to: after it is determined, according to the result of naming the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated, output information for identifying the API and information about the capability if the result of running the 3D engine is error.
- Optionally, the apparatus further includes: an establishing unit, configured to establish a graphics card information database before the hardware capability parameter of the graphics card to be simulated is acquired, where the graphics card information database records models and hardware capability parameters of multiple graphics cards including the graphics card to be simulated, where the acquiring unit includes: an acquiring module, configured to acquire the hardware capability parameter of the graphics card to be simulated from the graphics card information database.
- In the embodiments of the present invention, a virtual graphics card is simulated according to hardware capability parameters of different graphics cards, and a predetermined 3D engine is run on the virtual graphics card, so that the objective of testing the compatibility of 3D engines of different graphics cards is achieved, testing the compatibility by searching for a large amount of hardware and building a large number of hardware testing environments as in the prior art is avoided, and the technical problem that a hardware testing environment needs to be repeatedly built to test the compatibility of a 3D engine with different graphics cards is solved, thereby achieving technical effects of testing the compatibility of the 3D engine with different graphics cards in a hardware testing environment built once, and shortening a testing period of the compatibility.
- The accompanying drawings described herein are used to further understand the present disclosure, and constitute a part of this application, and the exemplary embodiments of the present invention and the descriptions thereof are used to explain the present disclosure, but are not construed as an inappropriate limitation to the present disclosure. In the accompanying drawings:
-
FIG. 1 is a flowchart of a method for testing the compatibility of a 3D engine in the prior art; -
FIG. 2 is a flowchart of an optional method for testing the compatibility of a 3D engine according to an embodiment of the present invention; -
FIG. 3 is a flowchart of another optional method for testing the compatibility of a 3D engine according to an embodiment of the present invention; -
FIG. 4 is a flowchart of still another optional method for testing the compatibility of a 3D engine according to an embodiment of the present invention; -
FIG. 5 is a flowchart of yet another optional method for testing the compatibility of a 3D engine according to an embodiment of the present invention; -
FIG. 6 is a schematic diagram of an optional output result of testing the compatibility of a 3D engine according to an embodiment of the present invention; -
FIG. 7 is a schematic diagram of a graphics card information database established in an optional test of the compatibility of a 3D engine according to an embodiment of the present invention; -
FIG. 8 is a flowchart of an optional method for testing the compatibility of a 3D engine according to an embodiment of the present invention; -
FIG. 9 is a schematic diagram of an optional apparatus for testing the compatibility of a 3D engine according to an embodiment of the present invention; -
FIG. 10 is a schematic diagram of another optional apparatus for testing the compatibility of a 3D engine according to an embodiment of the present invention; and -
FIG. 11 is a schematic diagram of still another optional apparatus for testing the compatibility of a 3D engine according to an embodiment of the present invention. - To make a person skilled in the art better understand the solutions of the present disclosure, the following clearly and completely describes the technical solutions in the embodiments of the present invention with reference to the accompanying drawings in the embodiments of the present invention. Apparently, the described embodiments are merely some rather than all of the embodiments of the present invention. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the protection scope of the present disclosure.
- It should be noted that, terms such as “first” and “second” in the specification, claims and the foregoing accompanying drawings of the present disclosure are used to distinguish similar objects, but are not necessarily used to describe a specific sequence or order. It should be understood that data used in this way is interchangeable in an appropriate situation, so that the embodiments of the present invention described herein can be implemented in other sequences than those that are shown or described herein. In addition, terms “include” and “have” and any variations of them are intended to cover nonexclusive inclusions, for example, a process, method, system, product or device including a series of steps or units is not necessarily limited to those steps and units that are clearly listed, but can include other steps or units that are not clearly listed or that are inherent in the process, method, product or device.
- According to this embodiment of the present invention, a method for testing the compatibility of a 3D engine is provided. Optionally, in this embodiment, a 3D engine functions as a bottom-layer tool to support development of higher-layer graphics software, and 3D engines are classified into real-
time 3D engines and off-line 3D engines according to whether a result can be computed in real time by a mainstream computer. Real-time 3D pictures on a personal computer (PC) and a game machine are generated through computation by a 3D engine, and 3D pictures applied to a movie are realized by using an off-line 3D engine, so as to achieve a realistic effect. The 3D engine includes, but not limited to, at least one of the following functions: data management, a renderer, and interaction. For example, a game that is offered as a real-time game may use a rasterized rendering algorithm, and for such a design, parameters related to geometry-level data include, but not limited to, refractive index, change rate in texture coordinate space, and change rate in tangent space. The foregoing example is merely exemplary, which is not limited in this application. - As shown in
FIG. 2 , the method for testing the compatibility of a 3D engine in this embodiment includes: - S202: Acquire a hardware capability parameter of a graphics card to be simulated.
- Optionally, in this embodiment, the hardware capability parameter records a capability supported by the graphics card, where the capability supported by the graphics card may include, but not limited to, a cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and a projected density profile (D3DTEXTURECAPS_PROJECTED) capability.
- Optionally, in this embodiment, the hardware capability parameter of the graphics card to be simulated may be, but not limited to, stored in the form of a Caps database. The Caps database of graphics cards includes, but not limited to, models of the graphics cards, attributes of the graphics cards, values of the attributes of the graphics cards, and whether the graphics cards support a certain capability, where attributes of a graphics card in this embodiment includes, but not limited to, at least one of the following: a core frequency, a texture fill rate, a pixel fill rate, a shader, a video memory frequency, and a video memory width.
- For example, using a graphics card A to be simulated as an example, as shown in
FIG. 7 , attributes of a graphics card whose model is ATI Radeon HD 3800 Series in the Caps database of graphics cards, and values of these attributes include: a maximum texture width (MaxTextureWidth) being 8192, and a maximum texture height (MaxTextureHeight) being 8192. In addition, it can be further known from the Caps database of graphics cards that the graphics card of this model can support the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and can also support the projected density profile (D3DTEXTURECAPS_PROJECTED) capability, but the graphics card of this model does not support an α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability. - For example, with reference to step S302 to step S308 shown in
FIG. 3 , using the graphics card A to be simulated as an example, hardware capability parameters of the graphics card A to be simulated, for example, a core frequency of f, a video memory width of B, supporting a capability X, and not supporting a capability Y, are acquired, and then testing is performed. - S204: Run a predetermined 3D engine according to the hardware capability parameter.
- Optionally, in this embodiment, the 3D engine implements the required capability by invoking an API. For example, when the predetermined 3D engine is run, the 3D engine invokes APIs: API_1, API_2, and API_3, to implement a capability M, a capability N, and a capability P corresponding to the APIs.
- S206: Determine, according to a result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated.
- Optionally, in this embodiment, after it is determined whether the 3D engine is compatible with the graphics card to be simulated, the root cause of a compatibility issue may be further located, for example, information for indicating incompatibility may include, but not limited to, an API and a capability in the Caps database. For example, with reference to step S310 to step S316 shown in
FIG. 3 , after a test result indicating incompatibility is determined, information for indicating incompatibility is output: incompatible with API_2, and/or, incompatible with the capability N in the Caps database; and then, the information for indicating incompatibility is fed back, making it convenient for a developer to quickly fix the problem. - For example, using the graphics card A to be simulated as an example, the capability parameter corresponding to the capability that needs to be implemented by the API invoked by the 3D engine is learned according to the test result of running the 3D engine, and the capability parameter is compared with the hardware capability parameter of the graphics card A to be simulated, to determine whether the 3D engine is compatible with the graphics card A to be simulated.
- In this embodiment provided by this application, different virtual graphics card data is simulated, and the data is used to test the compatibility of a 3D engine, to determine whether the 3D engine is compatible with a graphics card to be simulated, so that the problems of a long testing period and low efficiency caused by insertion and removal of a graphics card, driver reinstallation, and repeated building of a large number of hardware testing environments in the prior art are avoided, and different models of graphics cards are tested in the case of building a testing environment once, thereby shortening the testing period, and accelerating a testing procedure.
- As an optional solution, as shown in
FIG. 4 , step S204 of running a predetermined 3D engine according to the hardware capability parameter includes: - S402: Determine whether a capability implemented by an API that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter.
- For example, using the graphics card A to be simulated as an example, the 3D engine invokes APIs: API_1, API_2, and API_3, to implement the capability M, the capability N, and the capability P, to determine whether the capability that needs to be implemented by the 3D engine is the capability supported by the graphics card and recorded by the hardware capability parameter.
- S404: Determine, if the capability implemented by the API is the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is normal.
- For example, using the graphics card A to be simulated as an example, the 3D engine invokes APIs: API_1, API_2, and API_3, to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability). It can be known from the Caps database of graphics cards that the graphics card A to be simulated can support the foregoing capabilities, and it is determined that the result of running the 3D engine is normal.
- S406: Determine, if the capability implemented by the API is not the capability that is supported by the graphics card and recorded by the hardware capability parameter, that the result of running the 3D engine is error.
- For example, using the graphics card A to be simulated as an example, the 3D engine invokes APIs: API_1, API_2, and API_3, to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability). It can be known from the Caps database of graphics cards that the graphics card A to be simulated can support the capability M and the capability N, but does not support the capability P, and it is determined that the result of running the 3D engine is error.
- In this embodiment provided by this application, it is determined whether a capability implemented by an API invoked by a 3D engine is a capability supported by a graphics card to be simulated, to obtain whether a result of running the 3D engine is normal, thereby obtaining a result of testing the compatibility of the 3D engine, so that a tester can obtain, by only simulating different models of graphics cards in a physical configuration environment and comparing capabilities, the result of testing the compatibility of the 3D engine, thereby saving a lot of time in building an environment, and shortening a testing period.
- As an optional solution, step S206 of determining, according to the result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated includes:
- S1: Determine, if the result of running the 3D engine is normal, that the 3D engine is compatible with the graphics card to be simulated.
- S2: Determine, if the result of running the 3D engine is error, that the 3D engine is incompatible with the graphics card to be simulated.
- For example, using the graphics card A to be simulated as an example, if it can be known from the Caps database of graphics cards that, the graphics card A to be simulated can support the corresponding capability M, capability N, and capability P when the 3D engine invokes the APIs, it is determined that the result of running the 3D engine is normal, and further, a test result indicating that the 3D engine is compatible with the graphics card A to be simulated may be obtained; however, if it is determined that the result of running the 3D engine is error, a test result indicating, that the 3D engine is incompatible with the graphics card A to be simulated is obtained.
- As still another optional solution, as shown in
FIG. 5 , step S402 of determining whether a capability implemented by an API that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter includes: - S502: Return, by using a preset API, when the 3D engine is run, if it is determined that the API needs to be invoked currently, the capability implemented by the invoked API.
- Optionally, in this embodiment, in an algorithm corresponding to the 3D engine, a function corresponding to the foregoing API for returning the implemented capability may be preset before or in the function corresponding to the foregoing preset API that needs to be invoked, so that before the function corresponding to the foregoing API that needs to be invoked is invoked, the foregoing preset function corresponding to the API is invoked first to return the capability implemented by the invoked API. For example, using the graphics card A to be simulated as an example, the 3D engine currently needs to invoke APIs: API_1, API_2, and API_3, to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability), and information about the capability M, the capability N, and the capability P implemented by the APIs currently invoked by the 3D engine may be returned by the using the preset API.
- It is further noted that, under the premise of making no modification to the tested 3D engine, the API invoked when the 3D engine is run is remolded by using the preset API, the capability implemented by the API invoked by the 3D engine is learned, and the foregoing capability is returned.
- S504: Determine whether the returned capability is the capability that is supported by the graphics card and recorded by the hardware capability parameter.
- For example, using the graphics card A to be simulated as an example, capabilities that correspond to the APIs currently invoked by the 3D engine and are returned by using the preset API are the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability), and it is determined whether the foregoing capabilities are capabilities supported by the graphics card A to be simulated recorded by the hardware capability parameter.
- In this embodiment provided by this application, from the perspective of a third party, a capability implemented by an API that currently needs to be invoked when a 3D engine is run is learned by using a preset API, and is further compared with a capability that is supported by a graphics card and recorded by a hardware capability parameter, and whether the 3D engine is compatible with the graphics card to be simulated is obtained, thereby acquiring invoking information completely from the third party when the 3D engine is run, and automatically testing the compatibility of the graphics card with the 3D engine.
- As an optional solution, after step S206 of determining, according to the result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated, the method further includes:
- S1: Output information for identifying the API and information about the capability if the result of running the 3D engine is error.
- Optionally, in this embodiment, after it is determined whether the 3D engine is compatible with the graphics card to be simulated, the root cause of a compatibility issue may be further located and output, for example, information for indicating incompatibility may include, but not limited to, an API and a capability in the Caps database.
- Optionally, as shown in
FIG. 6 , Bench3D is a tool for testing the capability and the compatibility of the 3D engine in this embodiment, where a test result output by the Bench3D includes: a DXDebug view, and information about an identified API and information about a capability in the Caps database when the result of running the 3D engine is error can be known from the view. For example, the foregoing information may include: a sequence number (for example, 23850), a time (for example, 20:11:45:577), and Debuginfo (for example, Direct3D9: Texture in a virtual device D3DFMT_R16F format does not support D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING), foregoing example is merely exemplary, which is not limited in this application. - For example, using the graphics card A to be simulated as an example, if it can be known from the Caps database of graphics cards that the graphics card A to be simulated does not support the corresponding capability M when the 3D engine invokes the API, it is determined that the result of running the 3D engine is error, and further the information about the identified API and the information about the capability in the Caps database are output. For example, the output information may include the following information: a sequence number is 23850, a time is 20:11:45:577, and Debuginfo is Direct3D9: Texture in a virtual device D3DFMT_R16F format does not support D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING.
- In this embodiment provided by this application, when a result of running a 3D engine is error, information for identifying an API and information about a capability are output, thereby solving the problem in the prior art that a test result only feeds back the description for a phenomenon, accurately locating the root cause of a compatibility issue, and making it convenient for a developer to quickly fix the problem.
- As an optional solution, as shown in
FIG. 8 , before the acquiring a hardware capability parameter of a graphics card to be simulated, the method further includes: - S802: Establish a graphics card information database.
- Optionally, in this embodiment, the graphics card information database records models and hardware capability parameters of multiple graphics cards including the graphics card to be simulated.
- For example, before the hardware capability parameter of the graphics card to be simulated is acquired, a large amount of graphics card information is collected, and a relatively complete graphics card information database (the Caps database of graphics cards) is established. As shown in
FIG. 7 , different models of graphics cards are included, for example,ATI Radeon HD 3800 Series,NVDIA GEForce 9500 GT, and RADEON X700 SE; different graphics card attributes and values corresponding to the attributes are included, for example, a graphics card A to be simulated whose model isATI Radeon HD 3800 Series is used as an example, and the graphics card A to be simulated includes the following information: a value of a maximum texture width (MaxTextureWidth) is 8192, and a value of a maximum texture height (MaxTextureHeight) is 8192; and in addition, whether the graphics card of this model supports some capabilities is further included, for example, the graphics card A to be simulated whose model isATI Radeon HD 3800 Series is still used as an example, and the graphics card A to be simulated can support the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and can also support the projected density profile (D3DTEXTURECAPS_PROJECTED) capability, but the graphics card of this model does not support the α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability. - The acquiring a hardware capability parameter of a graphics card to be simulated in step S202 includes: S804: Acquire the hardware capability parameter of the graphics card to be simulated from the graphics card information database.
- Optionally, in this embodiment, the hardware capability parameter records the capability supported by the graphics card, where the capability supported by the graphics card may include, but not limited to, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and the projected density profile (D3DTEXTURECAPS_PROJECTED) capability.
- For example, using the graphics card A to be simulated as an example, a hardware capability parameter of the graphics card A to be simulated is acquired from the graphics card information database (the Caps database of graphics cards), for example, the maximum texture width (MaxTextureWidth) is 8192, and the maximum texture height (MaxTextureHeight) is 8192. In addition, it can be further known from the Caps database of graphics cards that, the graphics card can support the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and can also support the projected density profile (D3DTEXTURECAPS_PROJECTED) capability, but the graphics card does not support the α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability.
- In this embodiment provided by this application, a graphics card information database is established, and a hardware capability parameter of a graphics card to be simulated is acquired from the established graphics card information database, to implement simulation of a virtual graphics card, and further complete testing of a 3D engine without repeatedly building a large number of hardware testing environments, thereby saving a lot of testing costs, and shortening a testing period.
- It should be noted that, for the foregoing method embodiments, for the brevity of description, the method embodiments are described as a series of action combinations. But a person skilled in the art should appreciate that the present disclosure is not limited to the order of the described actions, because according to the present disclosure, some steps may be performed in another order or performed simultaneously. A person skilled in the art should also know that the embodiments described in this specification all belong to preferred embodiments, and the involved actions and modules are not necessarily required by the present disclosure.
- Through the description of the foregoing implementation manners, a person skilled in the art may clearly understand that the method of the foregoing embodiment may be implemented in a manner of software plus a necessary general hardware platform, and certainly may also be implemented by hardware, but in most cases, the former is a better implementation manner. Based on such an understanding, the technical solutions of the present disclosure essentially, or the part contributing to the prior art may be implemented in a form of a software product. The computer software product is stored in a storage medium (such as a read-only memory (ROM)/a random access memory (RAM), a magnetic disk, or an optical disc) and includes several instructions for instructing a terminal device (which may be a mobile phone, a computer, a server, a network device, or the like) to perform the methods described in the embodiments of the present invention.
- According to this embodiment of the present invention, an apparatus for testing the compatibility of a 3D engine is further provided. Optionally, in this embodiment, a 3D engine functions as a bottom-layer tool to support development of higher-layer graphics software, and 3D engines are classified into real-
time 3D engines and off-line 3D engines according to whether a result can be computed in real time by a mainstream computer. Real-time 3D pictures on a PC and a game machine are generated through computation by a 3D engine, and 3D pictures applied to a movie are realized by using an off-line 3D engine, so as to achieve a realistic effect. The 3D engine includes, but not limited to, at least one of the following functions: data management, a renderer, and interaction. For example, a game that is offered as a real-time game may use a rasterized rendering algorithm, and for such a design, parameters related to geometry-level data include, but not limited to, refractive index, change rate in texture coordinate space, and change rate in tangent space. The foregoing example is merely exemplary, which is not limited in this application. - As shown in
FIG. 9 , the apparatus for testing the compatibility of a 3D engine in this embodiment includes: an acquiringunit 902, a runningunit 904, and a determiningunit 906. - 1) The acquiring
unit 902 is configured to acquire a hardware capability parameter of a graphics card to be simulated, the hardware capability parameter recording a capability supported by the graphics card. - Optionally, in this embodiment, the hardware capability parameter records the capability supported by the graphics card, where the capability supported by the graphics card may include, but not limited to, a cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and a projected density profile (D3DTEXTURECAPS_PROJECTED) capability.
- Optionally, in this embodiment, the hardware capability parameter of the graphics card to be simulated may be, but not limited to, stored in the form of a Caps database. The Caps database of graphics cards includes, but not limited to, models of the graphics cards, attributes of the graphics cards, values of the attributes of the graphics cards, and whether the graphics cards support a certain capability, where attributes of a graphics card in this embodiment includes, but not limited to, at least one of the following: a core frequency, a texture fill rate, a pixel fill rate, a shader, a video memory frequency, and a video memory width.
- For example, using a graphics card A to be simulated as an example, as shown in
FIG. 7 , attributes of a graphics card whose model isATI Radeon HD 3800 Series in the Caps database of graphics cards, and values of these attributes include: a maximum texture width (MaxTextureWidth) being 8192, and a maximum texture height (MaxTextureHeight) being 8192. In addition, it can be further known from the Caps database of graphics cards that the graphics card of this model can support the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and can also support the projected density profile (D3DTEXTURECAPS_PROJECTED) capability, but the graphics card of this model does not support an α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability. - For example, with reference to step S302 to step S308 shown in
FIG. 3 , using the graphics card A to be simulated as an example, hardware capability parameters of the graphics card A to be simulated, for example, a core frequency of f, a video memory width of B, supporting a capability X, and not supporting a capability Y, are acquired, and then testing is performed. - 2) The running
unit 904 is configured to run a predetermined 3D engine according to the hardware capability parameter. - Optionally, in this embodiment, the 3D engine implements the required capability by invoking an API. For example, when the predetermined 3D engine is run, the 3D engine invokes APIs: API_1, API_2, and API_3, to implement a capability M, a capability N, and a capability P corresponding to the APIs.
- 3) The determining
unit 906 is configured to determine, according to a result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated. - Optionally, in this embodiment, after it is determined whether the 3D engine is compatible with the graphics card to be simulated, the root cause of a compatibility issue may be further located, for example, information for indicating incompatibility may include, but not limited to, an API and a capability in the Caps database. For example, with reference to step S310 to step S316 shown in
FIG. 3 , after a test result indicating incompatibility is determined, information for indicating incompatibility is output: incompatible with API_2, and/or, incompatible with the capability N in the Caps database; and then, the information for indicating incompatibility is fed back, making it convenient for a developer to quickly fix the problem. - For example, using the graphics card A to be simulated as an example, the capability parameter corresponding to the capability that needs to be implemented by the API invoked by the 3D engine is learned according to the test result of running the 3D engine, and the capability parameter is compared with the hardware capability parameter of the graphics card A to be simulated, to determine whether the 3D engine is compatible with the graphics card A to be simulated.
- In this embodiment provided by this application, different virtual graphics card data is simulated, and the data is used to test the compatibility of a 3D engine, to determine whether the 3D engine is compatible with a graphics card to be simulated, so that the problems of a long testing period and low efficiency caused by insertion and removal of a graphics card, driver reinstallation, and repeated building of a large number of hardware testing environments in the prior art are avoided, and different models of graphics cards are tested in the case of building a testing environment once, thereby shortening the testing period, and accelerating a testing procedure.
- As an optional solution, the running
unit 904 includes: - 1) a first determining module, configured to determine whether a capability implemented by an API that is invoked when the 3D engine is run is the capability that is supported by the graphics card and recorded by the hardware capability parameter.
- For example, using the graphics card A to be simulated as an example, the 3D engine invokes APIs: API_1, API_2, and API_3, to implement the capability M, the capability N, and the capability P, to determine whether the capability that needs to be implemented by the 3D engine is the capability supported by the graphics card and recorded by the hardware capability parameter.
- Optionally, if the capability implemented by the API is the capability that is supported by the graphics card and recorded by the hardware capability parameter, it is determined that the result of running the 3D engine is normal.
- For example, using the graphics card A to be simulated as an example, the 3D engine invokes APIs: API_1, API_2, and API_3, to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability). It can be known from the Caps database of graphics cards that the graphics card A to be simulated can support the foregoing capabilities, and it is determined that the result of running the 3D engine is normal.
- Optionally, if the capability implemented by the API is not the capability that is supported by the graphics card and recorded by the hardware capability parameter, it is determined that the result of running the 3D engine is error.
- For example, using the graphics card A to be simulated as an example, the 3D engine invokes APIs: API_1, API_2, and API_3, to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192) the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability). It can be known from the Caps database of graphics cards that the graphics card A to be simulated can support the capability M and the capability N, but does not support the capability P, and it is determined that the result of running the 3D engine is error.
- In this embodiment provided by this application, it is determined whether a capability implemented by an API invoked by a 3D engine is a capability supported by a graphics card to be simulated, to obtain whether a result of running the 3D engine is normal, thereby obtaining a result of testing the compatibility of the 3D engine, so that a tester can obtain, by only simulating different models of graphics cards in a physical configuration environment and comparing capabilities, the result of testing the compatibility of the 3D engine, thereby saving a lot of time in building an environment, and shortening a testing period.
- As an optional solution, the determining
unit 906 includes: - 1) a second determining module, configured to determine whether the result of running the 3D engine is normal; and determine, if the result of running the 3D engine is normal, that the 3D engine is compatible with the graphics card to be simulated; or determine, if the result of running the 3D engine is error, that the 3D engine is incompatible with the graphics card to be simulated.
- For example, using the graphics card A to be simulated as an example, if it can be known from the Caps database of graphics cards that, the graphics card A to be simulated can support the corresponding capability M, capability N, and capability P when the 3D engine invokes the APIs, it is determined that the result of running the 3D engine is normal, and further, a test result indicating that the 3D engine is compatible with the graphics card A to be simulated may be obtained; however, if it is determined that the result of running the 3D engine is error, a test result indicating that the 3D engine is incompatible with the graphics card A to be simulated is obtained.
- As an optional solution, the first determining module includes: a returning submodule and a first determining submodule.
- 1) The returning submodule is configured to return, by using a preset API, when the 3D engine is run, if it is determined that the API needs to be invoked currently, the capability implemented by the invoked API.
- Optionally, in this embodiment, in an algorithm corresponding to the 3D engine, a function corresponding to the foregoing API for returning the implemented capability may be preset before or in the function corresponding to the foregoing preset API that needs to be invoked, so that before the function corresponding to the foregoing API that needs to be invoked is invoked, the foregoing preset function corresponding to the API is invoked first to return the capability implemented by the invoked API. For example, using the graphics card A to be simulated as an example, the 3D engine currently needs to invoke APIs: API_1, API_2, and API_3, to implement the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability), and information about the capability M, the capability N, and the capability P implemented by the APIs currently invoked by the 3D engine may be returned by the using the preset API.
- It is further noted that, under the premise of making no modification to the tested 3D engine, the API invoked when the 3D engine is run is remolded by using the preset API, the capability implemented by the API invoked by the 3D engine is learned, and the foregoing capability is returned.
- 2) The first determining submodule is configured to determine whether the returned capability is the capability that is supported by the graphics card and recorded by the hardware capability parameter.
- For example, using the graphics card A to be simulated as an example, capabilities that correspond to the APIs currently invoked by the 3D engine and are returned by using the preset API are the capability M (for example, the maximum texture width (MaxTextureWidth) is 8192), the capability N (the projected density profile (D3DTEXTURECAPS_PROJECTED) capability), and the capability P (for example, the α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability), and it is determined whether the foregoing capabilities are capabilities supported by the graphics card A to be simulated recorded by the hardware capability parameter.
- In this embodiment provided by this application, from the perspective of a third party, a capability implemented by an API that currently needs to be invoked when a 3D engine is run is learned by using a preset API, and is further compared with a capability that is supported by a graphics card and recorded by a hardware capability parameter, and whether the 3D engine is compatible with the graphics card to be simulated is obtained, thereby acquiring invoking information completely from the third party when the 3D engine is run, and automatically testing the compatibility of the graphics card with the 3D engine.
- As an optional solution, as shown in
FIG. 10 , the apparatus for testing the compatibility of a 3D engine in this embodiment further includes: - 1) an
output unit 1002, configured to: after it is determined, according to the result of running the 3D engine, whether the 3D engine is compatible with the graphics card to be simulated, output information for identifying the API and information about the capability if the result of running the 3D engine is error. - Optionally, in this embodiment, after it is determined whether the 3D engine is compatible with the graphics card to be simulated, the root cause of a compatibility issue may be further located and output, for example, information for indicating incompatibility may include, but not limited to, an API and a capability in the Caps database.
- Optionally, as shown in
FIG. 6 , Bench3D is a tool for testing the capability and the compatibility of the 3D engine in this embodiment, where a test result output by the Bench3D includes: a DXDebug view, and information about an identified API and information about a capability in the Caps database when the result of running the 3D engine is error can be known from the view. For example, the foregoing information may include: a sequence number (for example, 23850), a time (for example, 20:11:45:577), and Debuginfo (for example, Direct3D9: Texture in a virtual device D3DFMT_R16F format does not support D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING), and the foregoing example is merely exemplary, which is not limited in this application. - For example, using the graphics card A to be simulated as an example, if it can be known from the Caps database of graphics cards that the graphics card A to be simulated does not support the corresponding capability M when the 3D engine invokes the API, it is determined that the result of running the 3D engine is error, and further the information about the identified API and the information about the capability in the Caps database are output. For example, the output information may include the following information: a sequence number is 23850, a time is 20:11:45:577, and Debuginfo is Direct3D9: Texture in a virtual device D3DFMT_R16F format does not support D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING.
- In this embodiment provided by this application, when a result of running a 3D engine is error, information for identifying an API and information about a capability are output, thereby solving the problem in the prior art that a test result only feeds back the description for a phenomenon, accurately locating the root cause of a compatibility issue, and making it convenient for a developer to quickly fix the problem.
- As an optional solution, as shown in
FIG. 11 , the apparatus for testing the compatibility of a 3D engine in this embodiment further includes: - 1) an
establishing unit 1102, configured to establish a graphics card information database before the hardware capability parameter of the graphics card to be simulated is acquired, where the graphics card information database records models and hardware capability parameters of multiple graphics cards including the graphics card to be simulated. - Optionally, in this embodiment, the graphics card information database records models and hardware capability parameters of multiple graphics cards including the graphics card to be simulated.
- For example, before the hardware capability parameter of the graphics card to be simulated is acquired, a large amount of graphics card information is collected, and a relatively complete graphics card information database (the Caps database of graphics cards) is established. As shown in
FIG. 7 , different models of graphics cards are included, for example,ATI Radeon HD 3800 Series,NVDIA GEForce 9500 GT, and RADEON X700 SE; different graphics card attributes and values corresponding to the attributes are included, for example, a graphics card A to be simulated whose model isATI Radeon HD 3800 Series is used as an example, and the graphics card A to be simulated includes the following information: a value of a maximum texture width (MaxTextureWidth) is 8192, and a value of a maximum texture height (MaxTextureHeight) is 8192; and in addition, whether the graphics card of this model supports some capabilities is further included, for example, the graphics card A to be simulated whose model isATI Radeon HD 3800 Series is still used as an example, and the graphics card A to be simulated can support the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and can also support the projected density profile (D3DTEXTURECAPS_PROJECTED) capability, but the graphics card of this model does not support the α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability. - 2) The acquiring
unit 902 includes: an acquiringmodule 1104, configured to acquire the hardware capability parameter of the graphics card to be simulated from the graphics card information database. - Optionally, in this embodiment, the hardware capability parameter records the capability supported by the graphics card, where the capability supported by the graphics card may include, but not limited to, the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and the projected density profile (D3DTEXTURECAPS_PROJECTED) capability.
- For example, using the graphics card A to be simulated as an example, a hardware capability parameter of the graphics card A to be simulated is acquired from the graphics card information database (the Caps database of graphics cards), for example, the maximum texture width (MaxTextureWidth) is 8192, and the maximum texture height (MaxTextureHeight) is 8192. In addition, it can be further known from the Caps database of graphics cards that, the graphics card can support the cube texture (D3DTEXTURECAPS_CUBEMAP) capability, and can also support the projected density profile (D3DTEXTURECAPS_PROJECTED) capability, but the graphics card does not support the α palette (D3DTEXTURECAPS_ALPHAPALETTE) capability.
- In this embodiment provided by this application, a graphics card information database is established, and a hardware capability parameter of a graphics card to be simulated is acquired from the established graphics card information database, to implement simulation of a virtual graphics card, and further complete testing of a 3D engine without repeatedly building a large number of hardware testing environments, thereby saving a lot of testing costs, and shortening a testing period.
- The sequence numbers of the foregoing embodiments of the present invention are merely for description, and do not represent the superiority or inferiority of the embodiments.
- In the foregoing embodiments of the present invention, the description of each of the embodiments has respective focuses. For a part that is not described in detail in a certain embodiment, reference may be made to related descriptions in other embodiments.
- In the several embodiments provided by this application, it should be understood that the disclosed client may be implemented in other manners. The described apparatus embodiments are merely exemplary. For example, the unit division is merely logical function division and may be other division in actual implementation. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not performed. In addition, the displayed or discussed mutual couplings or direct couplings or communication connections may be implemented through some interfaces. The indirect couplings or communication connections between the units or modules may be implemented in electronic or other forms.
- The units described as separate parts may or may not be physically separate, and the parts displayed as units may or may not be physical units, may be located in one position, or may be distributed on multiple network units. Some or all of the units may be selected to achieve the objectives of the solutions of the embodiments according to actual needs.
- In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each of the units may exist alone physically, or two or more units may be integrated into one unit. The integrated unit may be implemented in a form of hardware, or may be implemented in a form of a software functional unit.
- When the integrated unit is implemented in a form of a software functional unit and sold or used as an independent product, the integrated unit may be stored in a computer-readable storage medium. Based on such an understanding, the technical solutions of the present disclosure essentially, or the part contributing to the prior art, or all or some of the technical solutions may be implemented in a form of a software product. The computer software product is stored in a storage medium and includes several instructions for instructing a computer device (which may be a PC, a server, a network device, or the like) to perform all or some of the steps of the methods described in the embodiments of the present invention. The foregoing storage medium includes: any medium that can store program code, such as a USB flash drive, a removable hard disk, a ROM, a RAM, a magnetic disk, or an optical disc.
- The foregoing descriptions are merely preferred implementation manners of the present disclosure. It should be noted that, a person of ordinary skill in the art may further make various improvements and refinements without departing from the principle of the present disclosure. All such improvements and refinements shall fall within the protection scope of the present disclosure.
Claims (12)
Applications Claiming Priority (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
CN201410048079.5A CN104598351B (en) | 2014-02-11 | 2014-02-11 | The method of testing of 3D engine compatibility and device |
CN201410048079 | 2014-02-11 | ||
CN201410048079.5 | 2014-02-11 | ||
PCT/CN2015/072786 WO2015120797A1 (en) | 2014-02-11 | 2015-02-11 | Method and apparatus for testing compatibility of 3d engine |
Publications (2)
Publication Number | Publication Date |
---|---|
US20170091058A1 true US20170091058A1 (en) | 2017-03-30 |
US10372571B2 US10372571B2 (en) | 2019-08-06 |
Family
ID=53124164
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US15/117,029 Active 2035-08-09 US10372571B2 (en) | 2014-02-11 | 2015-02-11 | Method and apparatus for testing compatibility of 3D engine |
Country Status (3)
Country | Link |
---|---|
US (1) | US10372571B2 (en) |
CN (1) | CN104598351B (en) |
WO (1) | WO2015120797A1 (en) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN108959082A (en) * | 2018-06-27 | 2018-12-07 | 郑州云海信息技术有限公司 | A kind of the hardware compatibility test method and system of Openstack |
Families Citing this family (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN107885653B (en) * | 2016-09-30 | 2020-12-04 | 腾讯科技(深圳)有限公司 | Data processing system, method and device |
CN108073508B (en) * | 2016-11-18 | 2021-03-19 | 腾讯科技(深圳)有限公司 | Compatibility detection method and device |
CN107454240B (en) * | 2017-09-18 | 2020-10-02 | 上海研端信息科技有限公司 | Installation method of detection system, detection system and detection method of camera |
Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8301415B2 (en) * | 2009-10-28 | 2012-10-30 | Hong Fu Jin Precision Industry (Shenzhen) Co., Ltd. | System and method for testing graphics card |
US8732729B2 (en) * | 2008-12-30 | 2014-05-20 | Stmicroelectronics R&D (Shanghai) Co., Ltd. | Unified driving method and unified driver apparatus |
Family Cites Families (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8390639B2 (en) | 2001-01-30 | 2013-03-05 | Qualcomm Incorporated | Method and apparatus for rotating an image on a display |
US7113194B2 (en) * | 2001-01-30 | 2006-09-26 | Ati International Srl | Method and apparatus for rotating an image on a display |
US9305465B2 (en) * | 2011-03-07 | 2016-04-05 | Avaya, Inc. | Method and system for topic based virtual environments and expertise detection |
CN102436363B (en) * | 2011-08-30 | 2014-09-17 | 北京数码大方科技股份有限公司 | Method and device for automatically setting parameters of video card |
-
2014
- 2014-02-11 CN CN201410048079.5A patent/CN104598351B/en active Active
-
2015
- 2015-02-11 WO PCT/CN2015/072786 patent/WO2015120797A1/en active Application Filing
- 2015-02-11 US US15/117,029 patent/US10372571B2/en active Active
Patent Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8732729B2 (en) * | 2008-12-30 | 2014-05-20 | Stmicroelectronics R&D (Shanghai) Co., Ltd. | Unified driving method and unified driver apparatus |
US8301415B2 (en) * | 2009-10-28 | 2012-10-30 | Hong Fu Jin Precision Industry (Shenzhen) Co., Ltd. | System and method for testing graphics card |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN108959082A (en) * | 2018-06-27 | 2018-12-07 | 郑州云海信息技术有限公司 | A kind of the hardware compatibility test method and system of Openstack |
Also Published As
Publication number | Publication date |
---|---|
CN104598351B (en) | 2016-10-05 |
CN104598351A (en) | 2015-05-06 |
US10372571B2 (en) | 2019-08-06 |
WO2015120797A1 (en) | 2015-08-20 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
CN109816762B (en) | Image rendering method and device, electronic equipment and storage medium | |
JP6400720B2 (en) | View-independent color equalization 3D scene texture processing | |
US9928645B2 (en) | Raster-based mesh decimation | |
CN111815755A (en) | Method and device for determining shielded area of virtual object and terminal equipment | |
US20150356770A1 (en) | Street view map display method and system | |
CN107659455B (en) | Method, storage medium, device and system for Mock data of iOS (internet operating system) end | |
US10372571B2 (en) | Method and apparatus for testing compatibility of 3D engine | |
CN111191311A (en) | Efficient image examination method, efficient image examination system, terminal and readable storage medium | |
CN109756766B (en) | Virtual gift display method, storage medium, electronic device and system of live broadcast platform | |
US9135749B2 (en) | Method and apparatus for processing three-dimensional model data | |
CN107704568A (en) | Method and device for adding test data | |
CN111290960B (en) | Fluency detection method and device for application program, terminal and storage medium | |
CN108171778A (en) | It is a kind of to visualize processing, back method, device and the storage medium that data are presented | |
CN116206038A (en) | Rendering method, rendering device, electronic equipment and storage medium | |
CN108986205B (en) | Method, device, equipment and storage medium for drawing voxel model | |
CN109461198B (en) | Grid model processing method and device | |
CN113808246B (en) | Method and device for generating map, computer equipment and computer readable storage medium | |
CN113470124B (en) | Training method and device for special effect model, and special effect generation method and device | |
CN113244625B (en) | Editing method and device for game topography data, storage medium and electronic device | |
CN115079820A (en) | Virtual scene dynamic switching method, system, storage medium and equipment | |
US10713836B2 (en) | Simulating lenses | |
KR20210085817A (en) | System, method and computer program for creating BOM list | |
WO2023179091A1 (en) | Three-dimensional model rendering method and apparatus, and device, storage medium and program product | |
CN116152446B (en) | Geological model subdivision method, device, terminal and medium based on UE4 | |
US10382878B2 (en) | Sound reproducing method, apparatus and non-transitory computer readable storage medium thereof |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: TENCENT TECHNOLOGY (SHENZHEN) COMPANY LIMITED, CHI Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:CAO, WENSHENG;JING, YANQING;LI, JUN;AND OTHERS;SIGNING DATES FROM 20160518 TO 20160520;REEL/FRAME:043976/0100 |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: DOCKETED NEW CASE - READY FOR EXAMINATION |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: NOTICE OF ALLOWANCE MAILED -- APPLICATION RECEIVED IN OFFICE OF PUBLICATIONS |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: PUBLICATIONS -- ISSUE FEE PAYMENT VERIFIED |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
MAFP | Maintenance fee payment |
Free format text: PAYMENT OF MAINTENANCE FEE, 4TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1551); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY Year of fee payment: 4 |