Sign in with
Sign up | Sign in
Your question

question: control video card semi-directly ???

Last response: in Graphics & Displays
Share
Anonymous
a b U Graphics card
April 29, 2005 5:51:02 AM

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.
Anonymous
a b U Graphics card
April 29, 2005 4:19:43 PM

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.
>
>
Anonymous
a b U Graphics card
April 29, 2005 4:33:01 PM

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.
Related resources
Anonymous
a b U Graphics card
April 30, 2005 4:57:02 AM

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.
Anonymous
a b U Graphics card
April 30, 2005 5:25:35 PM

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.
>
>
Anonymous
a b U Graphics card
May 1, 2005 4:58:14 AM

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.
Anonymous
a b U Graphics card
May 1, 2005 6:50:30 PM

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.
>
>
!