BCB-Tools presents TDx Library 1.80 and overall introduction
DirectX on Autopilot
"Create working C++ Builder RAD DirectX applications in minutes..."
"No more spending countless hours struggling with the SDK, compiler integration, or bizarre tools."
"No matter if you are a beginner or an expert, RAD DirectX works perfectly and takes only minutes of coding..."
The TDx_Library is a huge high-performance C++ Builder and DirectX - RAD Game SDK - or - RAD Multimedia SDK -
It is quick, easy-to-use, comprehensive, and very powerful...
It is 107 native C++ Builder components, arranged in 5 different libraries,
seamlessly integrating almost all of DirectX 7.0a into C++ Builder v1,3,4,5,6,++, as OOP VCL RAD DirectX.
-= Read an overview of the TDx_Library =-
It is useful for adding :-
advanced 2d graphics
lots of sound effects, music, recording
force-feedback input devices
massive multiuser networking support
and 3d graphics rendering engine
to any coder's C++ Builder applications...
all using "wow..." - >so simple - so powerful< - native C++ Builder and automagic RAD DirectX code.
the TDx_Library is not "normal" win32 or DirectX programming, it's Rapid-Application-Development DirectX programming.
- something entirely different from normal DirectX programming.
It is very quick, very powerful, and very easy to use.
(Please continue to scroll down for more and more TDx_Library information)
C++ Builder is the best C++ compiler in the world, with massive, easy-to-use, RAD class-libraries integrated into the IDE,
which you can setup visually while you actually write your code, and can be used at runtime when your code executes.
DirectX is a low-level set of C++ structures and functions designed primary for advanced game or multimedia development,
and it provides a very complex and horridly evil Microsoft win32/com interface designed to access nearly all hardware on windows pc's,with built-in hardware independence and software driver support when hardware is unable to perform necessary functions.
When you blend the best RAD C++ compiler in the world and dramatically enhance it with a game development SDK like DirectX, and then convert DirectX so it works as an integrated RAD DirectX part of the C++ Builder compiler, it's kinda cool.
The TDx_Library is DirectX seamlessly integrated into C++ Builder,
a complete layer of C++ Builder VCL code built on top of DirectX,
which converts and translates the painful DirectX SDK from a win32/COM+ interface
into a native C++ Builder VCL class interface, replacing the seriously difficult Microsoft SDK
with an automagic C++ Builder RAD DirectX OOP SDK...
You install C++ Builder X
You install DirectX 7.0a SDK
You install the TDx_Library v1.80
Instant RAD DirectX...
As soon as you have installed the TDx_Library, you have complete RAD DirectX 7.0a SDK support
in your C++ Builder compiler(s)... you are ready to code advanced "RAD" DirectX 7.0a SDK applications in literally seconds or minutes...
All of the DirectX 7.0a SDK, intelligently converted into standard RAD OOP C++ Builder VCL component libraries,
designed from the ground up to make DirectX programming incredibly easy... actually... very simple code...
while still retaining all the power of DirectX, you can mix and match "traditional" win32 / com+ DirectX programming with VCL code...
and also mix and match your complete RAD VCL DirectX interface with "standard" C++ Builder VCL components.
You can code completely working, bug-free DirectX 7.0a SDK applications using the TDx_Library RAD DirectX SDK in literally minutes,
and you can code a complete sound-mixing or animation application in (say) 10-20 lines of RAD DirectX code...
Compare that to "traditional" DirectX programming, or any other kind of DirectX programming,
and you will find that it takes at least 1000-2000 lines of very complex win32/com+ Visual C++ code to do the same thing,
without any extra C++ Builder VCL component libraries, or similar, or code required just to enhance the basic DirectX SDK.
"Standard" win32/com+ DirectX programming usually requires a high level of programming skill,
and normally you need to know a lot of esoteric win32/com+ DirectX coding techniques, just to begin writing a DirectX application.
When you write a "normal" win32/com+ DirectX program, you normally need to code a huge amount of "other" code
to actually accomplish anything with DirectX... you need to manage all your own DirectX data and interfaces, quite complex,
you need to write code to handle DirectX callbacks, you need to write code to handle all the DirectX error reporting,
you need to write code to handle the win32 event queue, usually as a multithreaded background task,
you need to write code to handle any kind of "load image from disk" or "load sound from disk" and so on...
then you still need to learn and code to make DirectX actually do something for you...
Very silly, very slow, to code "standard" "crap" "normal" C++ DirectX applications...
When instead, you can code incredibly easy, incredibly simple, incredibly powerful... RAD DirectX...
The TDx_Library offers complete Rapid-Application-Development support to C++ Builder programmers who wish to use DirectX in C++ Builder :-
You don't have to do much really, just install the TDx_Library RAD DirectX SDK, and you can be programming in minutes...
All of DirectX, working automagically, you just use the components, you don't have to write 10000's of lines of code just to get the SDK working...
The TDx_Library v1.80 is :-
DirectDraw(tm) - Incredible Multimonitor 2D Graphics
DirectSound(tm) - Sounds, Recording and Music
DirectInput(tm) - Joysticks, Yokes, Steering Wheels, etc.
DirectPlay(tm) - Multiplayer Network Support, Internet, LAN, IPX, TCP, etc.
Direct3D(tm) - Low-Level 3D Graphics Rendering Engine
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.