예제 #1
0
bool MeshLoaderB3D::Load(const char* file) {
	_file = new lfFile;
	if( !_file->Open(file) )
		return false;

	_mesh = new Mesh;
	lfStr head = ReadChunk();
	int nB3DVersion = _file->ReadInt();

	Sys_Printf("load b3d file %s, version %s %d\n", file, head.c_str(), nB3DVersion);

	while( CheckSize() ) {
		lfStr t = ReadChunk();
		if (t == "TEXS")
			ReadTexs();
		else if (t == "BRUS")
			ReadBrus();
		else if (t == "NODE")
			_mesh->SetJoint(ReadNode());

		ExitChunk();
	}

	delete _file;
	_file = NULL;

	// The MESH chunk describes a mesh. 
	// A mesh only has one VRTS chunk, but potentially many TRIS chunks.
	srfTriangles_t* tri = _mesh->GetGeometries(0);
	tri->numIndices = _indices.size();
	_indices.set_free_when_destroyed(false);
	tri->indices = _indices.pointer();

	return true;
}
예제 #2
0
void MeshLoaderB3D::ReadBrus()
{
	int n_texs;
	_file->ReadInt(n_texs);
	if( n_texs<0 || n_texs>8 ){
		printf( "Bad texture count" );
	}
	while( CheckSize() ){
		idStr name;
		readString(_file, name);
		PrintTree(name.c_str());
		idVec3 color;
		_file->ReadVec3(color);
		float alpha;
		_file->ReadFloat(alpha);
		float shiny;
		_file->ReadFloat(shiny);
		int blend;
		/*int blend=**/_file->ReadInt(blend);
		int fx;
		_file->ReadInt(fx);

		//Textures
		for( int i=0;i<n_texs;++i ){
			int texid;
			_file->ReadInt(texid);
		}
	}
}
예제 #3
0
// ------------------------------------------------
// LogLit
// ------------------------------------------------
//
void CMdSLogger::LogLit( const TDesC8& aText )
    {
    if (!iValid)
    	{
    	return;
    	}

    TInt offset = 0;
    TInt linecount = 0;
    TInt length = aText.Length();
    while( offset < length )
        {
        TInt partLength = Min( length-offset, KLineLength );
#ifdef MDE_FILE_LOGGING
        iLog.Write( aText.Mid( offset, partLength ) );
#else
        TBuf<KLineLength> buffer;
        buffer.Copy( aText.Mid( offset, partLength ) );
        RDebug::Print( buffer );
#endif
        ++linecount;
        offset += partLength;
        }
    CheckSize( linecount );
    }
예제 #4
0
static BOOL
CopySections(const unsigned char *data, size_t size, PIMAGE_NT_HEADERS old_headers, PMEMORYMODULE module)
{
    int i, section_size;
    unsigned char *codeBase = module->codeBase;
    unsigned char *dest;
    PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(module->headers);
    for (i=0; i<module->headers->FileHeader.NumberOfSections; i++, section++) {
        if (section->SizeOfRawData == 0) {
            // section doesn't contain data in the dll itself, but may define
            // uninitialized data
            section_size = old_headers->OptionalHeader.SectionAlignment;
            if (section_size > 0) {
                dest = (unsigned char *)module->alloc(codeBase + section->VirtualAddress,
                    section_size,
                    MEM_COMMIT,
                    PAGE_READWRITE,
                    module->userdata);
                if (dest == NULL) {
                    return FALSE;
                }

                // Always use position from file to support alignments smaller
                // than page size (allocation above will align to page size).
                dest = codeBase + section->VirtualAddress;
                // NOTE: On 64bit systems we truncate to 32bit here but expand
                // again later when "PhysicalAddress" is used.
                section->Misc.PhysicalAddress = (DWORD) ((uintptr_t) dest & 0xffffffff);
                memset(dest, 0, section_size);
            }

            // section is empty
            continue;
        }

        if (!CheckSize(size, section->PointerToRawData + section->SizeOfRawData)) {
            return FALSE;
        }

        // commit memory block and copy data from dll
        dest = (unsigned char *)module->alloc(codeBase + section->VirtualAddress,
                            section->SizeOfRawData,
                            MEM_COMMIT,
                            PAGE_READWRITE,
                            module->userdata);
        if (dest == NULL) {
            return FALSE;
        }

        // Always use position from file to support alignments smaller
        // than page size (allocation above will align to page size).
        dest = codeBase + section->VirtualAddress;
        memcpy(dest, data + section->PointerToRawData, section->SizeOfRawData);
        // NOTE: On 64bit systems we truncate to 32bit here but expand
        // again later when "PhysicalAddress" is used.
        section->Misc.PhysicalAddress = (DWORD) ((uintptr_t) dest & 0xffffffff);
    }

    return TRUE;
}
예제 #5
0
void ff::Dict::SetValue(ff::StringRef name, ff::Value *value)
{
	if (value)
	{
		if (_propsLarge != nullptr)
		{
			hash_t hash = GetAtomizer().CacheString(name);
			_propsLarge->SetKey(hash, value);
		}
		else
		{
			_propsSmall.Set(name, value);
			CheckSize();
		}
	}
	else if (_propsLarge != nullptr)
	{
		hash_t hash = GetAtomizer().CacheString(name);
		_propsLarge->DeleteKey(hash);
	}
	else
	{
		_propsSmall.Remove(name);
	}
}
예제 #6
0
void MeshLoaderB3D::ReadKey(Joint* joint)
{
	int flags = _file->ReadInt();
	while( CheckSize() ){
		int frame = _file->ReadInt();
		if (flags & 1){
			PositionKey k;
			k.position = _file->ReadVec3();
			k.frame = frame;
			joint->positionKeys.push_back(k);
		}
		if( flags & 2 ){
			ScaleKey k;
			k.position = _file->ReadVec3();
			k.frame = frame;
			joint->scaleKeys.push_back(k);
		}
		if( flags & 4 ){
			Quat r = _file->ReadQuat();
			r.w = -r.w; // fix bug
			RotationKey k;
			k.rotation = r;
			k.frame = frame;
			joint->rotationKeys.push_back(k);
		}
	}
}
예제 #7
0
파일: tab.c 프로젝트: wesgarner/wine
static void test_misc(HWND parent_wnd, INT nTabs)
{
    HWND hTab;
    RECT rTab;
    INT nTabsRetrieved;
    INT rowCount;
    INT dpi;
    HDC hdc;

    ok(parent_wnd != NULL, "no parent window!\n");
    flush_sequences(sequences, NUM_MSG_SEQUENCES);

    hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
    ok(hTab != NULL, "Failed to create tab control\n");

    if(!winetest_interactive)
        ok_sequence(sequences, TAB_SEQ_INDEX, add_tab_to_parent,
                    "Tab sequence, after adding tab control to parent", TRUE);
    else
        ok_sequence(sequences, TAB_SEQ_INDEX, add_tab_to_parent_interactive,
                    "Tab sequence, after adding tab control to parent", TRUE);

    if(!winetest_interactive)
        ok_sequence(sequences, PARENT_SEQ_INDEX, add_tab_control_parent_seq,
                    "Parent after sequence, adding tab control to parent", TRUE);
    else
        ok_sequence(sequences, PARENT_SEQ_INDEX, add_tab_control_parent_seq_interactive,
                    "Parent after sequence, adding tab control to parent", TRUE);

    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ok(SendMessage(hTab, TCM_SETMINTABWIDTH, 0, -1) > 0,"TCM_SETMINTABWIDTH returned < 0\n");
    ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Set minTabWidth test parent sequence", FALSE);

    /* Testing GetItemCount */
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
    expect(nTabs, nTabsRetrieved);
    ok_sequence(sequences, TAB_SEQ_INDEX, get_item_count_seq, "Get itemCount test sequence", FALSE);
    ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset itemCount test parent sequence", FALSE);

    /* Testing GetRowCount */
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    rowCount = SendMessage(hTab, TCM_GETROWCOUNT, 0, 0);
    expect(1, rowCount);
    ok_sequence(sequences, TAB_SEQ_INDEX, get_row_count_seq, "Get rowCount test sequence", FALSE);
    ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Get rowCount test parent sequence", FALSE);

    /* Testing GetItemRect */
    flush_sequences(sequences, NUM_MSG_SEQUENCES);
    ok(SendMessage(hTab, TCM_GETITEMRECT, 0, (LPARAM) &rTab), "GetItemRect failed.\n");

    hdc = GetDC(hTab);
    dpi = GetDeviceCaps(hdc, LOGPIXELSX);
    ReleaseDC(hTab, hdc);
    CheckSize(hTab, dpi, -1 , "Default Width");
    ok_sequence(sequences, TAB_SEQ_INDEX, get_item_rect_seq, "Get itemRect test sequence", FALSE);
    ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Get itemRect test parent sequence", FALSE);

    DestroyWindow(hTab);
}
예제 #8
0
void TSessionLog::DoAddToSelf(TLogLineType Type, UnicodeString ALine)
{
  if (LogToFile()) { try
  {
    if (FLogger == nullptr)
    {
      OpenLogFile();
    }

    if (FLogger != nullptr)
    {
      UnicodeString Timestamp = FormatDateTime(L" yyyy-mm-dd hh:nn:ss.zzz ", Now());
      UTF8String UtfLine = UTF8String(UnicodeString(LogLineMarks[Type]) + Timestamp + TrimRight(ALine)) + "\r\n";
#if 0
      for (intptr_t Index = 1; Index <= UtfLine.Length(); Index++)
      {
        if ((UtfLine[Index] == '\n') &&
            (UtfLine[Index - 1] != '\r'))
        {
          UtfLine.Insert(L'\r', Index);
        }
      }
#endif // #if 0
      intptr_t ToWrite = UtfLine.Length();
      CheckSize(ToWrite);
      FCurrentFileSize += FLogger->Write(UtfLine.c_str(), ToWrite);
    }}
    catch (...)
    {
      // TODO: log error
      DEBUG_PRINTF("TSessionLog::DoAddToSelf: error");
    }
  }
}
void Auddrv_UL_Interrupt_Handler(void)  // irq1 ISR handler
{
    unsigned long flags;
    kal_uint32 Afe_Dac_Con0 = Afe_Get_Reg(AFE_DAC_CON0);
    AFE_MEM_CONTROL_T *Mem_Block = &VUL_Control_context;
    AFE_BLOCK_T *Vul_Block = &(VUL_Control_context.rBlock);

    //printk("Auddrv_UL_Interrupt_Handler \n ");
    kal_uint32 HW_Cur_ReadIdx = 0;
    kal_int32 Hw_Get_bytes = 0;
    AFE_BLOCK_T  *mBlock = NULL;

    if (Mem_Block == NULL)
    {
        printk("Mem_Block == NULL  \n ");
        return;
    }
    mBlock = &Mem_Block->rBlock;
    HW_Cur_ReadIdx = Afe_Get_Reg(AFE_VUL_CUR);
    //printk("Auddrv_UL_Interrupt_Handler HW_Cur_ReadIdx = 0x%x\n ", HW_Cur_ReadIdx);

    if (CheckSize(HW_Cur_ReadIdx))
    {
        return;
    }
    if (mBlock->pucVirtBufAddr  == NULL)
    {
        return;
    }

    // HW already fill in
    Hw_Get_bytes = (HW_Cur_ReadIdx - mBlock->pucPhysBufAddr) - mBlock->u4WriteIdx;
    if (Hw_Get_bytes < 0)
    {
        Hw_Get_bytes += mBlock->u4BufferSize;
    }
    /*
    printk("Auddrv_Handle_Mem_context Hw_Get_bytes:%x, HW_Cur_ReadIdx:%x, u4DMAReadIdx:%x, u4WriteIdx:0x%x, pucPhysBufAddr:%x Mem_Block->MemIfNum = %d \n",
           Hw_Get_bytes, HW_Cur_ReadIdx, mBlock->u4DMAReadIdx, mBlock->u4WriteIdx, mBlock->pucPhysBufAddr, Mem_Block->MemIfNum);*/

    mBlock->u4WriteIdx  += Hw_Get_bytes;
    mBlock->u4WriteIdx  %= mBlock->u4BufferSize;
    mBlock->u4DataRemained += Hw_Get_bytes;

    // buffer overflow
    if (mBlock->u4DataRemained > mBlock->u4BufferSize)
    {
        printk("Auddrv_Handle_Mem_context buffer overflow u4DMAReadIdx:%x, u4WriteIdx:%x, u4DataRemained:%x, u4BufferSize:%x \n",
               mBlock->u4DMAReadIdx, mBlock->u4WriteIdx, mBlock->u4DataRemained, mBlock->u4BufferSize);
        mBlock->u4DataRemained = mBlock->u4BufferSize / 2;
        mBlock->u4DMAReadIdx = mBlock->u4WriteIdx - mBlock->u4BufferSize / 2;
        if (mBlock->u4DMAReadIdx < 0)
        {
            mBlock->u4DMAReadIdx += mBlock->u4BufferSize;
        }
    }
    snd_pcm_period_elapsed(prtdtemp->substream);
    InterruptTrigger = 1;
}
예제 #10
0
MemStream::MemStream( size_t sz0 )
{
    pos = 0;
    len = 0;
    maxLen = len;
    data = NULL;
    CheckSize(sz0);
}
예제 #11
0
void ListedTextItems::Insert(const Text& text)
{
    __Item item;
    item._caption = text;
    item._state = 0;
    _items.Insert(item);
    CheckSize(text);
}
예제 #12
0
파일: tab.c 프로젝트: carlosbislip/wine
static void TabCheckSetSize(HWND hwnd, INT set_width, INT set_height, INT exp_width,
    INT exp_height, const char *msg, int line)
{
    SendMessage(hwnd, TCM_SETITEMSIZE, 0,
	(LPARAM) MAKELPARAM((set_width >= 0) ? set_width : 0, (set_height >= 0) ? set_height : 0));
    if (winetest_interactive) RedrawWindow (hwnd, NULL, 0, RDW_UPDATENOW);
    CheckSize(hwnd, exp_width, exp_height, msg, line);
}
예제 #13
0
void ListedTextItems::SetText( int item_no, const Text &text )
{
    if ( item_no >=0 && item_no<GetNumItems() )  
    { 
        GetItem(item_no)._caption=text; 
        CheckSize(text);
    }
}
예제 #14
0
int CTextureManager::LoadTextureFromMemory (UBYTE *pData, int nWidth, int nHeight, int nBPP, int nTextureID) {

	// First we do ALOT of error checking on the data...
	if (!CheckSize (nWidth) || !CheckSize (nHeight)) {
		sprintf (m_Singleton->szErrorMessage, "ERROR : Improper Dimension");
		return -1;
	}
	if (nBPP != 3 && nBPP != 4) {
		sprintf (m_Singleton->szErrorMessage, "ERROR : Unsuported Color Depth");
		return -1;
	}

	// I guess were good to go...
	// ---------------------------------------------------------------------
	int nNewTextureID = GetNewTextureID (nTextureID);	// Also increases nNumTextures!

	// Register and upload the texture in OpenGL
	glBindTexture (GL_TEXTURE_2D, nNewTextureID);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

	//Method1
	//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,  nWidth, nHeight, 0,  nBPP == 3 ? GL_BGR_EXT : GL_BGRA_EXT, GL_UNSIGNED_BYTE, pData);

	//Method2
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,  nWidth, nHeight, 0,  nBPP == 3 ? GL_BGR_EXT : GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
	glTexSubImage2D(GL_TEXTURE_2D, 0, 0,0,nWidth, nHeight, nBPP == 3 ? GL_BGR_EXT : GL_BGRA_EXT,GL_UNSIGNED_BYTE, pData);

	//Method3
	//gluBuild2DMipmaps (GL_TEXTURE_2D,
	//				   nBPP, nWidth, nHeight,
	//				   (nBPP == 3 ? GL_RGB : GL_RGBA),
	//				   GL_UNSIGNED_BYTE,
	//				   pData);
//	 ---------------------------------------------------------------------

	 // delete [] pData;	// Leave memory clearing upto the caller...

	sprintf (m_Singleton->szErrorMessage, "Loaded Some Memory Perfectly!");
	return nNewTextureID;
}
예제 #15
0
파일: kstring.cpp 프로젝트: MP2E/dlight
kexStr &kexStr::operator=(const char *str) {
    int len = strlen(str);
    
    CheckSize(len+1, false);
    strncpy(charPtr, str, len);
    length = len;
    charPtr[length] = '\0';

    return *this;
}
예제 #16
0
파일: memory.c 프로젝트: bdacode/ArangoDB
void* TRI_AllocateZ (TRI_memory_zone_t* zone, uint64_t n, bool set, char const* file, int line) {
#else
void* TRI_Allocate (TRI_memory_zone_t* zone, uint64_t n, bool set) {
#endif
  char* m;

#ifdef TRI_ENABLE_MAINTAINER_MODE
  CheckSize(n, file, line);

  m = MALLOC_WRAPPER(zone, (size_t) n + sizeof(uintptr_t));
#else
  m = MALLOC_WRAPPER(zone, (size_t) n);
#endif

  if (m == NULL) {
    if (zone->_failable) {
      TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
      return NULL;
    }

    if (CoreReserve == NULL) {
      fprintf(stderr,
              "FATAL: failed to allocate %llu bytes for memory zone %d" ZONE_DEBUG_LOCATION ", giving up!\n",
              (unsigned long long) n,
              (int) zone->_zid
              ZONE_DEBUG_PARAMS);
      TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL);
    }

    free(CoreReserve);
    CoreReserve = NULL;

    fprintf(stderr,
            "failed to allocate %llu bytes for memory zone %d" ZONE_DEBUG_LOCATION ", retrying!\n",
            (unsigned long long) n,
            (int) zone->_zid
            ZONE_DEBUG_PARAMS);

#ifdef TRI_ENABLE_MAINTAINER_MODE
    return TRI_AllocateZ(zone, n, set, file, line);
#else
    return TRI_Allocate(zone, n, set);
#endif
  }

#ifdef TRI_ENABLE_MAINTAINER_MODE
  else if (set) {
    memset(m, 0, (size_t) n + sizeof(uintptr_t));
  }
  else {
    // prefill with 0xA5 (magic value, same as Valgrind will use)
    memset(m, 0xA5, (size_t) n + sizeof(uintptr_t));
  }
#else
  else if (set) {
예제 #17
0
static BOOL
CopySections(const unsigned char *data, size_t size, PIMAGE_NT_HEADERS old_headers, PMEMORYMODULE module)
{
    int i, section_size;
    unsigned char *codeBase = module->codeBase;
    unsigned char *dest;
    PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(module->headers);
    for (i=0; i<module->headers->FileHeader.NumberOfSections; i++, section++) {
        if (section->SizeOfRawData == 0) {
            // section doesn't contain data in the dll itself, but may define
            // uninitialized data
            section_size = old_headers->OptionalHeader.SectionAlignment;
            if (section_size > 0) {
                dest = (unsigned char *)VirtualAlloc(codeBase + section->VirtualAddress,
                    section_size,
                    MEM_COMMIT,
                    PAGE_EXECUTE_READWRITE);
                if (dest == NULL) {
                    return FALSE;
                }

                // Always use position from file to support alignments smaller
                // than page size.
                dest = codeBase + section->VirtualAddress;
                section->Misc.PhysicalAddress = (DWORD) (uintptr_t) dest;
                memset(dest, 0, section_size);
            }

            // section is empty
            continue;
        }

        if (size && !CheckSize(size, section->PointerToRawData + section->SizeOfRawData)) {
            return FALSE;
        }

        // commit memory block and copy data from dll
        dest = (unsigned char *)VirtualAlloc(codeBase + section->VirtualAddress,
                            section->SizeOfRawData,
                            MEM_COMMIT,
                            PAGE_EXECUTE_READWRITE);
        if (dest == NULL) {
            return FALSE;
        }

        // Always use position from file to support alignments smaller
        // than page size.
        dest = codeBase + section->VirtualAddress;
        memcpy(dest, data + section->PointerToRawData, section->SizeOfRawData);
		section->Misc.PhysicalAddress = ((DWORD)(((POINTER_TYPE)(dest)) & 0xffffffff));
    }

    return TRUE;
}
예제 #18
0
파일: kstring.cpp 프로젝트: MP2E/dlight
kexStr &kexStr::Concat(const char *string, int len) {
    CheckSize((length + len)+1, true);

    for(int i = 0; i < len; i++) {
        charPtr[length+i] = string[i];
    }

    length += len;
    charPtr[length] = '\0';
    
    return *this;
}
예제 #19
0
파일: kstring.cpp 프로젝트: MP2E/dlight
kexStr &kexStr::Copy(const kexStr &src, int len) {
    int i = 0;
    const char *p = src;
    CheckSize((length + len)+1, true);
    
    while((len--) >= 0) {
        charPtr[i] = p[i];
        i++;
    }

    return *this;
}
예제 #20
0
void MeshLoaderB3D::ReadBone( Joint* joint )
{
	int i = 0;
	while( CheckSize() ){
		int vertex = _file->ReadInt();
		float weight = _file->ReadFloat();
		joint->vertexIndices.push_back(vertex);
		joint->vertexWeights.push_back(weight);
		i++;
	}
	PrintTree("vertex count: %d", i);
}
예제 #21
0
파일: kstring.cpp 프로젝트: MP2E/dlight
kexStr &kexStr::StripExtension(void) {
    int pos = IndexOf(".");
    
    if(pos == -1)
        return *this;
    
    length = pos;
    CheckSize(length, true);
    charPtr[length] = '\0';
    
    return *this;
}
예제 #22
0
void* TRI_AllocateZ(TRI_memory_zone_t* zone, uint64_t n, bool set,
                    char const* file, int line) {
#else
void* TRI_Allocate(TRI_memory_zone_t* zone, uint64_t n, bool set) {
#endif
#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
  CheckSize(n, file, line);
#endif
  char* m = static_cast<char*>(MALLOC_WRAPPER(zone, (size_t)n));

  if (m == nullptr) {
    if (zone->_failable) {
      TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
      return nullptr;
    }

    if (CoreReserve == nullptr) {
      fprintf(stderr,
              "FATAL: failed to allocate %llu bytes for core mem zone "
              ZONE_DEBUG_LOCATION ", giving up!\n",
              (unsigned long long)n ZONE_DEBUG_PARAMS);
      TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr);
    }

    free(CoreReserve);
    CoreReserve = nullptr;

    fprintf(
        stderr,
        "failed to allocate %llu bytes for core mem zone" ZONE_DEBUG_LOCATION
        ", retrying!\n",
        (unsigned long long)n ZONE_DEBUG_PARAMS);

#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
    return TRI_AllocateZ(zone, n, set, file, line);
#else
    return TRI_Allocate(zone, n, set);
#endif
  }

  if (set) {
    memset(m, 0, (size_t)n);
  }
#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
  else {
    // prefill with 0xA5 (magic value, same as Valgrind will use)
    memset(m, 0xA5, (size_t)n);
  }
#endif

  return m;
}
예제 #23
0
void MeshLoaderB3D::ReadMesh() {
	/*int matid=*/_file->ReadInt();

	//printTree("mesh");
	while( CheckSize() ){
		lfStr t = ReadChunk();
		if( t=="VRTS" ){
			ReadVrts();
		}else if( t=="TRIS" ){
			ReadTris();
		}
		ExitChunk();
	}
}
예제 #24
0
void CRehldsFlightRecorder::WriteBuffer(const void* data, unsigned int len) {
	if (m_pRecorderState->curMessage == 0) {
		rehlds_syserror("%s: Could not write, invalid state", __FUNCTION__);
	}

	CheckSize(len);
	unsigned int freeSz = DATA_REGION_MAIN_SIZE - m_pRecorderState->wpos;
	if (freeSz < len) {
		MoveToStart();
	}

	memcpy(m_DataRegionPtr + m_pRecorderState->wpos, data, len);
	m_pRecorderState->wpos += len;
}
예제 #25
0
void CDataPack::PackCell(cell cells)
{
    CheckSize(sizeof(char) + sizeof(size_t) + sizeof(cell));

    *(char *)m_curptr = DataPackType::Cell;
    m_curptr += sizeof(char);

    *(size_t *)m_curptr = sizeof(cell);
    m_curptr += sizeof(size_t);

    *(cell *)m_curptr = cells;
    m_curptr += sizeof(cell);

    m_size += sizeof(char) + sizeof(size_t) + sizeof(cell);
}
예제 #26
0
void CDataPack::PackFloat(float val)
{
    CheckSize(sizeof(char) + sizeof(size_t) + sizeof(float));

    *(char *)m_curptr = DataPackType::Float;
    m_curptr += sizeof(char);

    *(size_t *)m_curptr = sizeof(float);
    m_curptr += sizeof(size_t);

    *(float *)m_curptr = val;
    m_curptr += sizeof(float);

    m_size += sizeof(char) + sizeof(size_t) + sizeof(float);
}
예제 #27
0
void MeshLoaderB3D::ReadTexs()
{
	while (CheckSize()) {
		PrintTree("read texs \n");
		SB3dTexture tex;
		tex.TextureName = _file->ReadString();
		tex.Flags = _file->ReadInt();
		tex.Blend = _file->ReadInt();
		tex.Xpos = _file->ReadFloat();
		tex.Ypos = _file->ReadFloat();
		tex.Xscale = _file->ReadFloat();
		tex.Yscale = _file->ReadFloat();
		tex.Angle = _file->ReadFloat();
		_textures.push_back(tex);
	}
}
예제 #28
0
BOOL FixSize(int *cy, int displayHeight)
{
	int nCy = *cy;
	int checkResult = CheckSize(nCy, displayHeight);
	if (checkResult == CHECKRESULT_NORMALSIZE)
	{
		*cy = displayHeight - sizeSoftkeyBar - sizeStatusBar;
		return TRUE;
	}
	else if (checkResult == CHECKRESULT_FULLSCREEN)
	{
		*cy = displayHeight - sizeStatusBar;
		return TRUE;
	}
	return FALSE;
};
예제 #29
0
void MeshLoaderB3D::ReadTexs()
{
	while (CheckSize()) {
		PrintTree("read texs \n");
		SB3dTexture tex;
		readString(_file, tex.TextureName);
		_file->ReadInt(tex.Flags);
		 _file->ReadInt(tex.Blend);
		_file->ReadFloat(tex.Xpos);
		_file->ReadFloat(tex.Ypos);
		_file->ReadFloat(tex.Xscale);
		_file->ReadFloat(tex.Yscale);
		_file->ReadFloat(tex.Angle);
		_textures.Insert(tex);
	}
}
예제 #30
0
void TSessionLog::OpenLogFile()
{
  DebugAssert(FConfiguration != nullptr);
  if (!FConfiguration)
    return;
  try
  {
    DebugAssert(FLogger == nullptr);
    FCurrentLogFileName = FConfiguration->GetLogFileName();
    FILE *file = LocalOpenLogFile(FCurrentLogFileName, FStarted, FSessionData, FConfiguration->GetLogFileAppend(), FCurrentFileName);
    FLogger = new tinylog::TinyLog(file);
    TSearchRec SearchRec;
    if (FileSearchRec(FCurrentFileName, SearchRec))
    {
      FCurrentFileSize = SearchRec.Size;
    }
    else
    {
      FCurrentFileSize = 0;
    }
  }
  catch (Exception &E)
  {
    // We failed logging to file, turn it off and notify user.
    FCurrentLogFileName.Clear();
    FCurrentFileName.Clear();
    FConfiguration->SetLogFileName(UnicodeString());
    try
    {
      throw ExtException(&E, LoadStr(LOG_GEN_ERROR));
    }
    catch (Exception &E2)
    {
      AddException(&E2);
      // not to deadlock with TSessionLog::ReflectSettings invoked by FConfiguration->LogFileName setter above
      TUnguard Unguard(FCriticalSection);
      FUI->HandleExtendedException(&E2);
    }
  }

  // in case we are appending and the existing log file is already too large
  if (FLogger != nullptr)
  {
    CheckSize(0);
  }
}