Home Page Icon
Home Page
Table of Contents for
X. Bonus Web Site Chapters
Close
X. Bonus Web Site Chapters
by Graham Wihlidal
Game Engine Toolset Development
Copyright
Dedication
Foreword
Acknowledgments
About the Author
Introduction
I. Toolset Design Fundamentals
1. What is a Tool? What is a Toolset?
Stakeholders: Internal Versus External
Who Builds the Tools?
How Large are Tools Teams?
Conclusion
2. Why Use C#? Why Use .NET?
Overview of .NET
Overview of C#
Legacy Interoperability
Platform Invocation Service (P/Invoke)
COM and Runtime Callable Wrappers
C++/CLI (Managed Extensions for C++)
Benefits
Conclusion
3. Examples of Commercial Toolsets
Case Study: BioWare Corporation
Case Study: Artificial Studios
Conclusion
4. Everything Starts with a Plan
Vision
Stakeholders
Reusability
Architecture
Requirements
Design Standards
Coding Standards
Documentation
Testing
Defect Tracking
Life Cycle
Development Environment
Staging Environment
Production Environment
Conclusion
5. Development Phases of a Tool
Phase: Planning
Phase: Analysis
Phase: Design
Phase: Implementation
Conclusion
6. Measurement Metrics for Tool Quality
Metric: Maintainability
Metric: Traceability
Metric: Performance
Metric: Usability
Metric: Testability
Metric: Portability
Metric: Reliability
Metric: Efficiency
Conclusion
7. Fundamentals of User Interface Design
Principle of Consistency
Principle of Transparency
Principle of Feedback
Principle of Refinement
Principle of Exploration
Principle of Modality
Principle of Self-Evidence
Principle of Moderation
Principle of Customization
Conclusion
8. Distributed Componential Architecture Design
Architecture Overview
Core Components
Specific Tool Logic
Console Entry Point
Windows Entry Point
Other Entry Points
Remoting
Web Access
COM Interface
Architecture Example
Object Definitions
Object Processing
Alert Object Tool Interface
Alert Object Tool
Alert Object Console
Alert Object Windows—Direct
Alert Object Windows—Wrapper
Alert Object Remoting
Alert Object Remoting Example
Unmanaged COM Support
Alternate Architecture Structure
Conclusion
9. Solutions to Bridge Domain Gaps
Compositional Friction
Cause: Domain Coverage
Cause: Design Intentions
Cause: Framework Gap
Cause: Entity Overlap
Cause: Legacy Components
Cause: Source Code Access
Relevant Design Patterns
Façade Design Pattern
Adapter Design Pattern
Conclusion
10. Unit Testing with Nunit
Overview of Unit Testing
Introducing NUnit
Creating an NUnit Project
Attribute Overview
Expected Outcome Assertion
A Simple Example
Running Tests
Debugging with Visual Studio
Conclusion
11. Code Documentation with NDoc and XML
Configuring the Project
Supported XML Markup
Commenting Example
Generating the Documentation
Conclusion
12. Microsoft Coding Conventions
Styles of Capitalization
Naming Classes
Naming Interfaces
Naming Namespaces
Naming Attributes
Naming Enumerations
Naming Static Fields
Naming Parameters
Naming Methods
Naming Properties
Naming Events
Abbreviations
Conclusion
13. Enforcing Coding Policies with FxCop
Installing FxCop
Creating an FxCop Project
Configuring Built-In Rules
Analyzing Your Project
Building Custom Rules
Conclusion
14. Best Practices for Robust Exception Handling
External Data is Evil
Creating Custom Exceptions
Throwing Exceptions
Structured Exception Handlers
Logging Exception Information
Mechanisms for Cleanup
Unhandled and Thread Exception Events
Conclusion
II. Techniques for Arbitrary Tools
15. Compressing Data to Reduce Memory Footprint
Types of Compression
GZipStream Compression in .NET 2.0
Implementation for Arbitrary Data
Implementation for Serializable Objects
Conclusion
16. Protecting Sensitive Data with Encryption
Encryption Rudiments
Public-Key Encryption
Private-Key Encryption
Ciphers
Block Padding
Key Strength
Cipher Modes
Initialization Vectors
Selecting a Cipher
ICryptoTransform Interface
Conclusion
17. Generic Batch File Processing Framework
Goals
Proposed Solution
Implementation
Delegate Definitions
Conclusion
18. Ensuring a Single Instance of an Application
Early Solutions
Journey to the Dark Side
The Solution
Conclusion
19. Implementing a Checksum to Protect Data Integrity
Implementation
Usage
Alternative
Conclusion
20. Using the Property Grid Control with Late Binding
Designing a Bindable Class
Ordering Properties
Using the PropertyGrid
Conclusion
21. Adding Printing Support for Arbitrary Data
Printing Regular Text
Supporting Printer Selection
Supporting Page Setup
Supporting Print Preview
Conclusion
22. Flexible Command Line Tokenizer
Formatting Styles
Implementation
Sample Usage
Conclusion
23. Layering Windows Forms on Console Applications
Implementation
Sample Usage
Conclusion
24. Overview of Database Access with ADO.NET
Advantages of ADO.NET
ADO.NET Object Model
DataView
DataSet
DataProvider
Working with a DataReader
Working with a DataAdapter
Working with XML
Potion Database Editor
Conclusion
III. Techniques for Graphical Tools
25. Using Direct3D Swap Chains with MDI Applications
What is a Swap Chain?
Thoughts for SDI and MDI Applicability
Common Pitfalls
The Proposed Solution
Conclusion
26. Constructing an Aesthetic Texture Browser Control
Swappable Loader Interface
Windows GDI+ Loader
Managed Direct3D Loader
Storing Texture Information
Building the Thumbnail Control
Handling Custom User Events
Building the Viewer Control
Using the Control
Loading Textures from a Directory
Loading Textures from a MemoryStream
Loading Textures from a Bitmap
Texture Browser Demo
Conclusion
27. Converting from Screen Space to World Space
Transforming Screen Coordinates
Computing the Picking Ray
Bounding Sphere Intersection Tests
Improving Intersection Accuracy
Using Built-In D3DX Functionality
Conclusion
28. Asynchronous Input Device Polling
Asynchronous Mouse Polling
Asynchronous Keyboard Polling
Sample Usage
Conclusion
IV. Techniques for Network Tools
29. Downloading Network Files Asynchronously
HttpWebRequest and HttpWebResponse
The Request Object
Maintaining Data State
The Core System
Sample Usage
Conclusion
V. Techniques for Legacy Interoperability
30. Exchanging Data Between Applications
What Microsoft.NET Provides
Web Services
Remoting
Clipboard
TCPIP Loopback Communication
What Microsoft.NET Should Provide
Named Pipes
WM_COPYDATA
Building a Wrapper Around WM_COPYDATA
Communicating from Unmanaged Applications
Communicating from Managed Applications
Conclusion
31. Interacting with the Clipboard
The Clipboard Class and IDataObject
Storing Built-In Types
Storing Custom Data Formats
Querying Available Data Formats
Complete Solution
Conclusion
32. Using .NET Assemblies as COM Objects
COM Callable Wrappers (CCW)
Applying Interop Attributes
Registering with COM
Accessing from Unmanaged Code
Deployment Considerations
Conclusion
33. Managing Items in the Recent Documents List
Implementation
Example Usage
Conclusion
VI. Techniques to Improve Performance
34. Playing Nice with the Garbage Collector
Overview of the Garbage Collector
Collecting the Garbage
Allocation Profile
CLR Profiler and GC Monitoring
Performance Counters
Profiling API and the CLR Profiler
Finalization and the Dispose Pattern
Finalization
The Dispose Pattern
Weak Referencing
Explicit Control
Conclusion
35. Using Unsafe Code and Pointers
Rudiments of Pointer Notation
Using an Unsafe Context
Pinning Memory with the Fixed Statement
Disabling Arithmetic Overflow Checking
Allocating High Performance Memory
Getting Size of Data Types
Example: Array Iteration and Value Assignment
Example: Data Block Copying
Example: Win32 API Access
Conclusion
36. Investigating Managed Code Performance
Investigating Performance
Avoid Manual Optimization
String Comparison
String Formatting
String Reversal
Compiling Regular Expressions
Use the Most Specific Type
Avoid Boxing and Unboxing
Use Value Types Sensibly
The Myth About Foreach Loops
Use Asynchronous Calls
Efficient IO Buffer Sizes
Minimize the Working Set
Perform Chunky Calls
Minimize Exception Throwing
Thoughts About NGen
Conclusion
37. Responsive UI During Intensive Processing
Implementing the Worker Logic
Reporting Operation Progress
Supporting User Cancellation
Executing the Worker Thread
Conclusion
VII. Techniques to Enhance Usability
38. Designing an Extensible Plugin-Based Architecture
Designing a Common Interface
Embedding Plugin Metadata Information
Building a Proxy Wrapper
Loading Plugins Through the Proxy
Reloading Plugins During Runtime
Runtime Compilation of Plugins
Enforcing a Security Policy
Conclusion
39. Persisting Application Settings to Isolated Storage
Concept of Isolated Storage
Accessing Isolated Storage
Levels of Isolation
Management and Debugging
Conclusion
40. Designing a Reusable and Versatile Loading Screen
Splash Dialog
Go for the Gusto
Concept of Loading Jobs
Responsive Processing
Simple Example
Conclusion
41. Writing Context Menu Shell Extensions
Unmanaged Interfaces
Reusable Framework
Sample Usage—Standalone
Sample Usage—Integrated
Component Registration
Debugging Techniques
Conclusion
VIII. Techniques to Increase Productivity
42. Automating Workflow Using Job Scheduling
Benefits
Solution Goals
Implementation
Conclusion
43. MVC Object Model Automation with CodeDom
Advantages of an Automatable Object Model
Comparison with Model-View-Controller Pattern
A Simple Object Model Architecture
Plugin-Based Architectures
Controlling an Object Model with Scripts
Implementing a C# Command Window
Simple Automation and MVC Example
Conclusion
IX. Techniques for Deployment and Support
44. Deployment and Versioning with Clickonce
ClickOnce and MSI Comparison
Creating the Application
Publishing the Application
Launching the Application
Deployment Configuration
Pushing Application Updates
Programmatically Handling Updates
Conclusion
45. Testing for the Availability of the .Net Framework
The Solution
Example Usage
Conclusion
46. Building and Customizing an MSI Installer
Creating a Setup Project
Project Configuration
Deployment Configuration
Custom Installer Actions
Deploying the Installer
Conclusion
47. Determining Binary File Differences
What is Levenshtein Distance?
Generating a Difference List
Transforming Data Using a Difference List
Thoughts for Usability and Deployment
Conclusion
X. Bonus Web Site Chapters
1. Distributed Computing Using .NET Remoting
Investigating Scalability
Fault Tolerance
Managing Security
Middleware Considerations
Sample Framework
Conclusion
2. Building a Managed Wrapper with C++/CLI
Introduction to Managed C++ (C++/CLI)
Overview of Extended Syntax
Reference Handles
Keyword: abstract
Keyword: delegate
Keyword: event
Keyword: interface
Keyword: property
Keyword: sealed
Keyword: __identifier
Keyword: pin_ptr
Keyword: safe_cast
Keyword: typeid
Common Language Runtime Compilation (/clr)
Referencing Assemblies and Classes
Mixing Managed and Unmanaged Code
Example Unmanaged 3D Engine
Creating a Managed Wrapper for SimpleEngine
Consuming the Managed Wrapper
Conclusion
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
47. Determining Binary File Differences
Next
Next Chapter
1. Distributed Computing Using .NET Remoting
Part X. Bonus Web Site Chapters
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset