Thanks. I understand what you mean with 'blind staring' on style (and possible OCD :))

During time I've developed my own style which feels good. My whole project (3d engine) uses this style, but never takes into account if parameters passed to a function can be modified or not, that's why I'm approaching this 'wider' then just one source file.

For example:

- I have a d3d class, which is the main class where the rendering happens

- for example the 'RenderFrame' member function, takes a d3dscene and other objects as parameters, but they're never changed

(and therefore would be safer to make them 'const'). At the moment I pass basically everything as a pointer, meaning I could accidentally change everything and can't see in a (member) function what the passed parameters/ variables are used for

- the same 'RenderFrame' function uses variables of the d3d object, but never changes them, so the member function 'RenderFrame' should be 'const' to (for safety)

etc. :)

One of the things I've put through over my complete project is variable namings.

mMyThing, means it's a class member, starting with "m", pMyOther, means it's a parameter given to the scope/ function, because it starts with 'p'.

It was quite a job to go through all code and apply it, but it definately helped and helps me when I change things now.

The same is with documentation/ comments in my code, also one style all over the engine.

Basically it's to late to prevent OCD, as you can read :)

But if in your examples you confuse the syntax for pointers and references I feel you need to be OCD in other areas. I personally like the p prefix for pointers since the syntax is different ("->" vs. ".").

Yep, I understand.

An example in my case:

bool CD3d::CheckDevice() const
{
	if(SUCCEEDED(mD3ddev->TestCooperativeLevel())) return true;
	return false;
}

** when it regards passing 'simple' objects like a vector/vertex, matrix, int, float etc., that is only input (not to be changed), I use const only (no reference). For example:
float DistCoordToCoord(const D3DXVERTEX3 pVector1, const D3DXVECTOR3 pVector2); or

** when it regards passing 'simple' objects which need to be altered, I use a pointer. For example:
void DistCoordToCoord(const D3DXVERTEX3 pVector1, const D3DXVECTOR3 pVector2, float *pResult);

This is a code smell to me. If pResult is an output of the function then it should be returned.

float DistCoordToCoord(const D3DXVERTEX3 pVector1, const D3DXVECTOR3 pVector2);

If you need the initial value for some reason, pass that in.

float DistCoordToCoord(const D3DXVERTEX3 pVector1, const D3DXVECTOR3 pVector2, float initialValue);

Then do the assignment in the call

float someValue = 10f;
someValue = DistCoordToCoord(vector1, vector2, someValue);

Side note: If you're going to prefix p to pointers, make sure you're consistent about it. pVector1 and pVector2 are poorly named.
Even more side note: Why not make them references here? Sure, you're only saving a few bytes, but it costs you nothing in terms of readability and code maintenance.

float DistCoordToCoord(const D3DXVERTEX3 pVector1, const D3DXVECTOR3 pVector2);

This is going to invoke the copy constructor for pVector1 and pVector2, create new copies of each, and put them on the stack. Not a big deal for a D3DXVECTOR3, but you need to be real careful if doing it with other object types.