question: control video card semi-directly ???

Archived from groups: alt.comp.periphs.videocards.nvidia (More info?)

Question: Is it possible to control the video graphics card directly?
In effect, I am asking whether there is an API for nvidea graphics card
so I can bypass DirectX and control the graphics card semi-directly.
I understand there is probably no way to literally access the card
directly, but some low-level API that maps to the card is fine for me.
I have already written a whole graphics engine, and don't want to
twist and torture it into the DirextX architecture, but am happy
to interface my code to the card.
6 answers Last reply
More about question control video card semi directly
  1. Archived from groups: alt.comp.periphs.videocards.nvidia (More info?)

    If you say you already made a graphics engine, do you mean you created
    something which draws, fills, colors and whatever else directly onto a
    bitmap in a generic way? I mean: without using any hardware acceleration and
    you are not using any hardware specific code?
    If so, you could 'simply' setup a directx drawing surface and access that as
    a linear piece of graphics memory.
    The only thing you need from directx is the directx engine and two simple 2d
    drawing surfaces (one for the currently visible frame and one for a
    'backbuffer' where you will paint the next frame to be displayed) since
    everything else is done by your driver...
    but if this is the case, it won't be a fast graphics engine compared to
    today's standard since you are not using any hardware acceleration at all.

    A better step would be to learn *some* directx 2d drawing, like drawing
    lines and filling areas and use that as the 'bottom layer' of your graphics
    engine.

    Just googled for a nice tutorial, this is the first one that came up and
    seems good enough:
    http://www.cse.unsw.edu.au/~atan164/ddraw_print.html

    Note that the initial setup needed for a proper working directx drawing
    surface is a pain in the ass if you've never done that before, but after
    that, drawing lines, boxes, bitmaps and such is peanuts. You could probably
    just replace your DrawLine/DrawBox functions (if you've made them) with a
    simpler directx command like Surface.DrawLine() and Surface.DrawBox() also
    Surface.

    Hope this helps.

    regards,
    Marcel


    "ann yard" <annyard1960@yahoo.com> schreef in bericht
    news:aqgce.290$Au1.155@tornado.socal.rr.com...
    > Question: Is it possible to control the video graphics card directly?
    > In effect, I am asking whether there is an API for nvidea graphics card
    > so I can bypass DirectX and control the graphics card semi-directly.
    > I understand there is probably no way to literally access the card
    > directly, but some low-level API that maps to the card is fine for me.
    > I have already written a whole graphics engine, and don't want to
    > twist and torture it into the DirextX architecture, but am happy
    > to interface my code to the card.
    >
    >
  2. Archived from groups: alt.comp.periphs.videocards.nvidia (More info?)

    In article <aqgce.290$Au1.155@tornado.socal.rr.com>, ann yard says...
    > Question: Is it possible to control the video graphics card directly?
    > In effect, I am asking whether there is an API for nvidea graphics card
    > so I can bypass DirectX and control the graphics card semi-directly.
    > I understand there is probably no way to literally access the card
    > directly, but some low-level API that maps to the card is fine for me.
    > I have already written a whole graphics engine, and don't want to
    > twist and torture it into the DirextX architecture, but am happy
    > to interface my code to the card.
    >
    Take a look at framebuffer drivers.


    --
    Conor

    "Of all the things I've lost, I miss my mind the most." O.Osbourne.
  3. Archived from groups: alt.comp.periphs.videocards.nvidia (More info?)

    Yes, I wrote the whole 3D simulation engine already.

    My code already does approximately what you suggest. But now I want
    to re-write the last stages of my application as pixel-shaders, to
    take advantage of the super-high-speed capabilities of video cards
    (GeForce 6800 Ultra now - then new/better cards every couple years.

    Therefore, I really do want to control the card, not just "BYPASS" it.
    Is this practical? If not, how does OpenGL get to the video card?
    Surely it is able to set and run video-card vertex and pixel shaders!


    "Marcel Overweel" <moverweel@hotmail.com> wrote in message news:42720a3f$0$151$e4fe514c@news.xs4all.nl...
    > If you say you already made a graphics engine, do you mean you created
    > something which draws, fills, colors and whatever else directly onto a
    > bitmap in a generic way? I mean: without using any hardware acceleration and
    > you are not using any hardware specific code?
    > If so, you could 'simply' setup a directx drawing surface and access that as
    > a linear piece of graphics memory.
    > The only thing you need from directx is the directx engine and two simple 2d
    > drawing surfaces (one for the currently visible frame and one for a
    > 'backbuffer' where you will paint the next frame to be displayed) since
    > everything else is done by your driver...
    > but if this is the case, it won't be a fast graphics engine compared to
    > today's standard since you are not using any hardware acceleration at all.
    >
    > A better step would be to learn *some* directx 2d drawing, like drawing
    > lines and filling areas and use that as the 'bottom layer' of your graphics
    > engine.
    >
    > Just googled for a nice tutorial, this is the first one that came up and
    > seems good enough:
    > http://www.cse.unsw.edu.au/~atan164/ddraw_print.html
    >
    > Note that the initial setup needed for a proper working directx drawing
    > surface is a pain in the ass if you've never done that before, but after
    > that, drawing lines, boxes, bitmaps and such is peanuts. You could probably
    > just replace your DrawLine/DrawBox functions (if you've made them) with a
    > simpler directx command like Surface.DrawLine() and Surface.DrawBox() also
    > Surface.
    >
    > Hope this helps.
    >
    > regards,
    > Marcel
    >
    >
    >
    > "ann yard" <annyard1960@yahoo.com> schreef in bericht
    > news:aqgce.290$Au1.155@tornado.socal.rr.com...
    > > Question: Is it possible to control the video graphics card directly?
    > > In effect, I am asking whether there is an API for nvidea graphics card
    > > so I can bypass DirectX and control the graphics card semi-directly.
    > > I understand there is probably no way to literally access the card
    > > directly, but some low-level API that maps to the card is fine for me.
    > > I have already written a whole graphics engine, and don't want to
    > > twist and torture it into the DirextX architecture, but am happy
    > > to interface my code to the card.
  4. Archived from groups: alt.comp.periphs.videocards.nvidia (More info?)

    Use the OpenGL Shading Language Shading extensions (glSlang ). They support
    vertex and fragment ( pixel ) shaders under OpenGL up to Shader Model 3.0.


    "ann yard" <annyard1960@yahoo.com> wrote in message
    news:yJAce.501$Au1.415@tornado.socal.rr.com...
    > Yes, I wrote the whole 3D simulation engine already.
    >
    > My code already does approximately what you suggest. But now I want
    > to re-write the last stages of my application as pixel-shaders, to
    > take advantage of the super-high-speed capabilities of video cards
    > (GeForce 6800 Ultra now - then new/better cards every couple years.
    >
    > Therefore, I really do want to control the card, not just "BYPASS" it.
    > Is this practical? If not, how does OpenGL get to the video card?
    > Surely it is able to set and run video-card vertex and pixel shaders!
    >
    >
    > "Marcel Overweel" <moverweel@hotmail.com> wrote in message
    > news:42720a3f$0$151$e4fe514c@news.xs4all.nl...
    >> If you say you already made a graphics engine, do you mean you created
    >> something which draws, fills, colors and whatever else directly onto a
    >> bitmap in a generic way? I mean: without using any hardware acceleration
    >> and
    >> you are not using any hardware specific code?
    >> If so, you could 'simply' setup a directx drawing surface and access that
    >> as
    >> a linear piece of graphics memory.
    >> The only thing you need from directx is the directx engine and two simple
    >> 2d
    >> drawing surfaces (one for the currently visible frame and one for a
    >> 'backbuffer' where you will paint the next frame to be displayed) since
    >> everything else is done by your driver...
    >> but if this is the case, it won't be a fast graphics engine compared to
    >> today's standard since you are not using any hardware acceleration at
    >> all.
    >>
    >> A better step would be to learn *some* directx 2d drawing, like drawing
    >> lines and filling areas and use that as the 'bottom layer' of your
    >> graphics
    >> engine.
    >>
    >> Just googled for a nice tutorial, this is the first one that came up and
    >> seems good enough:
    >> http://www.cse.unsw.edu.au/~atan164/ddraw_print.html
    >>
    >> Note that the initial setup needed for a proper working directx drawing
    >> surface is a pain in the ass if you've never done that before, but after
    >> that, drawing lines, boxes, bitmaps and such is peanuts. You could
    >> probably
    >> just replace your DrawLine/DrawBox functions (if you've made them) with a
    >> simpler directx command like Surface.DrawLine() and Surface.DrawBox()
    >> also
    >> Surface.
    >>
    >> Hope this helps.
    >>
    >> regards,
    >> Marcel
    >>
    >>
    >>
    >> "ann yard" <annyard1960@yahoo.com> schreef in bericht
    >> news:aqgce.290$Au1.155@tornado.socal.rr.com...
    >> > Question: Is it possible to control the video graphics card directly?
    >> > In effect, I am asking whether there is an API for nvidea graphics
    >> > card
    >> > so I can bypass DirectX and control the graphics card semi-directly.
    >> > I understand there is probably no way to literally access the card
    >> > directly, but some low-level API that maps to the card is fine for me.
    >> > I have already written a whole graphics engine, and don't want to
    >> > twist and torture it into the DirextX architecture, but am happy
    >> > to interface my code to the card.
    >
    >
  5. Archived from groups: alt.comp.periphs.videocards.nvidia (More info?)

    Thanks for the tip, but could you tell me how this
    answers the concerns in my post? Or point me to some
    brief overview that gets me started (or if you must,
    a long expensive book - as long as it DOES explain
    the aspects of architecture that I need explained).

    DirectX 9 also "supports vertex & pixel shaders",
    so I don't understand how your post actually answers
    any of my questions. Maybe it does, but I don't see.

    "Sharanga Dayananda" <sharanga@gmail.com> wrote in message news:jHLce.2145$l37.1948@newsfe4-gui.ntli.net...
    > Use the OpenGL Shading Language Shading extensions (glSlang).
    > They support vertex and fragment (pixel) shaders under OpenGL
    > up to Shader Model 3.0.
    >
    >
    >> "ann yard" <annyard1960@yahoo.com> wrote in message
    >> news:yJAce.501$Au1.415@tornado.socal.rr.com...
    >> Yes, I wrote the whole 3D simulation engine already.
    >>
    >> My code already does approximately what you suggest. But now I want
    >> to re-write the last stages of my application as pixel-shaders, to
    >> take advantage of the super-high-speed capabilities of video cards
    >> (GeForce 6800 Ultra now - then new/better cards every couple years.
    >>
    >> Therefore, I really do want to control the card, not just "BYPASS" it.
    >> Is this practical? If not, how does OpenGL get to the video card?
    >> Surely it is able to set and run video-card vertex and pixel shaders!
    >> Why does nobody want to describe how things work? Are programmers
    >> supposed to be a brain-dead zombies (unless they work for McSoft
    >> or nvidia and have access to "confidential information")? Sigh.
    >> Do science and engineering blindly, on faith! :-(
    >>
    >>
    >> "Marcel Overweel" <moverweel@hotmail.com> wrote in message
    >> news:42720a3f$0$151$e4fe514c@news.xs4all.nl...
    >>> If you say you already made a graphics engine, do you mean you
    >>> created something which draws, fills, colors and whatever else
    >>> directly onto a bitmap in a generic way? I mean: without using
    >>> any hardware acceleration and you are not using any hardware
    >>> specific code? If so, you could 'simply' setup a directx drawing
    >>> surface and access that as a linear piece of graphics memory.
    >>> The only thing you need from directx is the directx engine and
    >>> two simple 2d drawing surfaces (one for the currently visible frame
    >>> and one for a 'backbuffer' where you will paint the next frame
    >>> to be displayed) since everything else is done by your driver...
    >>> but if this is the case, it won't be a fast graphics engine
    >>> compared to today's standard since you are not using any
    >>> hardware acceleration at all.
    >>>
    >>> A better step would be to learn *some* directx 2d drawing,
    >>> like drawing lines and filling areas and use that as the
    >>> 'bottom layer' of your graphics engine.
    >>>
    >>> Just googled for a nice tutorial, this is the first one that
    >>> came up and seems good enough:
    >>> http://www.cse.unsw.edu.au/~atan164/ddraw_print.html
    >>>
    >>> Note that the initial setup needed for a proper working directx
    >>> drawing surface is a pain in the ass if you've never done that
    >>> before, but after that, drawing lines, boxes, bitmaps and such
    >>> is peanuts. You could probably just replace your DrawLine/DrawBox
    >>> functions (if you've made them) with a simpler directx command like
    >>> Surface.DrawLine() and Surface.DrawBox() also Surface.
    >>>
    >>> Hope this helps.
    >>>
    >>> regards,
    >>> Marcel
    >>>
    >>> "ann yard" <annyard1960@yahoo.com> schreef in bericht
    >>> news:aqgce.290$Au1.155@tornado.socal.rr.com...
    >>>> Question: Is it possible to control the video graphics card directly?
    >>>> In effect, I am asking if there is an API for nvidea graphics card
    >>>> so I can bypass DirectX and control the graphics card semi-directly.
    >>>> I understand there is probably no way to literally access the card
    >>>> directly, but some low-level API that maps to the card is fine for me.
    >>>> I have already written a whole graphics engine, and don't want to
    >>>> twist and torture it into the DirextX architecture, but am happy
    >>>> to interface my code to the card.
  6. Archived from groups: alt.comp.periphs.videocards.nvidia (More info?)

    Hi

    >>If not, how does OpenGL get to the video card?

    OpenGL has hooks to allow the graphic driver to implement custom
    functionality via extensions. The graphic card isn't being controlled by
    DirectX or OpenGL. Rather core functionality which DX and OpenGL expect is
    implemented by the graphics drivers through a suitable interface.

    If you could access the driver directly you could proly use those
    interfaces, but since they're specifically coded to support core
    functionality for that API I doubt that 'tis a raw interface to the
    hardware. The drivers control the hardware in native mode. Perhaps using an
    ICE program you could reverse engineer the driver to see what registers it
    writes to and what values are written, you could have direct access to the
    hardware.( TVTool was written in this way, which allowed access to the TV
    out functionality. )

    If you need access to the vertex and pixel shaders ( whose code is compiled
    internally on the GPU to anative format via the drivers ) your best bet is
    to use DX9 HLSL or OpenGL glSlang. You could also use Cg from nVidia.

    If you need examples for glSlang, take following may help.

    http://www.lighthouse3d.com/opengl/glsl/ ( though you'll need to load in the
    extensions in manually. )

    OR
    http://www.clockworkcoders.com/oglsl/

    OR if you need a book
    http://3dshaders.com/


    Cheers
    Sha

    "ann yard" <annyard1960@yahoo.com> wrote in message
    news:GQVce.17871$R46.11960@tornado.socal.rr.com...
    > Thanks for the tip, but could you tell me how this
    > answers the concerns in my post? Or point me to some
    > brief overview that gets me started (or if you must,
    > a long expensive book - as long as it DOES explain
    > the aspects of architecture that I need explained).
    >
    > DirectX 9 also "supports vertex & pixel shaders",
    > so I don't understand how your post actually answers
    > any of my questions. Maybe it does, but I don't see.
    >
    > "Sharanga Dayananda" <sharanga@gmail.com> wrote in message
    > news:jHLce.2145$l37.1948@newsfe4-gui.ntli.net...
    >> Use the OpenGL Shading Language Shading extensions (glSlang).
    >> They support vertex and fragment (pixel) shaders under OpenGL
    >> up to Shader Model 3.0.
    >>
    >>
    >>> "ann yard" <annyard1960@yahoo.com> wrote in message
    >>> news:yJAce.501$Au1.415@tornado.socal.rr.com...
    >>> Yes, I wrote the whole 3D simulation engine already.
    >>>
    >>> My code already does approximately what you suggest. But now I want
    >>> to re-write the last stages of my application as pixel-shaders, to
    >>> take advantage of the super-high-speed capabilities of video cards
    >>> (GeForce 6800 Ultra now - then new/better cards every couple years.
    >>>
    >>> Therefore, I really do want to control the card, not just "BYPASS" it.
    >>> Is this practical? If not, how does OpenGL get to the video card?
    >>> Surely it is able to set and run video-card vertex and pixel shaders!
    >>> Why does nobody want to describe how things work? Are programmers
    >>> supposed to be a brain-dead zombies (unless they work for McSoft
    >>> or nvidia and have access to "confidential information")? Sigh.
    >>> Do science and engineering blindly, on faith! :-(
    >>>
    >>>
    >>> "Marcel Overweel" <moverweel@hotmail.com> wrote in message
    >>> news:42720a3f$0$151$e4fe514c@news.xs4all.nl...
    >>>> If you say you already made a graphics engine, do you mean you
    >>>> created something which draws, fills, colors and whatever else
    >>>> directly onto a bitmap in a generic way? I mean: without using
    >>>> any hardware acceleration and you are not using any hardware
    >>>> specific code? If so, you could 'simply' setup a directx drawing
    >>>> surface and access that as a linear piece of graphics memory.
    >>>> The only thing you need from directx is the directx engine and
    >>>> two simple 2d drawing surfaces (one for the currently visible frame
    >>>> and one for a 'backbuffer' where you will paint the next frame
    >>>> to be displayed) since everything else is done by your driver...
    >>>> but if this is the case, it won't be a fast graphics engine
    >>>> compared to today's standard since you are not using any
    >>>> hardware acceleration at all.
    >>>>
    >>>> A better step would be to learn *some* directx 2d drawing,
    >>>> like drawing lines and filling areas and use that as the
    >>>> 'bottom layer' of your graphics engine.
    >>>>
    >>>> Just googled for a nice tutorial, this is the first one that
    >>>> came up and seems good enough:
    >>>> http://www.cse.unsw.edu.au/~atan164/ddraw_print.html
    >>>>
    >>>> Note that the initial setup needed for a proper working directx
    >>>> drawing surface is a pain in the ass if you've never done that
    >>>> before, but after that, drawing lines, boxes, bitmaps and such
    >>>> is peanuts. You could probably just replace your DrawLine/DrawBox
    >>>> functions (if you've made them) with a simpler directx command like
    >>>> Surface.DrawLine() and Surface.DrawBox() also Surface.
    >>>>
    >>>> Hope this helps.
    >>>>
    >>>> regards,
    >>>> Marcel
    >>>>
    >>>> "ann yard" <annyard1960@yahoo.com> schreef in bericht
    >>>> news:aqgce.290$Au1.155@tornado.socal.rr.com...
    >>>>> Question: Is it possible to control the video graphics card
    >>>>> directly?
    >>>>> In effect, I am asking if there is an API for nvidea graphics card
    >>>>> so I can bypass DirectX and control the graphics card semi-directly.
    >>>>> I understand there is probably no way to literally access the card
    >>>>> directly, but some low-level API that maps to the card is fine for
    >>>>> me.
    >>>>> I have already written a whole graphics engine, and don't want to
    >>>>> twist and torture it into the DirextX architecture, but am happy
    >>>>> to interface my code to the card.
    >
    >
Ask a new question

Read More

Nvidia Graphics Cards Graphics