int SampWrite( void FAR_PTR *buff, unsigned len )
{
unsigned written;
int handle;
int rc;
_fstrcpy( SampName, SharedMemory->SampName );
if( SharedMemory->SampleHandle == 0 ) {
handle = SysCreate( SampName );
SharedMemory->SampleHandle = 1;
} else {
handle = SysOpen( SampName );
if( handle >= 0 ) SysSeek( handle, SharedMemory->SampOffset );
}
if( handle == -1 ) {
SharedMemory->FarWriteProblem = 1;
return( -1 );
}
written = SysWrite( handle, buff, len );
if( written == len ) {
SharedMemory->SampOffset += len;
rc = 0;
} else {
SysSeek( handle, SharedMemory->SampOffset );
SysWrite( handle, "", 0 );
SharedMemory->FarWriteProblem = 1;
rc = -1;
}
SysClose( handle );
return( rc );
} /* SampWrite */
void Output( char FAR_PTR *str )
{
char FAR_PTR *p = str;
int len = 0;
while( *p++ ) ++len;
SysWrite( 2, str, len );
}
void Output( const char FAR_PTR *str )
{
const char FAR_PTR *p = str;
unsigned len = 0;
while( *p++ != '\0' )
++len;
SysWrite( 2, str, len );
}
ssize_t write(int fd,const void* buf,size_t count)
{
void* buffer=(void*)buf;
ssize_t ret = SysWrite(fd, buffer, count);
if (ret < 0)
{
errno=-ret;
ret=-1;
}
return ret;
}
int SampWrite( void FAR_PTR *buff, unsigned len )
{
LONG written;
if( SampIsDOS ) {
DOSWrite( SampleHandle, SampOffset, buff, len, &written );
} else {
written = SysWrite( SampleHandle, buff, len );
}
if( written == len ) {
SampOffset += len;
return( 0 );
} else {
if( SampIsDOS ) {
DOSWrite( SampleHandle, SampOffset, buff, 0, &written );
} else {
SysSeek( SampleHandle, SampOffset );
SysWrite( SampleHandle, "", 0 ); /* truncate the file */
}
FarWriteProblem = 1;
return( -1 );
}
}
void Closef( b_file *io ) {
// Close a file.
uint cc_len;
char *cc;
if( io->attrs & CARRIAGE_CONTROL ) {
cc_len = FSetCC( io, ' ', &cc );
if( SysWrite( io, cc, cc_len ) == -1 ) return;
}
if( FlushBuffer( io ) < 0 ) return;
if( close( io->handle ) < 0 ) {
FSetSysErr( io );
return;
}
MEM_FREE( io );
IOOk( NULL );
}
EResult CompileShader(
const char * szFileName,
const char * szSource,
const char * szEntryPoint,
const char * szProfile,
ID3D10Blob ** ppShaderByteCode )
{
if ( ( NULL == szFileName ) || ( NULL == szSource ) || ( NULL == ppShaderByteCode ) )
return R_INVALID_ARG;
size_t nSize = strlen( szSource );
if ( 0 == nSize )
return R_INVALID_ARG;
ID3D10Blob * pErrorMsg = NULL;
HRESULT hRes = D3D10CompileShader(
szSource, // file data
nSize, // file data size
NULL, // file name (set to null if prev args not null)
NULL, // macro array (defines)
NULL, // ? include
szEntryPoint,
szProfile,
0, // shader compile flags
ppShaderByteCode,
&pErrorMsg );
if ( FAILED( hRes ) )
{
if ( NULL != pErrorMsg )
{
const char * szErr = Va(
"\tShader compilation failed, file \"%s\"\n\t\t%s",
szFileName, (const char *)pErrorMsg->GetBufferPointer() );
SysWrite( szErr );
DEBUG_MSG( szErr );
}
return R_GENERIC_ERROR;
}
return R_OK;
}
void CShaderCfgLoader::FinalizeRes( TResource * pRes )
{
pRes->eState = TResource::FAILED;
//--------------------------------------------------------------------------
// Tip: Check XMLWrapper
//--------------------------------------------------------------------------
IXMLWrapper * pWrapper = (IXMLWrapper *)g_pSystem->GetInterface( IT_UTIL );
if ( !pWrapper )
return;
CXMLElement * pRoot = NULL;
pWrapper->LoadXMLFromMem( (char *)pRes->pBuffer, pRes->nSize, &pRoot );
DEL_ARRAY( pRes->pBuffer );
//pRes->pResource = pRoot;
//--------------------------------------------------------------------------
// Tip: Check root element name
//--------------------------------------------------------------------------
CStr sName( pRoot->GetName() );
if ( !sName.Compare( "Shaders" ) )
{
DEL( pRoot );
return;
}
//--------------------------------------------------------------------------
// Tip: Parsing shaders
//--------------------------------------------------------------------------
for ( size_t i = 0; i < pRoot->GetNumChilds(); ++i )
{
//----------------------------------------------------------------------
// Tip: New shader
//----------------------------------------------------------------------
CXMLElement * pShaderBranch = pRoot->GetChild( i );
CStr sPath( "Shaders/" );
sPath.Add( pShaderBranch->GetName() );
// const CStr sShader( pShaderBranch->GetName() );
// CBaseShader * pShader = NEW CBaseShader( sShader.GetString() );
// CXMLAttr * pProgPath = pShaderBranch->GetAttr( "ProgramPath" );
// CStr sProgPath( pProgPath->GetValue() );
SysWrite( Va( "\tshader %s", pShaderBranch->GetName() ) );
IVertexDecl * pDecl = NULL;
TUniform * pUniforms = NULL;
uint nUnfmCount = 0;
//----------------------------------------------------------------------
// Tip: Parse shader data
//----------------------------------------------------------------------
for ( size_t j = 0; j < pShaderBranch->GetNumChilds(); ++j )
{
CXMLElement * pStruct = pShaderBranch->GetChild( j );
const CStr sStruct( pStruct->GetName() );
if ( sStruct.Compare( "VertexFormat" ) )
{
pDecl = ParseVertexFormat( pStruct );
}
else if ( sStruct.Compare( "Constants" ) )
{
/*
pShader->m_nUniformCount = 1;
pShader->m_pUniforms = NEW CBaseShader::TUniform [ pShader->m_nUniformCount ];
pShader->m_pUniforms[ 0 ].sName = "vColorMod";
pShader->m_pUniforms[ 0 ].eType = TYPE_VEC4;
pShader->m_pUniforms[ 0 ].nLoc = pShader->GetUniformLoc( pShader->m_pUniforms[ 0 ].sName );
pShader->m_pUniforms[ 0 ].nCount = 1;
m_ppShaders[ UI_SHADER ] = pShader;
*/
nUnfmCount = ParseConstants( pStruct, &pUniforms );
//pShader->ParseMaps( pStruct );
}
}
g_pRenderer->CreateShader( sPath.GetString(), pDecl, pUniforms, nUnfmCount );
}
DEL( pRoot );
pRes->eState = TResource::LOADED;
}
void CModel::LoadObjects( const char * szFile )
{
const int nFileVer = 1;
IFile * pFile;
if ( R_OK != g_pVfs->OpenFile( &pFile, szFile, VFS_BINARY | VFS_READ ) )
{
SysWrite( Va( "Failed to open model file \"%s\"", szFile ) );
return;
}
TModelFileHdr tFileHdr;
//--------------------------------------------------------------------------
// Tip: Читаем заголовок MODEL файла
//--------------------------------------------------------------------------
if ( !g_pVfs->CheckRead( pFile, &tFileHdr, sizeof( TModelFileHdr ) ) )
{
// invalid file
goto error_label;
}
if ( /*( 0 != strcmp( "MDL ", (char *)&tFileHdr.nSign ) ) ||*/
( 0 == tFileHdr.nNumObjects ) ||
( nFileVer != tFileHdr.nVersion ) ||
( sizeof( TModelFileHdr ) != tFileHdr.nHeaderSize ) )
{
// invalid file or no objects
goto error_label;
}
m_nNumObjects = tFileHdr.nNumObjects;
m_pObjects = NEW CObject [ m_nNumObjects ];
if ( NULL == m_pObjects )
goto error_label;
//--------------------------------------------------------------------------
// Tip: Читаем mesh
//--------------------------------------------------------------------------
{
TObjectHdr tMeshHdr;
g_pVfs->Read( pFile, &tMeshHdr, sizeof( TObjectHdr ) );
}
m_pShape = g_pEngine->CreateMesh();
m_pShape->LoadFromStream( pFile );
m_pBoneMatrices = NEW mat4[ m_nNumObjects ];
//--------------------------------------------------------------------------
// Tip: Читаем объекты
//--------------------------------------------------------------------------
for ( uint nObj = 0; nObj < m_nNumObjects; ++nObj )
{
TObjectHdr tObjHdr;
CObject * pObject = m_pObjects + nObj;
// Читаем заголовок объекта
if ( sizeof ( TObjectHdr ) != g_pVfs->Read( pFile, &tObjHdr, sizeof( TObjectHdr ) ) )
{
goto error_label;
}
pObject->SetParentName( tObjHdr.szParent );
pObject->SetName( tObjHdr.szName );
pObject->SetScale( tObjHdr.vScale );
pObject->SetPos( tObjHdr.vPos );
pObject->SetRot( tObjHdr.qRot );
////////////////////////////////////////////////////////////////////////
/*switch ( tObjHdr.eType )
{
default:
{
g_pVfs->Seek( pFile, tObjHdr.nShapeBlockSize, VFS_SEEK_CUR );
continue;
}
}*/
}
RebuildHierarchy();
g_pVfs->CloseFile( &pFile );
return;
//--------------------------------------------------------------------------
// Tip: Поведение кода в случае ошибки при разборе файла
//--------------------------------------------------------------------------
error_label:
m_nNumObjects = 0;
g_pVfs->CloseFile( &pFile );
}
