Da bin ich wieder und voller Fragen die mich als unwissend definieren. Trotz dessen wird nicht aufgegeben.
Denn mein Ziel ist die Erleuchtung zu gewinnen.
Genug der einleitenden Worte. Hier das neue Problem:
Seit 2 Tagen werden Gedanken verbraucht um Microsoft (Effectfiles) HLSL Programme zu verwalten. Mein bisheriges Konzept
ist sehr "löchrig". Versuche kurz und präzise alles zusammenzufassen was bisher erarbeitet wurde.
Meine D3D Klasse befindet sich in einer DLL. Diese soll die HLSL Programme verwalten. Die gesamte Klassendefinition wird euch
erspart zu viel Informationen. Daher nur das wesentliche in kürze:
D3D Klasse:
- Code: Alles auswählen
/**
* Class definition for a Direct3D render device, implementing the
* interface RenderDevice
*/
class D3D : public RenderDevice {
public:
D3D(HINSTANCE hDLL);
~D3D(void);
SkinManager* GetSkinManager(void) { return m_pSkinMan; }
VertexCacheManager* GetVertexManager(void) { return m_pVertexMan; }
ModelManager* GetModelManager(void) { return m_pModelMan; }
// initialize the engine stuff
HRESULT Init(HWND);
...
// shader stuff
HRESULT CreateHLSLShader(const void*, UINT *nShaderID);
ID3D10Effect* GetHLSLShader(UINT nShaderID);
HRESULT SetTechnique(char *tc, UINT nShaderID, UINT *nTechniqueID);
HRESULT ActivateTechnique();
//HRESULT SetVariable();
...
private:
ID3D10Effect* m_pHLSLShaders[MAX_SHADER];
UINT m_nNumHLSLShaders;
HLSLTechnique m_HLSLTechniques[MAX_TECHNIQUES][MAX_SHADER];
UINT m_nNumHLSLTechniques[MAX_SHADER];
}; // class
/*----------------------------------------------------------------*/
An diese Klasse wird die Schnittstellendefinition Renderdevice vererbt. Das kennt ihr ja alle mittlerweile zu genüge so dass darauf nicht
eingegangen werden muss was das bedeutet.
Meine Absicht ist eine begrenzte Anzahl von HLSL Shadern zu verwalten. => MAX_SHADER
Jeder Shader darf eine begrenzte Anzahl von Techniken verwenden. => MAX_TECHNIQUES
Diese Techniken werden der D3D Klasse mit folgender Struktur bekannt gegeben:
- Code: Alles auswählen
typedef struct HLSLTechnique {
ID3D10EffectTechnique* pTechnique; // D3D10 technique interface
UINT nShaderID; // ID die den Shader kennzeichnet welche die "technique" verwendet
} HLSLTechnique;
Innerhalb der D3D Klasse wird nun Speicherplatz geschaffen über
HLSLTechnique m_HLSLTechniques[MAX_TECHNIQUES][MAX_SHADER];
Hier werden nun die Daten abgelegt für die möglichen Techniken. Jeder Shader kann ja MAX_TECHNIQUES besitzen. Damit die Klasse "weiß"
wie viele Shader bzw. Techniken sie besitzt existieren die beiden Zähler:
UINT m_nNumHLSLShaders;
und
UINT m_nNumHLSLTechniques[MAX_SHADER];
Damit kann die Klasse schon mal mit HLSL "Progrämmchen" und ihren Techniken gefüttert werden.
Weiterhin benötigt die Klasse ein Konzept um die Variablen der HLSL Programme zu speichern um diese während der Laufzeit
zur Verfügung zu stellen. Dazu viel mir folgendes ein:
- Code: Alles auswählen
typedef enum HLSLVARIABLE_TYPE {
FLOAT,
VECTOR,
MATRIX,
...
} HLSLVARTYPE
typedef struct HLSLVariable {
ID3D10EffectVariable* pVariable; // D3D10 variablen interface
HLSLVARTYPE Varablentyp;
UINT nShaderID; // ID die den Shader kennzeichnet welche die Variable verwendet
} HLSLVariable;
Mit diesem Strukturen können der D3D Klasse nun die Variablen mitgeteilt werden. Methoden werden zur Verfügung gestellt
um der Renderfunktion der Applikation den Zugriff auf diese Variablen zu ermöglichen.
Was haltet ihr von dieser Lösung? Ist es einfacher möglich?
