These components are an "ideal" "massive" low-level C++ class library designed for use in C++ Builder when writing :-
* advanced games,
* multimedia applications,
* multi-monitor 2d graphics applications,
* sound, music, input, networking, 3d applications,
or any other type of application that requires very advanced features.
These components supply basic C++ Builder building blocks required for adding device-independant hardware
support via RAD DirectX to very advanced C++ Builder applications, pretty well any type of application,
for example, a very intensive sound/graphics/input/networked/3d application such as a very advanced computer game
or multimedia simulation.
These components also do many things in the background to make RAD DirectX incredibly easy to use,
quite literally hiding all the difficult aspects of "standard" DirectX programming from the components end-user,
while still allowing full and transparent access to all DirectX internals if needed.
You can write your code using these components to draw 1000's of images every second, across all monitors,
independant of hardware or operating system, then value-add the existing hardware support by using the
in-built C++ Builder Visual Component Library controls and image and canvas drawing functions,
or add your own image functions such as pixel-drawing, lines, circles, jpeg, gif, mpeg, avi support, etc.
You could add lots of sound fx and music, maybe while recording, using all available sound hardware,
and add your own code to manipulate the raw sound data... if you need to save it to disk, use the in-built TDx_Functions...
Add simple code to handle all input devices attached to the system, simultaneously knowing the realtime status of
all hardware devices and playing your custom force-feedback effects through the devices...
Add simultaneous and transparent safe networking to your application using p2p or client/server or whatever you like,
on LAN, internet, Modem, cable using TCP/IP or IPX, with massive in-built multiplayer functions and event-driven
network handling... incredibly easy multiuser networking support compared to something like sockets.
Finally, support and have all available 3d hardware pumping out incredible realtime 3d graphics,
with "whatever" 3d world engine you like plugged in...
You can do whatever you like with these components...
Very simple DirectX.
You can code DirectX very quickly indeed - usually one line of code per DirectX action,
and a lot happens automatically and invisibly to make coding DirectX incredibly easy, such as :-
* automatic component creation and destruction
* easy DirectX interface creation and destruction
* easy Method() calling... all of DirectX is in here... 1000's of methods()... plus TDx Extras()
* automagic error detection and redirection to standard C++ Builder OnError() event's
* automagic OnCreate(), OnDestroy() and many other OnEvent()'s
* automagic redirection of (yuk) win32 callbacks to very easy-to-use OnCallback() events
* automagic win32 event queue handling and redirection to very easy-to-use OnEvents()
* automagic parameter conversion
* automagic parameter checking
* automagic memory management of internal DirectX structures
* automagic cross-updating of related DirectX datasets
* complete access to component DirectX internal interfaces and data
* instant and comprehensive [F1] help from anywhere in the C++ Builder IDE
* and so on
These RAD DirectX components are native C++ Builder VCL TComponents, the most basic type of TComponent...
they can be used at design-time, visually, inside the compiler, like normal VCL components,
they can used with other VCL components, and you can also mix-and-match your RAD DirectX and native DirectX code if you like.
You can use the C++ Builder Object Repository, setup your DirectX components, data, flags, events, callbacks, etc. at design-time
using the C++ Builder Object Inspector, and you can use the in-built code-creation and navigation features of C++ Builder to very easily
code your DirectX applications runtime code, mixing the thousands of methods, interfaces, data structures, etc. normally in DirectX
with all the in-built C++ Builder and additional TDx RAD enhancements.
the components are designed to be used with all the C++ Builder Code-Reuse functionality,
and come with easy C++ Builder code navigation and instant and fully documented [F1] help and source code.
For runtime programming, a complete and simple-to-use OOP VCL RAD DirectX interface to most of DirectX 7.0a,
with 107 different TComponent's, 1000's of __property's, Methods(), OnEvents(), automatic callback handling to OnCallbacks()... etc.
It is DirectX nearly all converted to native C++ Builder VCL-standard code, with everything already done to make
the TDx_Library a complete "off-the-shelf" end-to-end solution for coding DirectX - incredibly simply.
You don't have to code or debug the libraries, you just use them, and you don't have to worry about all
the incredible complexity of DirectX much... the incredibly hard part is already done... working as RAD DirectX,
a fully integrated part of the C++ Builder compiler.
There's no normal win32 code for the end-programmer of the TDx_Library, there's no wierd callback handling,
or any kind of wierd win32 queue handling or any kind of bizarre "hungarian notation" -> quite literally everything
normally in entire sections of DirectX is actually converted intelligently into C++ Builder code,
and you use it like incredibly advanced RAD C++ Builder DirectX code.
This is not "painful" "standard" - Win32 / DirectX programming...
This is something different - "real" "simple" "wow" - RAD DirectX programming...
This library is huge but fairly effortless to use, and it makes coding RAD DirectX incredibly simple and neat-and-tidy indeed.
It will also save you 90% or more of the time, effort and money that you would normally spend in your projects -
saving you quite literally years reinventing the wheel.