script0r´s world | Paul Bartulej

Direct3D - Pure or Non-Pure Device?

nospam@example.com (Paul Bartulej) — 2007-10-02T12:37:29Z

MSDN has the following explanation of pure devices:

A pure device does not save the current state (during state changes), which often improves performance; this device also requires hardware vertex processing. A pure device is typically used when development and debugging are completed, and you want to achieve the best performance.

One drawback of a pure device is that it does not support Get* API calls; this means you can not use a pure device to query the pipeline state. This makes it more difficult to debug while running an application.

A second drawback of a pure device is that it does not filter any redundant state changes. When using a pure device, your application should reduce the number of state changes in the render loop to a minimum; this may include filtering state changes to make sure that states do not get set more than once. This trade-off is application dependent; if you use more than a 1000 Set calls per frame, you should consider taking advantage of the redundancy filtering that is done automatically by a non-pure device.

As with all performance issues, the only way to know whether or not your application will perform better with a pure device is to compare your application’s performance with a pure vs. non-pure device. A pure device has the potential to speed up an application by reducing the CPU overhead of the API. But be careful! For some scenarios, a pure device will slow down your application (due to the additional CPU work caused by redundant state changes). If you are not sure which type of device will work best for your application, and you do not filter redundant changes in the application, use a non-pure device.

Direct3D - Managing Resources

nospam@example.com (Paul Bartulej) — 2007-09-27T22:57:25Z

This is what MSDN tells about Managing Resources in Direct3D - take it in mind!

Resource management is the process in which resources are promoted from system-memory storage to device-accessible storage and discarded from device-accessible storage. The Microsoft Direct3D run time has its own management algorithm based on a least-recently-used priority technique. Direct3D switches to a most-recently-used priority technique when it detects that more resources than can coexist in device-accessible memory are used in a single frame, between Device.BeginScene and EndScene calls.

Use the Managed constant of the Pool enumeration at creation time to specify a managed resource. Managed resources persist through transitions between the lost and operational states of the device. The device can be restored with a call to Reset, and such resources continue to function normally without being reloaded with artwork. However, if the device must be destroyed and re-created, all resources created using Managed must be re-created.

Use the Default flag at creation time to specify that a resource is to be placed in the default pool. Resources in the default pool do not persist through transitions between the lost and operational states of the device. These resources must be released before calling Reset and must then be re-created.

For more information on the lost state of a device, see Lost Devices.

Note that resource management is not supported for all types and usages. For example, objects created with the RenderTarget flag are not supported. In addition, resource management is not recommended for objects whose contents are changing with high frequency. For example, a managed vertex buffer that changes every frame can significantly degrade performance for some hardware. However, this is not a problem for texture resources.

C# Recap - Part 1

nospam@example.com (Paul Bartulej) — 2007-09-21T16:25:51Z

While deepen in C#, I noted some significant points of that. You can use this to recap or
refresh your language knowledge - or just to deepen like me.

Define Variables
Variables can only be used (allocated), after they are defined.

break and continue
While iterations, the break command predicates to leave the complete iteration. With
continue, you can leave the current loop and goon with the next one.

params[] Modifier
Methods-Parameter can be modified as params[]. There, you
can pass as lot variables as you wish, based on the type you defined as params[] - but you
must not, if you won't. (Using an array, you must know how many variables to pass - and
you must pass)

public void MyMethod(int Iin, string SIn, params[] long SomeLongParams)

There are some rules using the params[] modifier:
- only one parameter of a method can be modified as params[]
- the parameter defined as params[] stays at the end of the parameter list
- cant be set as ref or out
- is one-dimensional
- you don't have to pass any variables through (because it's optional)

Using properties
Note that you can do any operations in the properties, if you want. For example if you
have to check an input value for validation, you can write it like:

public int Num
{
get{return _Num;}
set{if(value >0) value = _Num;}
}

You can use sharing-modificators for "getter" and "setter" using properties but take in mind:
- both, the get and the set Accessor must be defined
- but only one of them can be modified
- used sharing-modificator must be restrictered than the modificator of the property

readonly and const
Both modificators are similar. The difference:
- readonly can be also defined in constructors, const not (imagine, you havn't a value till runtime)
- readonly is invoked by an object-reference, const by the class-name

Constructor
What happens, calling a constructor of a class?
- arrange required space for the object
- initialize the object

Overloaded constructors allows a variable/dynamic initialization of an object (because of the
variable set of parameters, variables and methods). Take in mind, that the
standard-constructor (the constructor that will be used if you don't define one) is public!
You can build a hirarchial (linked) constructor-calling. Instructions in constructors that are
needed many times can be packed in own constructors. The called constructor by creating a
new object can first call another constructors (and that another again...) before it initializie
itself. This method is used to reduce code-redundancy.

Example

public Circle(double Radius)
{
this.Radius = Radius;
}

public Circle(double Radius, int X, int Y) : this(Radius)
{
this.XKoordinate = X;
this.YKoordinate = Y;
}

Short-Lived Objects
Creating an object to solve some operations and delete it after well done job to save
memory-ressources is a nice idea! And here the sample:

using(ClassA Obj = new ClassA())
{
Obj.AnyOperation();}
}

When does it euqals?
Objects equals, when references show to the same object. Objects are identic when
references has their own objects.

Check Equality between two Objects
- Equals-Method
- ReferenceEquals-Method
- == operator

static and instance (classes and objects)
In object-methods you can modify the class-variables and call class-methods. The reverse
way (calling object-methods and modify object variables with static methods) is not possible.
Take in mind to use data encapsulation, like in objects, in classes (static variables), too!

Game Class Diagram Sample (using sprites)

nospam@example.com (Paul Bartulej) — 2007-09-19T12:17:17Z

A game class diagram sample of a little game using sprites and DirectX

Game Class Diagram Sample

Sprite Class Sample

nospam@example.com (Paul Bartulej) — 2007-09-19T11:48:29Z

A nice sprite class sample below...

Sprite Class Sample

?:-Operator

nospam@example.com (Paul Bartulej) — 2007-09-11T13:36:57Z

If you have to execute an assignment in condition of a boolean, you can use the ?:-operator.

Structure
condition ? assignment(true) : assignment(false);

Example:

bool sunshine = true;

string strSun = sunshine ? "yes" : "No";
Console.WriteLine(strSun);
// Output: yes

Counting Loops

nospam@example.com (Paul Bartulej) — 2007-09-11T12:51:59Z

Keep an eye on setting condition for an iteration. For example, if your condition is the length of an array, you can use the amount of the array using the "<" (lower) sign. Alternatively, you can use the amount of array -1 using the "<=" (lower-equals) sign. Both cases will iterate as much as needed. But don´t confuse!

int[] intArr = new int[7]{3, 1, 54, 332, 2, 4, 5};

for(int i = 0; i<intArr.Length; i++)
{
// ...
}

// or...
for (int j = 0; j <= intArr.Length - 1; j++)
{
// ...
}

Absolute Base Class

nospam@example.com (Paul Bartulej) — 2007-09-10T16:22:33Z

Base classes should be as abstract as possible (they can be defined as abstract classes). Depending on use case, they should contain no more information than what is absolutely necessary - even if it is only the name of the object! Inside of a class-hierarchy all affected classes (objects) can be handeled similar. Thats exacting than if you handle all similar classes of a class-hierarchy as absolute base class "object". Once particular classes get specify tasks/Properties, interfaces can be used.

Some notes about logic operators

nospam@example.com (Paul Bartulej) — 2007-09-07T16:49:04Z

If you use the operator "&", the expression a&b got true, if both (a and b) are true. Independence of the result, both variables will be exploit.
If you use the operator "&&", the expression a&&b got true, if both (a and b) are true. But if the first variable is false, the result got false and the second variable won´t be exploit.

The same with the operators "|" and "||". "||" says, if the first variable is true, the result got true and the second variable won´t be exploit.

Logic or ("|") got true, if one of the variables of the expression "a|b" got true or both, xor ("^") only got true, if one of them is true!

Attention with devisions!

nospam@example.com (Paul Bartulej) — 2007-09-07T16:42:38Z

Look at the code below:

double dblVal = 3/4;
Console.WriteLine(dblVal);

// Output: 0!

Because the runtime take the "3" and "4" as Integers, the result of 0,75 got "0" (trim)!

If you set one of the two numbers to a float (e.g. 3.0), the runtime recognise the positions after decimal point and the result will be correct.

double dblVal = 3.0/4;
Console.WriteLine(dblVal);

// Output: 0,75!

Operations with increment and decrement

nospam@example.com (Paul Bartulej) — 2007-09-07T16:01:00Z

Increment:
By an increment operation, the value of the increment variable (in this case x) will first be assigned to the destination-variable (in this case y) before it increments (got +1).

int x = 4;
int y = x++;

y=4!
x=5

Decrement:
By a decrement operation, the value of the increment variable (in this case x) will first increment its value before it assigns to the destination-variable (in this case y).

int x = 4;
int y = ++x;

y=5!
x=5

Implicit and explicit converts

nospam@example.com (Paul Bartulej) — 2007-09-07T15:41:04Z

Implicit convert:
A less unit converts to a larger one => no losing data.

Explicit convert:
A larger unit converts to a less unit => losing data, so explicit expression required!

Note:
Data Types can only be converted in the same hierarchy. An Integer is not a String!

Data Types in C#

nospam@example.com (Paul Bartulej) — 2007-09-07T13:44:51Z

Here is a list of Value Types in C#

Easier way to write string-expressions with format-expressions

nospam@example.com (Paul Bartulej) — 2007-09-07T12:32:32Z

A string-output can be very circular, if you write a longer expression with lots of variables in it.

Example 1:

string strWho = "girlfriend";
string strHow = "sweet";
string strWhat = "princess";

Console.WriteLine("My " + strWho + " is a " + strHow + " " + strWhat + " :)");
// Output: My girlfriend is a sweet princess : )

Therefore, there is another way - an easier way to do the same by using format-expressions ({num}).

Example 2:

string strWho = "girlfriend";
string strHow = "sweet";
string strWhat = "princess";

Console.WriteLine("My {0} is a {1} {2} :)", strWho, strHow, strWhat);
// Output: My girlfriend is a sweet princess : )

Instead of variables, you write the format-expressions in your string-expression. The variables, that will be filled in the formats, are standing after the comma as further parameters. Please attend to the sequence of the variables! First variable fill the first format.

With comma and colon, you can set number of space charakters and the format expression.

Example 3:

int iPlanets = 10;

// Expression "N" stands for numeric-comma
Console.WriteLine("With Xena, our Solarsystem has now {0,5:N} Planets!", iPlanets);
Console.ReadLine();
// Output: With Xena, our Solarsystem has now 10,00 Planets!

// Expression "D" stands for decimal integer
Console.WriteLine("With Xena, our Solarsystem has now {0,10:D} Planets!", iPlanets);
Console.ReadLine();
// Output: With Xena, our Solarsystem hast now 10 Planets!

Format Description
C: currency-format
D: decimal-format
E: scientific notation
F: dot-format
G: dot-format or rather scientific-format (the better case)
N: numeric-format with comma
P: numeric-format in power
X: Hex-Code

Assemblies

nospam@example.com (Paul Bartulej) — 2007-09-06T16:18:33Z

An Assembly is the result of compiling a .Net code. You can compile .exe and .dll files – depend on your project type. Assemblies consists from IL-Code/MSIL-Code and metadata. IL-Code is the code, compiled by the used Language compiler. Metadata describes a component and its object-information. So it can access to other components, written in IL-Code.

A Manifest describes an Assembly. A Manifest contains:
- name and version of an assembly
- references to other assemblies
- public Types of an assembly
- security-instructions for access on the assembly