Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Messages - Stefan

Pages: [1] 2 3 ... 160
1
3D-Tech News Around The Web / CUDA-Z 0.10.251 released
« on: August 02, 2015, 08:15:20 AM »
CUDA-Z 0.10.251 is out at 2015.07.31.

What's new
----------
 * Use CUDA run-time 6.5;
* Add export to clipboard;
* 64-bit integer performance test;
* Improved missing CUDA error messages;
* Support of new hardware;
* Separate 32 and 64-bit builds for Windows and Linux platforms;
* Minor fixes and improvements



2
3D-Tech News Around The Web / Microsoft Windows 10 SDK RTM
« on: July 31, 2015, 08:46:55 PM »
Windows 10 SDK RTM

Last week saw the release of the final version of VS 2015, and yesterday was the release of the Windows 10 SDK (build 10240). The Windows 10 SDK is installed via VS 2015 Custom install options or as a standalone installer. This includes DirectXMath 3.07, Direct3D 11.3, Direct3D 12.0, DXGI 1.4, Direct2D/DirectWrite 1.3, and XAudio 2.9.

Be sure to read this blog post about configuring your VS 2015 projects to use the 10240 build of the Windows 10 SDK--remember that Windows desktop applications with VS 2015 default to building with the Windows 8.1 SDK Spring 2015 release.

GitHub:
All of my open source project have new releases to support VS 2015 and Windows 10 SDK RTM: DirectXTK, DirectXTex, DirectXMesh, UVAtlas, Effects11, and DXUT11.

Universal Windows apps:
The official samples for UWP are on GitHub.

Direct3D 12:
The samples for Windows desktop development using Direct3D 12 are on GitHub.

XInput:
For UWP, you can continue to use the XInput 1.4 API but need to change from linking to xinput.lib to xinputuap.lib. Alternatively, you can make use of the GamePad class in DirectX Tool Kit which uses the new Windows.Gaming.Input API. See XInput and Windows 8.

XAudio:
With the Windows 10 SDK, if you are linking with xaudio2.lib you are linking against XAudio 2.9 and should build your application using _WIN32_WINNT=0x0A00. If you want to use XAudio 2.8 with the Windows 10 SDK, you need to set _WIN32_WINNT=0x0602 or _WIN32_WINNT=0x0603 and link against xaudio2_8.lib. See XAudio2 and Windows 8 for more details.

VS 2013 Users:
As with the past few releases, the Windows 10 SDK only integrates with the latest Visual Studio, VS 2015. You can use the Windows 10 SDK with VS 2013 by using the props attached per this Visual C+ Team Blog.     

Windows10SDKVS13.zip 

3
Using OpenCL™ 2.0 Read-Write Images

While Image convolution is not as effective with the new Read-Write images functionality, any image processing technique that needs be done in place may benefit from the Read-Write images. One example of a process that could be used effectively is image composition.
In OpenCL 1.2 and earlier, images were qualified with the “__read_only” and __write_only” qualifiers. In the OpenCL 2.0, images can be qualified with a “__read_write” qualifier, and copy the output to the input buffer. This reduces the number of resources that are needed.
Since OpenCL 1.2 images are either read_only or write_image. Performing an in-place modifications of an image requires treating the image as a buffer and operating on the buffer (see cl_khr_image2d_from_buffer: https://software.intel.com/en-us/articles/using-image2d-from-buffer-extension.
The current solution is to treat the images as buffers, and manipulate the buffers. Treating 2d images as buffers many not be a free operation and prevents clamping and filtering abilities available in read_images from being used. As a result, it may be more desirable to use read_write qualified images.

4
3D-Tech News Around The Web / Microsoft Direct3D 12 programming guide
« on: July 30, 2015, 07:39:30 PM »
[Some information relates to pre-released product which may be substantially modified before it's commercially released. Microsoft makes no warranties, express or implied, with respect to the information provided here.]

The Direct3D 12 programming guide contains information about how to use the Direct3D 12 programmable pipeline to create a customized graphics engine.

6
3D-Tech News Around The Web / TechPowerUp GPU-Z v0.8.5
« on: July 30, 2015, 03:59:49 PM »
GPU-Z is a lightweight utility designed to provide you with all information about your graphics card and GPU.Version History0.8.5
  • Fixed Windows 10 detection
  • Fixed CUDA detection in Windows 10
  • Added GPU voltage monitoring for AMD Fiji
  • Added memory controller load monitoring for AMD Sea Islands, Volcanic Islands, Pirate Islands
  • Board Id moved into BIOS version tooltip
  • Validation Id now displayed in GPU-Z window title
  • Revision Id of recent AMD GPUs will now be displayed
  • Added support for NVIDIA GeForce GTX 970M & 980M (GM204-B), GeForce 940M, 930M
  • Added support for Intel Atom x7-Z8700, Celeron N3150
  • Added support for AMD R9 370, R9 370X, R9 380, R9 390, R9 390X, R9 Fury, A8-7100

7
English forum / Re: 250 demos converted and counting...
« on: July 30, 2015, 05:02:39 AM »
Maybe the Python part could be CUDA accelerated?
Run GLSL Hacker to open "sao miguel" and click "Python immediate mode box" and button "Execute!". Ok? But dunno how...

Actually i was thinking about "PYCUDA".



Shadertoy celebrates Win 10 launch it's own way


8
Under XP this driver still nukes Julia, under Vista and Windows 10 it's fixed as aforementioned.


9
Windows 10, Windows 8.1, Windows 7 & Windows XP Game Ready Driver Released


The new NVIDIA GeForce GTX Game Ready drivers for Windows 10, Windows 8.1 and Windows 7 are now available to download from GeForce Experience and GeForce.com. Featuring launch-day support for Windows 10, tweaks and optimizations for games running on other operating systems, and new SLI profiles, our latest Game Ready driver is a recommended update for all GeForce GTX gamers.

Game Ready For Windows 10

The GeForce Game Ready program delivers updated drivers for your favorite titles before their launch, ensuring the best possible experience the second you start playing. Today, we’re delivering Game Ready support for all games played on the newly-released Windows 10.
That means you can enjoy Dark Souls II at 4K with Dynamic Super Resolution, Witcher 3 with HairWorks and SLI, Battlefield Hardline with performance-enhancing Multi-Frame Sampled Anti-Aliasing, Grand Theft Auto V with TXAA Anti-Aliasing and PCSS shadows, Metal Gear Solid: Ground Zeroes with GameStream, and League of Legends with G-SYNC and ShadowPlay. If a feature is on our list, it’s supported under Windows 10 with the new Game Ready driver.
For gamers, Windows 10’s DirectX 12 is the focus of attention, enabling the creation of new, more advanced visual effects, and higher performance in DirectX 12-optimized games. With the Game Ready driver, Maxwell and Kepler GPUs offer complete support for DirectX 12. Fermi-based GPUs will gain support for DirectX 12 titles later this year, around the arrival of the first wave of DirectX 12 content. And of course, we’ll be ready and waiting with Game Ready drivers to add performance optimizations, SLI profiles, and much, much more.
For further details about GeForce GTX gaming on Windows 10 and DirectX 12 check out our Windows 10 launch article.
New SLI Profiles
Upgrade your rig with a second NVIDIA GeForce GTX GPU to activate SLI, the multi-GPU technology of choice for gamers. With intelligent scaling and industry-leading multi-GPU anti-stutter technology, NVIDIA SLI is the smoothest, most effective way of increasing frame rates by up to 2x.
In the new GeForce Game Ready drivers, the following SLI profiles have been introduced:
 
  • Batman: Arkham Knight - Added SLI profile (previously deployed via GeForce Experience)
  • Hai Zhaqn Shi Jie - Added SLI profile
  • Killing Floor 2 - Added SLI profile
  • Metro: Last Light - Updated SLI profile
  • Motocross - Added SLI profile
  • MotoGP 15 - Added SLI profile
  • Squadron 42: Star Citizen - Updated SLI profile
  • Total War: Arena - Updated SLI profile
GeForce Game Ready Driver: Download Now
You can download the new GeForce Game Ready drivers through GeForce Experience, our free, essential, game and system-enhancing application, or from the GeForce.com Drivers page.
If you experience any technical issues with the new Game Ready drivers, please post a detailed report on the GeForce.com Driver Feedback Forum where our Customer Care team can better assist you. Windows XP, Windows 7, and Windows 8.1 issues should be reported here, and Windows 10 issues here.

10
Quote from: LaptopVideo2Go.com
NVidia has now released the full downloads from their servers:
Windows 10 64-bit
Desktop GeForce GPUs:
http://international.download.nvidia.com/Windows/353.62/353.62-desktop-win10-64bit-international.hf.exe
Notebook GeForce GPUs:
http://international.download.nvidia.com/Windows/353.62/353.62-notebook-win10-64bit-international.hf.exe


Windows 10 32-bit
Desktop GeForce GPUs:
http://international.download.nvidia.com/Windows/353.62/353.62-desktop-win10-32bit-international.hf.exe
Notebook GeForce GPUs:
http://international.download.nvidia.com/Windows/353.62/353.62-notebook-win10-32bit-international.hf.exe
 

No changelog yet, but it loves Julia again (reminder: select NVIDIA OpenCL for testing)


11
English forum / Re: 250 demos converted and counting...
« on: July 29, 2015, 02:15:57 PM »

My GTX 780 Ti Classified is faster than your 750 Ti but I got only 29 fps running Win 8.1 x64 with my CPU i5-2500K@4.5GHz because GLSL Hacker seems be not good optimized for mega polygons - CPU gets bottlenecked.

I think that my videocard gets ~95 fps at ~95-99% GPU usage without CPU bottenecked.

Maybe the Python part could be CUDA accelerated?

Can you post a screenshot with your GPU? I wonder if you see more textures with more video RAM.

12
English forum / Re: 250 demos converted and counting...
« on: July 28, 2015, 10:06:11 PM »
Download code for following demos from >>>here<<<
And the models from the original location.

San Miguel

Triangles: 7,880,512
Vertices: 6,720,106

GLSL Hacker allocates 2.7 GB RAM with NVIDiA or 4.4 GB with Intel GPU for that model.
It forgets some textures while rendering.





Dabrovic Sponza




Sibenik


13
3D-Tech News Around The Web / MojoCorp Shadergen
« on: July 28, 2015, 02:48:34 PM »
Quote
ShaderGen is a tool that automatically generates OpenGL Shading Language shaders that duplicate fixed function OpenGL behavior.

 Download
 ShaderGen 3.3.0 Windows
 ShaderGen 3.3.0 Mac OS X Intel 64bit DMG
 ShaderGen 3.3.0 Linux Ubuntu x64 

Creates complex vertex shader and a small pixel shader.
Tried to convert to GLSL Hacker, it compiles successfully, but only black screen.

Code: [Select]
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?><glsl_hacker>   
  <window name="win3d01" title="MojoCorp Shadergen"
          width="800" height="480"
          gl_version_major="2" gl_version_minor="1" />
<gpu_program name="shadertoy_prog" >    <raw_data_vs><![CDATA[     
/*******************************************************
*  Fixed.vert Fixed Function Equivalent Vertex Shader  *
*   Automatically Generated by 3Dlabs GLSL ShaderGen   *
*             http://developer.3dlabs.com              *
*******************************************************/
vec4 Ambient;
vec4 Diffuse;
vec4 Specular;


void pointLight(in int i, in vec3 normal, in vec3 eye, in vec3 ecPosition3)
{
   float nDotVP;       // normal . light direction
   float nDotHV;       // normal . light half vector
   float pf;           // power factor
   float attenuation;  // computed attenuation factor
   float d;            // distance from surface to light source
   vec3  VP;           // direction from surface to light position
   vec3  halfVector;   // direction of maximum highlights

   // Compute vector from surface to light position
   VP = vec3 (gl_LightSource[i].position) - ecPosition3;

   // Compute distance between surface and light position
   d = length(VP);

   // Normalize the vector from surface to light position
   VP = normalize(VP);

   // Compute attenuation
   attenuation = 1.0 / (gl_LightSource[i].constantAttenuation +
                        gl_LightSource[i].linearAttenuation * d +
                        gl_LightSource[i].quadraticAttenuation * d * d);

   halfVector = normalize(VP + eye);

   nDotVP = max(0.0, dot(normal, VP));
   nDotHV = max(0.0, dot(normal, halfVector));

   if (nDotVP == 0.0)
   {
       pf = 0.0;
   }
   else
   {
       pf = pow(nDotHV, gl_FrontMaterial.shininess);

   }
   Ambient  += gl_LightSource[i].ambient * attenuation;
   Diffuse  += gl_LightSource[i].diffuse * nDotVP * attenuation;
   Specular += gl_LightSource[i].specular * pf * attenuation;
}

void directionalLight(in int i, in vec3 normal)
{
   float nDotVP;         // normal . light direction
   float nDotHV;         // normal . light half vector
   float pf;             // power factor

   nDotVP = max(0.0, dot(normal, normalize(vec3 (gl_LightSource[i].position))));
   nDotHV = max(0.0, dot(normal, vec3 (gl_LightSource[i].halfVector)));

   if (nDotVP == 0.0)
   {
       pf = 0.0;
   }
   else
   {
       pf = pow(nDotHV, gl_FrontMaterial.shininess);

   }
   Ambient  += gl_LightSource[i].ambient;
   Diffuse  += gl_LightSource[i].diffuse * nDotVP;
   Specular += gl_LightSource[i].specular * pf;
}

vec3 fnormal(void)
{
    //Compute the normal
    vec3 normal = gl_NormalMatrix * gl_Normal;
    normal = normalize(normal);
    return normal;
}

void ftexgen(in vec3 normal, in vec4 ecPosition)
{

    gl_TexCoord[0] = gl_MultiTexCoord0;
}

void flight(in vec3 normal, in vec4 ecPosition, float alphaFade)
{
    vec4 color;
    vec3 ecPosition3;
    vec3 eye;

    ecPosition3 = (vec3 (ecPosition)) / ecPosition.w;
    eye = vec3 (0.0, 0.0, 1.0);

    // Clear the light intensity accumulators
    Ambient  = vec4 (0.0);
    Diffuse  = vec4 (0.0);
    Specular = vec4 (0.0);

    pointLight(0, normal, eye, ecPosition3);

    pointLight(1, normal, eye, ecPosition3);

    directionalLight(2, normal);

    color = gl_FrontLightModelProduct.sceneColor +
            Ambient  * gl_FrontMaterial.ambient +
            Diffuse  * gl_FrontMaterial.diffuse;
    color += Specular * gl_FrontMaterial.specular;
    color = clamp( color, 0.0, 1.0 );
    gl_FrontColor = color;

    gl_FrontColor.a *= alphaFade;
}


void main (void)
{
    vec3  transformedNormal;
    float alphaFade = 1.0;

    // Eye-coordinate position of vertex, needed in various calculations
    vec4 ecPosition = gl_ModelViewMatrix * gl_Vertex;

    // Do fixed functionality vertex transform
    gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex;
    transformedNormal = fnormal();
    flight(transformedNormal, ecPosition, alphaFade);
    ftexgen(transformedNormal, ecPosition);
}  ]]></raw_data_vs>    <raw_data_ps><![CDATA[     

// https://github.com/mojocorp/ShaderGen

uniform vec3      iResolution;     // viewport resolution (in pixels)
uniform float     iGlobalTime;     // shader playback time (in seconds)
uniform vec4      iMouse;          // mouse pixel coords. xy: current (if MLB down), zw: click
uniform sampler2D iChannel0;
#define texUnit0 iChannel0

/*******************************************************
* Fixed.frag Fixed Function Equivalent Fragment Shader *
*   Automatically Generated by 3Dlabs GLSL ShaderGen   *
*             http://developer.3dlabs.com              *
*******************************************************/

void main (void)
{
    vec4 color;

    color = gl_Color;

    color *= texture2D(texUnit0, gl_TexCoord[0].xy);

    gl_FragColor = color;
}

]]></raw_data_ps></gpu_program>    <script name="init_scene" run_mode="INIT" >        <raw_data><![CDATA[   

app_dir = gh_utils.get_scripting_libs_dir()         
dofile(app_dir .. "lua/Moon3D_v2.lua")
moon3d.init(2, 1)
moon3d.graphics.vsync(0)
bmfont = moon3d.font.create("trebuchet_20px.fnt", "data/")
bmfont_texture = moon3d.font.getTexture(bmfont)
moon3d.madshaders.setBmFontData(bmfont, bmfont_texture)
winW, winH = moon3d.window.getSize()
quad = moon3d.graphics.newQuad(winW, winH)
shadertoy_prog = moon3d.graphics.getGpuProgram("shadertoy_prog")

tex0 = moon3d.image.load2d("./data/tex01.jpg")

moon3d.madshaders.resetBenchmarkData()
        ]]></raw_data>    </script>     <script name="update_scene" run_mode="FRAME" >        <raw_data><![CDATA[   
moon3d.startFrame(0, 0, 0, 1)
local global_time = moon3d.getTime()
moon3d.madshaders.updateBenchmarkData(global_time)
moon3d.camera.bindOrtho()
moon3d.graphics.bindGpuProgram(shadertoy_prog)
moon3d.madshaders.updateShadertoyCommonParams(shadertoy_prog, global_time)

moon3d.madshaders.setShadertoyTexture(shadertoy_prog, tex0, 0)

moon3d.graphics.draw(quad)
moon3d.madshaders.displayBenchmarkInfoV2("Shadertoy/MojoCorp Shadergen", global_time, 1, 1, 1, 1)
moon3d.endFrame()
        ]]></raw_data>    </script>     <script name="resize_scene" run_mode="SIZE" >        <raw_data><![CDATA[   
moon3d.window.resize()
winW, winH = moon3d.window.getSize()
moon3d.graphics.resizeQuad(quad, winW, winH)
        ]]></raw_data>    </script> </glsl_hacker>

14
Quadro & GeForce Mac OS X Driver Release 346.02.02f02

CUDA Application Support:
In order to run Mac OS X Applications that leverage the CUDA architecture of certain NVIDIA graphics cards, users will need to download and install the 7.0.52 driver for Mac located here.

New in Release 346.02.02f02:
  • Graphics driver updated for Mac OS X Yosemite 10.10.4 (14E46)
  • Contains performance improvements and bug fixes for a wide range of applications.
  • Includes NVIDIA Driver Manager preference pane.
  • Includes BETA support for iMac and MacBook Pro systems with NVIDIA graphics
Release Notes Archive:
This driver update is for Mac Pro 5,1 (2010), Mac Pro 4,1 (2009) and Mac Pro 3,1 (2008) users.

BETA support is for iMac 14,2 / 14,3 (2013), iMac 13,1 / 13,2 (2012) and MacBook Pro 11,3 (2013), MacBook Pro 10,1 (2012), and MacBook Pro 9,1 (2012) users.




15
Linux Display Driver - x86 NVIDIA Certified352.30July 28, 2015
Linux x64 (AMD64/EM64T) Display Driver NVIDIA Certified352.30July 28, 2015
Linux 32-bit ARM Display Driver NVIDIA Certified352.30July 28, 2015
Solaris Display Driver – x64/x86 NVIDIA Certified352.30July 28, 2015
FreeBSD Display Driver – x86 NVIDIA Certified352.30July 28, 2015
FreeBSD Display Driver – x64 NVIDIA Certified352.30July 28, 2015

 
  • Added support for the following GPU:
    • GeForce 910M
  • Fixed a bug that caused poor video post-processing performance in VDPAU when operating on a large number of video streams simultaneously.
  • Fixed a bug that could cause an Xid error when terminating a video playback application using the overlay presentation queue in VDPAU.
  • Updated nvidia-installer to avoid recursing too deeply into kernel source trees under /usr/lib/modules, mirroring an existing restriction on recursion under /lib/modules.
  • Fixed a rare deadlock condition when running applications that use OpenGL in multiple threads on a Quadro GPU.
  • Fixed a kernel memory leak that occurred when looping hardware - accelerated video decoding with VDPAU on Maxwell-based GPUs.
  • Fixed a bug that caused the X server to crash if a RandR 1.4 output provided by a Sink Output provider was selected as the primary output on X.Org xserver 1.17 and higher.
  • Fixed a bug that caused waiting on X Sync Fence objects in OpenGL to hang indefinitely in some cases.
  • Fixed a bug that prevented OpenGL from properly recovering from hardware errors or sync object waits that had timed out.

16
3D-Tech News Around The Web / AMD Catalyst 15.200.1065.0
« on: July 28, 2015, 11:52:05 AM »
Download from Microsoft

64 bit
32 bit

Supports Windows 7 - Windows 10, so it should survive the upgrade.
Comes with an Armada of INF files for any (?) AMD GPU.

Note: full OpenGL 4.5 support incl. GLSL 4.50 is scheduled for Catalyst 15.30x
 

17
3D-Tech News Around The Web / Microsoft DXGI Debug Device
« on: July 28, 2015, 10:45:41 AM »
Quote
DXGI Debug  Device

In my original post on using the debug layer, I mentioned several tricks for getting helpful behavior out of the Direct3D SDK debug layer for your applications. This best practice is demonstrated in my Visual C++ Game templates ...

18
3D-Tech News Around The Web / Microsoft Windows 10 update blocker
« on: July 28, 2015, 05:11:06 AM »
How to temporarily prevent a Windows or driver update from reinstalling in Windows 10 


 Symptoms

In Windows 10, your device is always kept up to date with the latest features and fixes. Updates and drivers are installed automatically, with no need to select which updates are needed or not needed. In rare cases, a specific driver or update might temporarily cause issues with your device, and in this case you will need a way to prevent the problematic driver or update from reinstalling automatically the next time Windows Updates are installed.ResolutionIf a driver or update you are being offered is causing system crashes or instability and Windows was operating correctly prior to that update, you can follow these instructions to prevent the unwanted driver or update from being installed: 

To uninstall the unwanted driver:
  • Launch the Device Manager with a right click on the lower left corner of the desktop and a left click on Device Manager.
  • Located the device driver with the problem driver installed, right click and choose Uninstall.
  • In the uninstall dialog, check the box to Delete the driver software for this device if available.
To uninstall an unwanted Windows Update:
  • Type “View Installed Updates” in the Search box and then click on View Installed Updates – Control Panel from the Search results.
  • To uninstall the unwanted update, select it from the list and then click Uninstall.
To temporarily prevent the driver or update from being reinstalled until a new driver or updated fix is available, a troubleshooter is available that provides a user interface for hiding and showing Windows Updates and drivers for Windows 10. You can obtain and run the "Show or hide updates" troubleshooter by downloading it from the Microsoft Download Center.

 The following file is available for download from the Microsoft Download Center:

DownloadDownload the "Show or hide updates" troubleshooter package now.

19
The Windows Error Codes document is a companion reference to the protocol specifications.

It  documents the common usage details for those HRESULT values, Win32 error codes, and NTSTATUS 
values that are referenced by specifications in the protocol documentation set.

The information in this specification is applicable to the following Microsoft products or supplemental 
software. References to product versions include released service packs. 

Note: Some of the information in this section is subject to change because it applies to an unreleased, 
preliminary version of the Windows Server operating system, and thus may differ from the final 
version of the server software when released. All behavior notes that pertain to the unreleased, 
preliminary version of the Windows Server operating system contain specific references to Windows 
Server 2016 Technical Preview as an aid to the reader. 

    Windows NT operating system 

    Windows 2000 operating system 

    Windows XP operating system 

    Windows Server 2003 operating system 

    Windows Vista operating system 

    Windows Server 2008 operating system 

    Windows 7 operating system 

    Windows Server 2008 R2 operating system 

    Windows 8 operating system 

    Windows Server 2012 operating system 

    Windows 8.1 operating system 

    Windows Server 2012 R2 operating system 

    Windows 10 operating system 

    Windows Server 2016 Technical Preview operating system

20
3D-Tech News Around The Web / Intel HD Graphics Driver v4256
« on: July 26, 2015, 02:07:42 PM »
v4256 at MS update - comes with a lotta fancy code names

Code: [Select]
DriverVer=07/17/2015,10.18.15.4256

[IntelGfx.NTamd64.10.0]
; HSW Classic
;; Merlin HSW
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B16103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B16103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B16103C

; SKL HW
;; Merlin_1.5 SKL
%iSKLDTGT2%      = iSKLD_w10, PCI\VEN_8086&DEV_1912&SUBSYS_2B5C103C
%iSKLDTGT15%      = iSKLD_w10, PCI\VEN_8086&DEV_1917&SUBSYS_2B5C103C
%iSKLDTGT1%      = iSKLD_w10, PCI\VEN_8086&DEV_1902&SUBSYS_2B5C103C


; HSW Classic
;Crusher-U/G
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B43103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B43103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B43103C

;Altis-U/G
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B3C103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B3C103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B3C103C

;Larkspur
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B04103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B04103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B04103C

;Laurel-G
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2AFA103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2AFA103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2AFA103C

;Layia
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B1B103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B1B103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B1B103C

;Lantana
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B1C103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B1C103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B1C103C

;Lilium-G
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B0F103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B0F103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B0F103C

;Lavender
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B0D103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B0D103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B0D103C

;Lavender-2G
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B21103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B21103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B21103C

;Laurel2
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B2B103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B2B103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B2B103C

;LumaU
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B12103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B12103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B12103C

; SKL HW
;; Bulldozer
%iSKLDTGT2%      = iSKLD_w10, PCI\VEN_8086&DEV_1912&SUBSYS_2B3E103C
%iSKLDTGT15%      = iSKLD_w10, PCI\VEN_8086&DEV_1917&SUBSYS_2B3E103C
%iSKLDTGT1%      = iSKLD_w10, PCI\VEN_8086&DEV_1902&SUBSYS_2B3E103C

;; Crane U/G
%iSKLDTGT2%      = iSKLD_w10, PCI\VEN_8086&DEV_1912&SUBSYS_2B45103C
%iSKLDTGT15%      = iSKLD_w10, PCI\VEN_8086&DEV_1917&SUBSYS_2B45103C
%iSKLDTGT1%      = iSKLD_w10, PCI\VEN_8086&DEV_1902&SUBSYS_2B45103C

;; Superion
%iSKLDTGT2%      = iSKLD_w10, PCI\VEN_8086&DEV_1912&SUBSYS_2B4C103C
%iSKLDTGT15%      = iSKLD_w10, PCI\VEN_8086&DEV_1917&SUBSYS_2B4C103C
%iSKLDTGT1%      = iSKLD_w10, PCI\VEN_8086&DEV_1902&SUBSYS_2B4C103C

; Camry AIO
%iSKLDTGT2%      = iSKLD_w10, PCI\VEN_8086&DEV_1912&SUBSYS_2B3D103C
%iSKLDTGT15%      = iSKLD_w10, PCI\VEN_8086&DEV_1917&SUBSYS_2B3D103C
%iSKLDTGT1%      = iSKLD_w10, PCI\VEN_8086&DEV_1902&SUBSYS_2B3D103C

; HSW Classic for Shave
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B5B103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B5B103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B5B103C
; HSW ULT for Prius
%iHSWGT1UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A06&SUBSYS_2B38103C
%iHSWGT2UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A16&SUBSYS_2B38103C
%iHSWGT3UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A26&SUBSYS_2B38103C

; BDW HW for Prius
%iBDWULTGT1%    = iBDWM_w10, PCI\VEN_8086&DEV_1606&SUBSYS_2B38103C
%iBDWULTGT2%    = iBDWM_w10, PCI\VEN_8086&DEV_1616&SUBSYS_2B38103C
%iBDWULTGT3%    = iBDWM_w10, PCI\VEN_8086&DEV_1626&SUBSYS_2B38103C
%iBDWULXGT2%    = iBDWM_w10, PCI\VEN_8086&DEV_161E&SUBSYS_2B38103C

;Skittles 1.0 HSW UMA and I+A
%iHSWGT2UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A16&SUBSYS_80BD103C
%iHSWGT2UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A16&SUBSYS_80BE103C

;Skittles 1.0 BDW UMA and I+A
%iBDWULTGT1%    = iBDWM_w10, PCI\VEN_8086&DEV_1606&SUBSYS_80BB103C
%iBDWULTGT1%    = iBDWM_w10, PCI\VEN_8086&DEV_1606&SUBSYS_80BC103C
%iBDWULTGT2%    = iBDWM_w10, PCI\VEN_8086&DEV_1616&SUBSYS_80BB103C
%iBDWULTGT2%    = iBDWM_w10, PCI\VEN_8086&DEV_1616&SUBSYS_80BC103C

;Skittles 1.1 SKL UMA and I+A

%iSKLULTGT2%     = iSKLD_w10, PCI\VEN_8086&DEV_1916&SUBSYS_8131103C
%iSKLULTGT2%     = iSKLD_w10, PCI\VEN_8086&DEV_1916&SUBSYS_8132103C

; HSW ULT
;Haribo1.1 HSW_UMA
%iHSWGT1UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A06&SUBSYS_80C3103C
%iHSWGT2UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A16&SUBSYS_80C3103C
%iHSWGT3UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A26&SUBSYS_80C3103C
%iHSWGT3UT28W%  = iHSWM_w10, PCI\VEN_8086&DEV_0A2E&SUBSYS_80C3103C
;Haribo1.1 HSW_AMD EXO
%iHSWGT1UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A06&SUBSYS_80C4103C
%iHSWGT2UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A16&SUBSYS_80C4103C
%iHSWGT3UT%        = iHSWM_w10, PCI\VEN_8086&DEV_0A26&SUBSYS_80C4103C
%iHSWGT3UT28W%  = iHSWM_w10, PCI\VEN_8086&DEV_0A2E&SUBSYS_80C4103C

; BDW HW
;Haribo1.1 BDW-U_UMA
%iBDWULTGT1%    = iBDWM_w10, PCI\VEN_8086&DEV_1606&SUBSYS_80C1103C
%iBDWULTGT2%    = iBDWM_w10, PCI\VEN_8086&DEV_1616&SUBSYS_80C1103C
;Haribo1.1 BDW-U_AMD EXO
%iBDWULTGT1%    = iBDWM_w10, PCI\VEN_8086&DEV_1606&SUBSYS_80C2103C
%iBDWULTGT2%    = iBDWM_w10, PCI\VEN_8086&DEV_1616&SUBSYS_80C2103C

; SKL HW
;Haribo1.1 SKL-U-GT2_UMA
%iSKLULTGT2%     = iSKLD_w10, PCI\VEN_8086&DEV_1916&SUBSYS_8135103C
;Haribo1.1 SKL-U-GT2_AMD EXO
%iSKLULTGT2%     = iSKLD_w10, PCI\VEN_8086&DEV_1916&SUBSYS_8136103C

; Dora5u

%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B34103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B34103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B34103C

; Dhoni

%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B1E103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B1E103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B1E103C

; Bachchan

%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B2A103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B2A103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B2A103C

; Dora6J

%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B39103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B39103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B39103C

; Dhoni6j

%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B30103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B30103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B30103C

; Memphis

%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2AF7103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2AF7103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2AF7103C

; Memphis2

%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B2C103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B2C103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B2C103C

; Kaili2

%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B36103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B36103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B36103C

; HSW Classic
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B36103C
%iHSWGT1M%        = iHSWM_w10, PCI\VEN_8086&DEV_0406&SUBSYS_2B36103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B36103C
%iHSWGT2M%        = iHSWM_w10, PCI\VEN_8086&DEV_0416&SUBSYS_2B36103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B36103C
%iHSWGT1D%       = iHSWD_w10, PCI\VEN_8086&DEV_0402&SUBSYS_2B2C103C
%iHSWGT1M%        = iHSWM_w10, PCI\VEN_8086&DEV_0406&SUBSYS_2B2C103C
%iHSWGT2D%       = iHSWD_w10, PCI\VEN_8086&DEV_0412&SUBSYS_2B2C103C
%iHSWGT2M%        = iHSWM_w10, PCI\VEN_8086&DEV_0416&SUBSYS_2B2C103C
%iHSWGT15D%        = iHSWD_w10, PCI\VEN_8086&DEV_041E&SUBSYS_2B2C103C

; BDW HW
%iBDWULTGT1%    = iBDWM_w10, PCI\VEN_8086&DEV_1606&SUBSYS_2B36103C
%iBDWULXGT1%    = iBDWM_w10, PCI\VEN_8086&DEV_160E&SUBSYS_2B36103C
%iBDWULTGT2%    = iBDWM_w10, PCI\VEN_8086&DEV_1616&SUBSYS_2B36103C
%iBDWULTGT3%    = iBDWM_w10, PCI\VEN_8086&DEV_1626&SUBSYS_2B36103C
%iBDWULXGT2%    = iBDWM_w10, PCI\VEN_8086&DEV_161E&SUBSYS_2B36103C
%iBDWHALOGT2%      = iBDWM_w10, PCI\VEN_8086&DEV_1612&SUBSYS_2B36103C
%iBDWGT2SRVR%      = iBDWM_w10, PCI\VEN_8086&DEV_161A&SUBSYS_2B36103C
%iBDWHALOGT3%       = iBDWM_w10, PCI\VEN_8086&DEV_1622&SUBSYS_2B36103C
%iBDWGT3SRVR%      = iBDWM_w10, PCI\VEN_8086&DEV_162A&SUBSYS_2B36103C
%iBDWULTGT328W%  = iBDWM_w10, PCI\VEN_8086&DEV_162B&SUBSYS_2B36103C
; SKL HW
%iSKLULTGT1%     = iSKLD_w10, PCI\VEN_8086&DEV_1906&SUBSYS_2B47103C
%iSKLULTGT15%    = iSKLD_w10, PCI\VEN_8086&DEV_1913&SUBSYS_2B47103C
%iSKLULTGT2%     = iSKLD_w10, PCI\VEN_8086&DEV_1916&SUBSYS_2B47103C
%iSKLULXGT1%     = iSKLD_w10, PCI\VEN_8086&DEV_190E&SUBSYS_2B47103C
%iSKLULXGT2%     = iSKLD_w10, PCI\VEN_8086&DEV_191E&SUBSYS_2B47103C
%iSKLDTGT2%      = iSKLD_w10, PCI\VEN_8086&DEV_1912&SUBSYS_2B47103C
%iSKLDTGT15%      = iSKLD_w10, PCI\VEN_8086&DEV_1917&SUBSYS_2B47103C
%iSKLDTGT1%      = iSKLD_w10, PCI\VEN_8086&DEV_1902&SUBSYS_2B47103C
%iSKLHaloGT2%    = iSKLD_w10, PCI\VEN_8086&DEV_191B&SUBSYS_2B47103C

%iSKLULTGT1%     = iSKLD_w10, PCI\VEN_8086&DEV_1906&SUBSYS_2B4B103C
%iSKLULTGT15%    = iSKLD_w10, PCI\VEN_8086&DEV_1913&SUBSYS_2B4B103C
%iSKLULTGT2%     = iSKLD_w10, PCI\VEN_8086&DEV_1916&SUBSYS_2B4B103C
%iSKLULXGT1%     = iSKLD_w10, PCI\VEN_8086&DEV_190E&SUBSYS_2B4B103C
%iSKLULXGT2%     = iSKLD_w10, PCI\VEN_8086&DEV_191E&SUBSYS_2B4B103C
%iSKLDTGT2%      = iSKLD_w10, PCI\VEN_8086&DEV_1912&SUBSYS_2B4B103C
%iSKLDTGT15%      = iSKLD_w10, PCI\VEN_8086&DEV_1917&SUBSYS_2B4B103C
%iSKLDTGT1%      = iSKLD_w10, PCI\VEN_8086&DEV_1902&SUBSYS_2B4B103C
%iSKLHaloGT2%    = iSKLD_w10, PCI\VEN_8086&DEV_191B&SUBSYS_2B4B103C

Pages: [1] 2 3 ... 160