STDMETHODIMP CTangramNode::get_Attribute(BSTR bstrKey, BSTR* pVal)
{
IXMLDOMElement* ele = NULL;
m_ObjItem.elem.QueryInterface<IXMLDOMElement>(&ele);
if (ele != NULL)
{
VARIANT var;
ele->getAttribute(bstrKey,&var);
ele->Release();
if (var.vt == VT_BSTR)
{
*pVal = var.bstrVal;
}
}
return S_OK;
}
HRESULT COFSNcDlg2::GetNodeAttribute(IXMLDOMNode *pNode, BSTR bsAttrName, CComBSTR &strAttrValue)
{
HRESULT hr = S_OK;
IXMLDOMElement *pEle = NULL;
if(pNode == NULL)
return E_INVALIDARG;
hr = pNode->QueryInterface(IID_IXMLDOMElement, (void**)&pEle);
if(pEle)
{
CComVariant var;
hr = pEle->getAttribute(bsAttrName, &var);
strAttrValue = var.bstrVal;
pEle->Release();
}
return hr;
}
bool COpenGL::SetShadersGLSL(const TCHAR *glslFileName)
{
char *fragment=NULL, *vertex=NULL;
IXMLDOMDocument * pXMLDoc = NULL;
IXMLDOMElement * pXDE = NULL;
IXMLDOMNode * pXDN = NULL;
HRESULT hr;
BSTR queryString, nodeContent;
TCHAR errorMsg[MAX_PATH + 50];
if(fragmentShader) {
glDetachShader(shaderProgram,fragmentShader);
glDeleteShader(fragmentShader);
fragmentShader = 0;
}
if(vertexShader) {
glDetachShader(shaderProgram,vertexShader);
glDeleteShader(vertexShader);
vertexShader = 0;
}
if(shaderProgram) {
glUseProgram(0);
glDeleteProgram(shaderProgram);
shaderProgram = 0;
}
if(glslFileName==NULL || *glslFileName==TEXT('\0'))
return true;
if(!LoadShaderFunctions()) {
MessageBox(NULL, TEXT("Unable to load OpenGL shader functions"), TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
hr = CoCreateInstance(CLSID_DOMDocument,NULL,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&pXMLDoc));
if(FAILED(hr)) {
MessageBox(NULL, TEXT("Error creating XML Parser"), TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
VARIANT fileName;
VARIANT_BOOL ret;
fileName.vt = VT_BSTR;
#ifdef UNICODE
fileName.bstrVal = SysAllocString(glslFileName);
#else
wchar_t tempfilename[MAX_PATH];
MultiByteToWideChar(CP_UTF8,0,glslFileName,-1,tempfilename,MAX_PATH);
fileName.bstrVal = SysAllocString(tempfilename);
#endif
hr = pXMLDoc->load(fileName,&ret);
SysFreeString(fileName.bstrVal);
if(FAILED(hr) || hr==S_FALSE) {
_stprintf(errorMsg,TEXT("Error loading GLSL shader file:\n%s"),glslFileName);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
pXMLDoc->Release();
return false;
}
VARIANT attributeValue;
BSTR attributeName;
hr = pXMLDoc->get_documentElement(&pXDE);
if(FAILED(hr) || hr==S_FALSE) {
_stprintf(errorMsg,TEXT("Error loading root element from file:\n%s"),glslFileName);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
pXMLDoc->Release();
return false;
}
attributeName=SysAllocString(L"language");
pXDE->getAttribute(attributeName,&attributeValue);
SysFreeString(attributeName);
pXDE->Release();
if(attributeValue.vt!=VT_BSTR || lstrcmpiW(attributeValue.bstrVal,L"glsl")) {
_stprintf(errorMsg,TEXT("Shader language is <%s>, expected <GLSL> in file:\n%s"),attributeValue.bstrVal,glslFileName);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal);
pXMLDoc->Release();
return false;
}
if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal);
queryString=SysAllocString(L"/shader/fragment");
hr = pXMLDoc->selectSingleNode(queryString,&pXDN);
SysFreeString(queryString);
if(hr == S_OK) {
hr = pXDN->get_text(&nodeContent);
if(hr == S_OK) {
int requiredChars = WideCharToMultiByte(CP_ACP,0,nodeContent,-1,fragment,0,NULL,NULL);
fragment = new char[requiredChars];
WideCharToMultiByte(CP_UTF8,0,nodeContent,-1,fragment,requiredChars,NULL,NULL);
}
SysFreeString(nodeContent);
pXDN->Release();
pXDN = NULL;
}
queryString=SysAllocString(L"/shader/vertex");
hr = pXMLDoc->selectSingleNode(queryString,&pXDN);
SysFreeString(queryString);
if(hr == S_OK) {
hr = pXDN->get_text(&nodeContent);
if(hr == S_OK) {
int requiredChars = WideCharToMultiByte(CP_ACP,0,nodeContent,-1,vertex,0,NULL,NULL);
vertex = new char[requiredChars];
WideCharToMultiByte(CP_UTF8,0,nodeContent,-1,vertex,requiredChars,NULL,NULL);
}
SysFreeString(nodeContent);
pXDN->Release();
pXDN = NULL;
}
pXMLDoc->Release();
if(!fragment && !vertex) {
_stprintf(errorMsg,TEXT("No vertex or fragment program in file:\n%s"),glslFileName);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
return false;
}
shaderProgram = glCreateProgram ();
if(vertex) {
vertexShader = glCreateShader (GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, (const GLchar **)&vertex, NULL);
glCompileShader(vertexShader);
glAttachShader(shaderProgram, vertexShader);
delete[] vertex;
}
if(fragment) {
fragmentShader = glCreateShader (GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, (const GLchar **)&fragment, NULL);
glCompileShader(fragmentShader);
glAttachShader(shaderProgram, fragmentShader);
delete[] fragment;
}
glLinkProgram(shaderProgram);
glUseProgram(shaderProgram);
shader_type = OGL_SHADER_GLSL;
return true;
}
bool CDirect3D::SetShaderHLSL(const TCHAR *file)
{
//MUDLORD: the guts
//Compiles a shader from files on disc
//Sets LUT textures to texture files in PNG format.
TCHAR folder[MAX_PATH];
TCHAR rubyLUTfileName[MAX_PATH];
TCHAR *slash;
char *shaderText = NULL;
TCHAR errorMsg[MAX_PATH + 50];
IXMLDOMDocument * pXMLDoc = NULL;
IXMLDOMElement * pXDE = NULL;
IXMLDOMNode * pXDN = NULL;
BSTR queryString, nodeContent;
HRESULT hr;
shaderTimer = 1.0f;
shaderTimeStart = 0;
shaderTimeElapsed = 0;
if(effect) {
effect->Release();
effect = NULL;
}
for(int i = 0; i < MAX_SHADER_TEXTURES; i++) {
if (rubyLUT[i] != NULL) {
rubyLUT[i]->Release();
rubyLUT[i] = NULL;
}
}
if (file == NULL || *file==TEXT('\0'))
return true;
hr = CoCreateInstance(CLSID_DOMDocument,NULL,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&pXMLDoc));
if(FAILED(hr)) {
MessageBox(NULL, TEXT("Error creating XML Parser"), TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
VARIANT fileName;
VARIANT_BOOL ret;
fileName.vt = VT_BSTR;
#ifdef UNICODE
fileName.bstrVal = SysAllocString(file);
#else
wchar_t tempfilename[MAX_PATH];
MultiByteToWideChar(CP_UTF8,0,file,-1,tempfilename,MAX_PATH);
fileName.bstrVal = SysAllocString(tempfilename);
#endif
hr = pXMLDoc->load(fileName,&ret);
SysFreeString(fileName.bstrVal);
if(FAILED(hr) || hr==S_FALSE) {
_stprintf(errorMsg,TEXT("Error loading HLSL shader file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
pXMLDoc->Release();
return false;
}
VARIANT attributeValue;
BSTR attributeName;
hr = pXMLDoc->get_documentElement(&pXDE);
if(FAILED(hr) || hr==S_FALSE) {
_stprintf(errorMsg,TEXT("Error loading root element from file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
pXMLDoc->Release();
return false;
}
attributeName=SysAllocString(L"language");
pXDE->getAttribute(attributeName,&attributeValue);
SysFreeString(attributeName);
pXDE->Release();
if(attributeValue.vt!=VT_BSTR || lstrcmpiW(attributeValue.bstrVal,L"hlsl")) {
_stprintf(errorMsg,TEXT("Shader language is <%s>, expected <HLSL> in file:\n%s"),attributeValue.bstrVal,file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal);
pXMLDoc->Release();
return false;
}
if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal);
queryString=SysAllocString(L"/shader/source");
hr = pXMLDoc->selectSingleNode(queryString,&pXDN);
SysFreeString(queryString);
if(hr == S_OK) {
hr = pXDN->get_text(&nodeContent);
if(hr == S_OK) {
int requiredChars = WideCharToMultiByte(CP_ACP,0,nodeContent,-1,shaderText,0,NULL,NULL);
shaderText = new char[requiredChars];
WideCharToMultiByte(CP_UTF8,0,nodeContent,-1,shaderText,requiredChars,NULL,NULL);
}
SysFreeString(nodeContent);
pXDN->Release();
pXDN = NULL;
}
pXMLDoc->Release();
if(!shaderText) {
_stprintf(errorMsg,TEXT("No HLSL shader program in file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
LPD3DXBUFFER pBufferErrors = NULL;
hr = D3DXCreateEffect( pDevice,shaderText,strlen(shaderText),NULL, NULL,
D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY, NULL, &effect,
&pBufferErrors );
delete[] shaderText;
if( FAILED(hr) ) {
_stprintf(errorMsg,TEXT("Error parsing HLSL shader file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
if(pBufferErrors) {
LPVOID pCompilErrors = pBufferErrors->GetBufferPointer();
MessageBox(NULL, (const TCHAR*)pCompilErrors, TEXT("FX Compile Error"),
MB_OK|MB_ICONEXCLAMATION);
}
return false;
}
lstrcpy(folder,file);
slash = _tcsrchr(folder,TEXT('\\'));
if(slash)
*(slash+1)=TEXT('\0');
else
*folder=TEXT('\0');
SetCurrentDirectory(S9xGetDirectoryT(DEFAULT_DIR));
for(int i = 0; i < MAX_SHADER_TEXTURES; i++) {
_stprintf(rubyLUTfileName, TEXT("%srubyLUT%d.png"), folder, i);
hr = D3DXCreateTextureFromFile(pDevice,rubyLUTfileName,&rubyLUT[i]);
if FAILED(hr){
rubyLUT[i] = NULL;
}
}
D3DXHANDLE hTech;
effect->FindNextValidTechnique(NULL,&hTech);
effect->SetTechnique( hTech );
shader_type = D3D_SHADER_HLSL;
return true;
}
HRESULT CPageEvents::UpdateItemFromNode(LPARAM lNode)
{
USES_CONVERSION;
// Typecast the tree item's param as an XML element pointer
IXMLDOMElement* pElement = reinterpret_cast<IXMLDOMElement*>(lNode);
if (!pElement)
return S_FALSE;
// Use to enable/disable the check boxes
bool bEnableLog2NT = false;
bool bEnableLog2DB = false;
// Determine if the node is a group element or an event
CComBSTR bstrTagName;
VERIFY(SUCCEEDED(pElement->get_tagName(&bstrTagName)));
bool bIsEvent = 0 == wcscmp(bstrTagName, m_bstrEvent);
bool bIsGroup = !bIsEvent && 0 == wcscmp(bstrTagName, m_bstrEventGroup);
ASSERT(bIsEvent || bIsGroup);
if (bIsEvent)
{
// Get the Severity attribute
CComVariant varSeverity;
pElement->getAttribute(m_bstrSeverity, &varSeverity);
VERIFY(SUCCEEDED(varSeverity.ChangeType(VT_BSTR)));
SetDlgItemText(IDC_EVENT_TYPE, TypeFromSeverity(V_BSTR(&varSeverity)));
// Get the event id attribute
CComVariant varEventID;
pElement->getAttribute(m_bstrID, &varEventID);
VERIFY(SUCCEEDED(varEventID.ChangeType(VT_I4)));
SetDlgItemInt(IDC_EVENT_ID, V_I4(&varEventID));
// Get the CanChangeLogAsNTEvent attribute
IXMLDOMAttributePtr spAttrNT;
if (S_OK == pElement->getAttributeNode(m_bstrCanChangeLogAsNTEvent, &spAttrNT))
{
CComVariant varCanChange;
spAttrNT->get_value(&varCanChange);
VERIFY(SUCCEEDED(varCanChange.ChangeType(VT_BOOL)));
bEnableLog2NT = !!V_BOOL(&varCanChange);
}
else
{
// When not specified, the default is true
bEnableLog2NT = true;
}
// Get the LogAsNTEvent attribute
CComVariant varLog2NT;
pElement->getAttribute(m_bstrLogAsNTEvent, &varLog2NT);
VERIFY(SUCCEEDED(varLog2NT.ChangeType(VT_BOOL)));
CheckDlgButton(IDC_LOG2NT, V_BOOL(&varLog2NT));
// Get the CanChangeLogAsDBEvent attribute
IXMLDOMAttributePtr spAttrDB;
if (S_OK == pElement->getAttributeNode(m_bstrCanChangeLogAsDBEvent, &spAttrDB))
{
CComVariant varCanChange;
spAttrDB->get_value(&varCanChange);
VERIFY(SUCCEEDED(varCanChange.ChangeType(VT_BOOL)));
bEnableLog2DB = !!V_BOOL(&varCanChange);
}
else
{
// When not specified, the default is true
bEnableLog2DB = true;
}
// Get the LogAsDBEvent attribute
CComVariant varLog2DB;
pElement->getAttribute(m_bstrLogAsDBEvent, &varLog2DB);
VERIFY(SUCCEEDED(varLog2DB.ChangeType(VT_BOOL)));
CheckDlgButton(IDC_LOG2DB, V_BOOL(&varLog2DB));
}
else
{
// Always show the type as "Group"
CString strGroup;
strGroup.LoadString(IDS_TYPE_GROUP);
SetDlgItemText(IDC_EVENT_TYPE, strGroup);
// Get the group LowerBound attribute
CComVariant varLowerBound;
pElement->getAttribute(m_bstrLowerBound, &varLowerBound);
VERIFY(SUCCEEDED(varLowerBound.ChangeType(VT_UI4)));
// Get the group UpperBound attribute
CComVariant varUpperBound;
pElement->getAttribute(m_bstrUpperBound, &varUpperBound);
VERIFY(SUCCEEDED(varUpperBound.ChangeType(VT_UI4)));
// Format the group's range into a string
TCHAR szID[_MAX_PATH];
wsprintf(szID, TEXT("%u - %u"), V_UI4(&varLowerBound),
V_UI4(&varUpperBound));
SetDlgItemText(IDC_EVENT_ID, szID);
// TODO: Work-out how to best support indeterminate checkbox state
CheckDlgButton(IDC_LOG2NT, false);
CheckDlgButton(IDC_LOG2DB, false);
}
// Get the event/group Description attribute
CComVariant varDescription;
pElement->getAttribute(m_bstrDescription, &varDescription);
VERIFY(SUCCEEDED(varDescription.ChangeType(VT_BSTR)));
SetDlgItemText(IDC_DESCRIPTION, OLE2CT(V_BSTR(&varDescription)));
// Enable/disable checkboxes
GetDlgItem(IDC_LOG2NT)->EnableWindow(bEnableLog2NT);
GetDlgItem(IDC_LOG2DB)->EnableWindow(bEnableLog2DB);
// Uncheck checkboxes that are disabled
if (!bEnableLog2NT)
CheckDlgButton(IDC_LOG2NT, false);
if (!bEnableLog2DB)
CheckDlgButton(IDC_LOG2DB, false);
// Indicate success
return S_OK;
}
