Surface Font::Render(const std::string & txt,
const Color & color,
bool cache)
{
Surface surface;
if (cache) {
txt_iterator p = surface_text_table.find(txt);
if( p == surface_text_table.end() ){
if( surface_text_table.size() > 5 ){
//SDL_FreeSurface( surface_text_table.begin()->second );
surface_text_table.erase( surface_text_table.begin() );
}
surface = CreateSurface(txt, color);
surface_text_table.insert( txt_sample(txt, surface) );
} else {
txt_iterator p2 = surface_text_table.find( txt );
surface = p2->second;
}
} else {
surface = CreateSurface(txt, color);
}
ASSERT( !surface.IsNull() );
return surface;
}
Slab CreateSlab(GLsizei width, GLsizei height, int numComponents)
{
Slab slab;
slab.Ping = CreateSurface(width, height, numComponents);
slab.Pong = CreateSurface(width, height, numComponents);
return slab;
}
PPSurface CreatePPSurface(GLsizei width, GLsizei height, int Components)
{
PPSurface ppsurface;
ppsurface.Ping = CreateSurface(width, height, Components);
ppsurface.Pong = CreateSurface(width, height, Components);
return ppsurface;
}
CNullVideoRendererInputPin::CNullVideoRendererInputPin(CBaseRenderer *pRenderer, HRESULT *phr, LPCWSTR Name)
: CRendererInputPin(pRenderer, phr, Name)
{
HMODULE hLib;
CreateSurface();
hLib = LoadLibrary (L"dxva2.dll");
pfDXVA2CreateDirect3DDeviceManager9 = hLib ? (PTR_DXVA2CreateDirect3DDeviceManager9) GetProcAddress (hLib, "DXVA2CreateDirect3DDeviceManager9") : NULL;
pfDXVA2CreateVideoService = hLib ? (PTR_DXVA2CreateVideoService) GetProcAddress (hLib, "DXVA2CreateVideoService") : NULL;
if (hLib != NULL)
{
pfDXVA2CreateDirect3DDeviceManager9 (&m_nResetTocken, &m_pD3DDeviceManager);
}
// Initialize Device Manager with DX surface
if (m_pD3DDev)
{
HRESULT hr;
hr = m_pD3DDeviceManager->ResetDevice (m_pD3DDev, m_nResetTocken);
hr = m_pD3DDeviceManager->OpenDeviceHandle(&m_hDevice);
}
}
void Surface::Set(const void* pixels, unsigned int width, unsigned int height, unsigned char bytes_per_pixel, bool amask0)
{
FreeSurface(*this);
switch(bytes_per_pixel)
{
case 1:
CreateSurface(width, height, 8, false);
LoadPalette();
Lock();
std::memcpy(surface->pixels, pixels, width * height);
Unlock();
break;
default:
{
u32 rmask, gmask, bmask, amask;
GetRGBAMask(bytes_per_pixel * 8, rmask, gmask, bmask, amask);
surface = SDL_CreateRGBSurfaceFrom(const_cast<void *>(pixels), width, height, 8 * bytes_per_pixel, width * bytes_per_pixel,
rmask, gmask, bmask, (amask0 ? amask : 0));
}
break;
}
if(!surface)
Error::Except(__FUNCTION__, SDL_GetError());
}
RageSurface *RageMovieTextureDriver_FFMpeg::AVCodecCreateCompatibleSurface( int iTextureWidth, int iTextureHeight, bool bPreferHighColor, int &iAVTexfmt, MovieDecoderPixelFormatYCbCr &fmtout )
{
FixLilEndian();
int iAVTexfmtIndex = FindCompatibleAVFormat( bPreferHighColor );
if( iAVTexfmtIndex == -1 )
iAVTexfmtIndex = FindCompatibleAVFormat( !bPreferHighColor );
if( iAVTexfmtIndex == -1 )
{
/* No dice. Use the first avcodec format of the preferred bit depth,
* and let the display system convert. */
for( iAVTexfmtIndex = 0; AVPixelFormats[iAVTexfmtIndex].bpp; ++iAVTexfmtIndex )
if( AVPixelFormats[iAVTexfmtIndex].bHighColor == bPreferHighColor )
break;
ASSERT( AVPixelFormats[iAVTexfmtIndex].bpp != 0 );
}
const AVPixelFormat_t *pfd = &AVPixelFormats[iAVTexfmtIndex];
iAVTexfmt = pfd->pf;
fmtout = pfd->YUV;
LOG->Trace( "Texture pixel format: %i %i (%ibpp, %08x %08x %08x %08x)", iAVTexfmt, fmtout,
pfd->bpp, pfd->masks[0], pfd->masks[1], pfd->masks[2], pfd->masks[3] );
if( pfd->YUV == PixelFormatYCbCr_YUYV422 )
iTextureWidth /= 2;
return CreateSurface( iTextureWidth, iTextureHeight, pfd->bpp,
pfd->masks[0], pfd->masks[1], pfd->masks[2], pfd->masks[3] );
}
wxIDirectFBSurfacePtr wxIDirectFB::GetPrimarySurface()
{
DFBSurfaceDescription desc;
desc.flags = DSDESC_CAPS;
desc.caps = DSCAPS_PRIMARY;
return CreateSurface(&desc);
}
MovieTexture_Null::MovieTexture_Null(RageTextureID ID) : RageMovieTexture(ID)
{
LOG->Trace("MovieTexture_Null::MovieTexture_Null(ID)");
texHandle = 0;
RageTextureID actualID = GetID();
actualID.iAlphaBits = 0;
int size = 64;
m_iSourceWidth = size;
m_iSourceHeight = size;
m_iImageWidth = size;
m_iImageHeight = size;
m_iTextureWidth = power_of_two(size);
m_iTextureHeight = m_iTextureWidth;
m_iFramesWide = 1;
m_iFramesHigh = 1;
CreateFrameRects();
RagePixelFormat pixfmt = RagePixelFormat_RGBA4;
if( !DISPLAY->SupportsTextureFormat(pixfmt) )
pixfmt = RagePixelFormat_RGBA8;
ASSERT( DISPLAY->SupportsTextureFormat(pixfmt) );
const RageDisplay::RagePixelFormatDesc *pfd = DISPLAY->GetPixelFormatDesc( pixfmt );
RageSurface *img = CreateSurface( size, size, pfd->bpp,
pfd->masks[0], pfd->masks[1], pfd->masks[2], pfd->masks[3] );
memset( img->pixels, 0, img->pitch*img->h );
texHandle = DISPLAY->CreateTexture( pixfmt, img, false );
delete img;
}
HSURFACE CTextHelper::CreateSurfaceFromString (ILTClient* pClientDE, FONT* pFontDef, int strID, HLTCOLOR foreColor, HLTCOLOR backColor, LTBOOL bCropped, int nExtraX, int nExtraY)
{
if (!pClientDE) return LTNULL;
HLTFONT hFont = pClientDE->CreateFont (pFontDef->strFontName,
pFontDef->nWidth,
pFontDef->nHeight,
pFontDef->bItalic,
pFontDef->bUnderline,
pFontDef->bBold);
if (!hFont) return LTNULL;
HSTRING hString = pClientDE->FormatString (strID);
if (!hString)
{
pClientDE->DeleteFont (hFont);
return LTNULL;
}
HSURFACE hSurface = CreateSurface (pClientDE, hFont, hString, foreColor, backColor, bCropped, nExtraX, nExtraY);
pClientDE->DeleteFont (hFont);
pClientDE->FreeString (hString);
return hSurface;
}
void mitk::ImageToSurfaceFilter::GenerateData()
{
mitk::Surface *surface = this->GetOutput();
mitk::Image * image = (mitk::Image*)GetInput();
if(image == NULL || !image->IsInitialized())
mitkThrow() << "No input image set, please set an valid input image!";
mitk::Image::RegionType outputRegion = image->GetRequestedRegion();
int tstart=outputRegion.GetIndex(3);
int tmax=tstart+outputRegion.GetSize(3); //GetSize()==1 - will aber 0 haben, wenn nicht zeitaufgeloest
if ((tmax-tstart) > 0)
{
ProgressBar::GetInstance()->AddStepsToDo( 4 * (tmax - tstart) );
}
int t;
for( t=tstart; t < tmax; ++t)
{
vtkImageData *vtkimagedata = image->GetVtkImageData(t);
CreateSurface(t,vtkimagedata,surface,m_Threshold);
ProgressBar::GetInstance()->Progress();
}
}
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
// Create the D3D object.
if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return E_FAIL;
// Set up the structure used to create the D3DDevice. Since we are now
// using more complex geometry, we will create a device with a zbuffer.
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof( d3dpp ) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
// Create the D3DDevice
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING |
D3DCREATE_MULTITHREADED |
D3DCREATE_FPU_PRESERVE,
&d3dpp, &g_pd3dDevice ) ) )
{
return E_FAIL;
}
if (FAILED(CreateSurface(SCREEN_WIDTH, SCREEN_HEIGHT)))
return E_FAIL;
// Turn on the zbuffer
g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
// Turn on ambient lighting
g_pd3dDevice->SetRenderState( D3DRS_AMBIENT, 0xffffffff );
return S_OK;
}
CNullVideoRendererInputPin::CNullVideoRendererInputPin(CBaseRenderer* pRenderer, HRESULT* phr, LPCWSTR Name)
: CRendererInputPin(pRenderer, phr, Name)
, m_hDXVA2Lib(nullptr)
, pfDXVA2CreateDirect3DDeviceManager9(nullptr)
, pfDXVA2CreateVideoService(nullptr)
, m_pD3DDev(nullptr)
, m_pD3DDeviceManager(nullptr)
, m_nResetToken(0)
, m_hDevice(INVALID_HANDLE_VALUE)
{
CreateSurface();
m_hDXVA2Lib = LoadLibrary(L"dxva2.dll");
if (m_hDXVA2Lib) {
pfDXVA2CreateDirect3DDeviceManager9 = reinterpret_cast<PTR_DXVA2CreateDirect3DDeviceManager9>(GetProcAddress(m_hDXVA2Lib, "DXVA2CreateDirect3DDeviceManager9"));
pfDXVA2CreateVideoService = reinterpret_cast<PTR_DXVA2CreateVideoService>(GetProcAddress(m_hDXVA2Lib, "DXVA2CreateVideoService"));
pfDXVA2CreateDirect3DDeviceManager9(&m_nResetToken, &m_pD3DDeviceManager);
}
// Initialize Device Manager with DX surface
if (m_pD3DDev) {
m_pD3DDeviceManager->ResetDevice(m_pD3DDev, m_nResetToken);
m_pD3DDeviceManager->OpenDeviceHandle(&m_hDevice);
}
}
WSERR WSurface::RestoreSurface()
{
LPDIRECTDRAWSURFACE left_buffer=data->LeftBuffer;
LPDIRECTDRAWSURFACE right_buffer=data->RightBuffer;
HRESULT hr=DD_OK;
bool need_restore=false;
if (data->screen->IsLost()) {
hr=data->screen->Restore();
need_restore=true;
}
if (hr==DD_OK && left_buffer->IsLost()) {
hr=left_buffer->Restore();
need_restore=true;
}
if (hr==DD_OK && right_buffer->IsLost()) {
hr=right_buffer->Restore();
need_restore=true;
}
if (hr!=DD_OK) {
WSERR err=CreateSurface();
if (err!=WS_OK) return err;
need_restore=false;
}
if (need_restore) {
Refresh();
}
return WS_OK;
}
RageSurface* RageDisplay_D3D::CreateScreenshot()
{
#if defined(XBOX)
return NULL;
#else
RageSurface * result = NULL;
// Get the back buffer.
IDirect3DSurface9* pSurface;
if( SUCCEEDED( g_pd3dDevice->GetBackBuffer( 0, 0, D3DBACKBUFFER_TYPE_MONO, &pSurface ) ) )
{
// Get the back buffer description.
D3DSURFACE_DESC desc;
pSurface->GetDesc( &desc );
// Copy the back buffer into a surface of a type we support.
IDirect3DSurface9* pCopy;
if( SUCCEEDED( g_pd3dDevice->CreateOffscreenPlainSurface( desc.Width, desc.Height, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pCopy, NULL ) ) )
{
if( SUCCEEDED( D3DXLoadSurfaceFromSurface( pCopy, NULL, NULL, pSurface, NULL, NULL, D3DX_FILTER_NONE, 0) ) )
{
// Update desc from the copy.
pCopy->GetDesc( &desc );
D3DLOCKED_RECT lr;
{
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = desc.Width;
rect.bottom = desc.Height;
pCopy->LockRect( &lr, &rect, D3DLOCK_READONLY );
}
RageSurface *surface = CreateSurfaceFromPixfmt( FMT_RGBA8, lr.pBits, desc.Width, desc.Height, lr.Pitch);
ASSERT( surface != NULL );
// We need to make a copy, since lr.pBits will go away when we call UnlockRect().
result =
CreateSurface( surface->w, surface->h,
surface->format->BitsPerPixel,
surface->format->Rmask, surface->format->Gmask,
surface->format->Bmask, surface->format->Amask );
RageSurfaceUtils::CopySurface( surface, result );
delete surface;
pCopy->UnlockRect();
}
pCopy->Release();
}
pSurface->Release();
}
return result;
#endif
}
void CChildView::OnSize(UINT nType, int cx, int cy)
{
CWnd::OnSize(nType, cx, cy);
if (m_hWnd && cx && cy) {
TRACE("OnSize: width == %d, height == %d\n", cx, cy);
// Initialize screen format
// First time init with an hwnd
if (m_eSurf == eNone) {
CClientDC dc(this);
int pixels;
bool bWarnDepth = false;
bool bWarnDebug = false;
SetTimer(m_kTimerID, m_kTimerDelay, NULL);
pixels = dc.GetDeviceCaps(BITSPIXEL) * dc.GetDeviceCaps(PLANES);
switch (pixels) {
case 16:
m_eSurf = IsSSE2() ? e16BitSSE2Intrin :
IsMMX() ? e16BitMMXIntrin : e16BitGeneric;
break;
case 24:
m_eSurf = IsSSE2() ? e24BitSSE2Intrin :
IsMMX() ? e24BitMMXIntrin : e24BitGeneric;
break;
case 32:
m_eSurf = IsSSE2() ? e32BitSSE2Intrin :
IsMMX() ? e32BitMMXIntrin : e32BitGeneric;
break;
default:
bWarnDepth = true;
m_eSurf = IsSSE2() ? e32BitSSE2Intrin :
IsMMX() ? e32BitMMXIntrin : e32BitGeneric;
break;
}
#ifdef _DEBUG
bWarnDebug = true;
#endif
if (bWarnDepth || bWarnDebug) {
CString fmt;
if (bWarnDepth) {
fmt.LoadString(IDS_WARNING_BITDEPTH);
}
if (bWarnDepth && bWarnDebug) {
fmt += "\n";
}
if (bWarnDebug) {
CString temp;
temp.LoadString(IDS_WARNING_DEBUG);
fmt += temp;
}
::AfxMessageBox(fmt, MB_ICONINFORMATION);
}
}
m_bSizeChanged = true;
CreateSurface();
}
}
BOOL CMovie::OpenMovie(char *fname,int music,BOOL loop)
{
int size;
Chunk aviFileHead;
Chunk aviInfo;
AVIMAINHEADER aviMainHead;
WaitThreadEnd();
stream = readFile->StreamOpenFile(pack_sound,fname,size);
if((-1)==stream) return FALSE;
readFile->StreamReadFile(pack_sound,stream,(char *)&aviFileHead,sizeof(Chunk));
if(MAKEFOURCC('R','I','F','F')!=aviFileHead.ckID){
readFile->StreamCloseFile(pack_sound,stream);
stream = -1;
return FALSE;
}
readFile->StreamReadFile(pack_sound,stream,(char *)&aviInfo,sizeof(Chunk));
readFile->StreamReadFile(pack_sound,stream,(char *)&aviMainHead,sizeof(AVIMAINHEADER));
readFile->StreamSeekFile(pack_sound,stream,0,FILE_BEGIN);
fpms = aviMainHead.dwMicroSecPerFrame;
srcWidth = aviMainHead.dwWidth;
srcHeight = aviMainHead.dwHeight;
HDC hDC = ::GetDC(sysInf.hWnd);
HBRUSH brush = CreateSolidBrush(RGB(0, 0, 8));
HBRUSH old_brush = (HBRUSH)SelectObject(hDC,brush);
PatBlt(hDC,0,0,wWidth,wHeight,PATCOPY);
SelectObject(hDC,old_brush);
DeleteObject(brush);
::ReleaseDC(sysInf.hWnd,hDC);
if(FALSE == CreateSurface() ){
}
buffer_size = srcWidth*srcHeight*2;
readBuf = (LPBYTE)malloc(buffer_size);
xvidDec.Start_XviD(srcWidth,srcHeight,overlay_forcc[forccNum]);
read_size = readFile->StreamReadFile(pack_sound,stream,(char *)readBuf,buffer_size);
frame_cnt = 0;
old_frame = 0;
start_time = 0;
old_time = 0;
skip_cnt = 0;
total_skip_cnt = 0;
bPause = FALSE;
if(NULL==lpSoundDS)lpSoundDS = new ClSoundDS(sysInf.hWnd,readFile,FALSE);
bPlay = TRUE;
bLoop = loop;
changeExecMode( movie_mode );
musicNum = music;
DWORD dwThreadID;
hMovieThread = CreateThread(NULL,0,movieThread,this,0,&dwThreadID);
bExitMovieThread = FALSE;
return TRUE;
} // CMovie::OpenMovie
/* bpp: 8, 16, 24, 32 */
void Surface::Set(u16 sw, u16 sh, u8 bpp, bool amask0)
{
FreeSurface(*this);
CreateSurface(sw, sh, bpp, amask0);
if(8 == bpp) LoadPalette();
SetDefaultColorKey();
}
void QmitkIsoSurface::CreateConnections()
{
if ( m_Controls )
{
connect( m_Controls->m_ImageSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(ImageSelected(const mitk::DataNode*)) );
connect( m_Controls->createSurfacePushButton, SIGNAL(clicked()), this, SLOT(CreateSurface()) );
}
}
//---テクスチャーをロードする
int eiTextureCell::Load(int trans /*= 1*/)
{
int surface_color = TextureSurfaceColor;
if(!Data.CreateFlag){
eiDebugWriteFile("(eiTextureCell) Not Created!!\n");
return 0;
}
eiDDSurface TempSurface;
//---テクスチャーサーフェイスを確保
if(!CreateSurface()){
return 0;
}
Texture.SetSrcBltColorKey(16,16);
// eiDebugWriteFile("(eiTextureCell) Texture.Create Succes\n");
//---エミュレーションでなければテンポラリサーフェイスを作る
if(!TempSurface.Create(Data.xSize,Data.ySize,
ESCREATE_TEXTURE | ESCREATE_TEMPTEXTURE | ESCREATE_SYSTEMMEMORY,
&Texture,TextureSurfaceColor)){
Texture.Release();
eiDebugWriteFile("::::::::::::1\n");
return 0;
}
// eiDebugWriteFile("(eiTextureCell) TempSurface.Create Succes\n");
if(Data.Color <= 8 && TempSurface.Color <= 8){
//---パレット
if(CreatePalette()){
TempSurface.lpSurface->SetPalette(Palette.lpPalette);
Texture.lpSurface->SetPalette(Palette.lpPalette);
}
}
//---テンポラリサーフェイスへコピーする
dib.CopyToDDSurface(&TempSurface,0,0,NULL,trans);
// eiDebugWriteFile("(eiTextureCell) dib.CopyToDDSurface end\n");
RECT rect = {0,0,Data.xSize,Data.ySize};
if(!LoadFromSurface(&TempSurface,&rect)){
eiDebugWriteFile("(eiTextureCell) load fail\n");
}
//---いらなくなったのを解放
TempSurface.Release();
//---サーフェイスセット
Data.SurfaceFlag = 1;
Data.SurfaceNumber = 2;
pDDSurface = &Texture;
// eiDebugWriteFile("(eiTextureCell) Create succes\n");
return 1;
}
static RageSurface *ReadImage( RageFile &f, int len, int height,
const RageSurfaceColor localColorMap[MAXCOLORMAPSIZE],
int interlace, int ignore )
{
int xpos = 0, ypos = 0, pass = 0;
/* Initialize the compression routines */
LWZState state;
if( !state.Init(f) )
{
// RWSetMsg("error reading image");
return NULL;
}
/* If this is an "uninteresting picture" ignore it. */
if( ignore )
{
while( state.ReadByte(f) >= 0 )
;
return NULL;
}
RageSurface *image = CreateSurface( len, height, 8, 0, 0, 0, 0 );
memcpy( image->fmt.palette->colors, localColorMap, 256*sizeof(RageSurfaceColor) );
int v;
while( (v = state.ReadByte(f)) >= 0 )
{
char *data = (char *) image->pixels;
data[xpos + ypos * image->pitch] = (char) v;
++xpos;
if( xpos == len )
{
xpos = 0;
if( interlace )
{
int step[] = { 8, 8, 4, 2 };
ypos += step[pass];
if( ypos >= height )
{
++pass;
if( pass == 4 )
return image;
int start[] = { 0, 4, 2, 1 };
ypos = start[pass];
}
} else {
++ypos;
}
}
if (ypos >= height)
break;
}
return image;
}
std::shared_ptr<gsurface_t> MyRenderGL::CacheSurface( const surf_t &s ) {
GLuint vao;
GLuint positionBuffer, indexBuffer;
_CH(glGenVertexArrays( 1, &vao ));
_CH(glBindVertexArray( vao ));
_CH(glGenBuffers( 1, &positionBuffer ));
_CH(glBindBuffer( GL_ARRAY_BUFFER, positionBuffer ));
_CH(glBufferData( GL_ARRAY_BUFFER, s.m_verts.size() * 8 * sizeof(float),
(void *)s.m_verts.data(), GL_STATIC_DRAW ));
_CH(glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float),
(void *)(0 * sizeof(float ) ) ));
_CH(glVertexAttribPointer( 1, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float),
(void *)(3 * sizeof(float ) ) ));
_CH(glVertexAttribPointer( 2, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float),
(void *)(5 * sizeof(float ) ) ));
_CH(glEnableVertexAttribArray( 0 ));
_CH(glEnableVertexAttribArray( 1 ));
_CH(glEnableVertexAttribArray( 2 ));
_CH(glGenBuffers( 1, &indexBuffer ));
_CH(glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, indexBuffer ));
_CH(glBufferData( GL_ELEMENT_ARRAY_BUFFER,
s.m_indices.size() * sizeof(GLushort),
(void *)s.m_indices.data(), GL_STATIC_DRAW ));
std::shared_ptr<gsurface_t> cached = CreateSurface();
cached->m_vao = vao;
cached->m_numIndices = s.m_indices.size();
cached->m_indexBuffer = indexBuffer;
if ( s.m_matName == "white" ) {
cached->m_material = m_whiteMaterial;
} else if ( s.m_matName == "sky" ) {
cached->m_material = m_skyMaterial;
} else {
if ( m_materialCache.find( s.m_matName ) != m_materialCache.end() ) {
cached->m_material = m_materialCache[ s.m_matName ];
} else {
std::shared_ptr<material_t> t = new material_t();
t->m_texture = CreateTexture( s.m_matName );
t->m_program = m_shaderProgram;
if ( !t.IsValid() ) {
msg_failure( "Can't cache material `%s'\n", s.m_matName.c_str() );
return nullptr;
}
m_materialCache[ s.m_matName ] = t;
cached->m_material = t;
}
}
return cached;
}
static struct XenosSurface * GetScreenSurface(int w, int h, int fmt) {
if (screen_texture == NULL) {
screen_texture = CreateSurface(1024, 1024, fmt);
}
screen_texture->width = w;
screen_texture->height = h;
return screen_texture;
}
void VolumeBrush::InitialUpdate()
{
// TESTING!!!!
if (!vtRemoveFilters.IsInitted())
{
vtRemoveFilters.Init(g_pLTServer, "RemoveFilters", LTNULL, 0.0f);
}
if (vtRemoveFilters.GetFloat())
{
g_pLTServer->CPrint("Removing Filter: %s", g_pLTServer->GetObjectName(m_hObject));
g_pLTServer->RemoveObject(m_hObject);
return;
}
// TESTING!!!!
// Tell the client about any special fx (fog)...
CreateSpecialFXMsg();
// Save volume brush's initial flags...
m_dwSaveFlags = g_pLTServer->GetObjectFlags(m_hObject);
uint32 dwUserFlags = g_pLTServer->GetObjectUserFlags(m_hObject);
dwUserFlags |= USRFLG_IGNORE_PROJECTILES;
if (!m_bHidden) dwUserFlags |= USRFLG_VISIBLE;
g_pLTServer->SetObjectUserFlags(m_hObject, dwUserFlags);
// Create the surface if necessary. We only need to do updates if we have
// a surface (in case somebody decides to move the brush, we need to update
// the surface's position)...
if (m_bShowSurface)
{
CreateSurface();
SetNextUpdate(UPDATE_DELTA);
}
// Normalize friction (1 = normal, 0 = no friction, 2 = double)...
if (m_fFriction < 0.0) m_fFriction = 0.0f;
else if (m_fFriction > 1.0) m_fFriction = 1.0f;
// Normalize viscosity (1 = no movement, 0 = full movement)...
if (m_fViscosity < 0.0) m_fViscosity = 0.0f;
else if (m_fViscosity > 1.0) m_fViscosity = 1.0f;
}
void VolumeBrush::InitialUpdate(int nData)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return;
// For save game restores, just recreate the surface
if (nData == INITIALUPDATE_SAVEGAME)
return;
if (m_bShowSurface)
{
CreateSurface();
}
m_hPlayerClass = pServerDE->GetClass("CPlayerObj");
DDWORD dwUserFlags = m_bHidden ? 0 : USRFLG_VISIBLE;
dwUserFlags |= USRFLG_SAVEABLE;
pServerDE->SetObjectUserFlags(m_hObject, dwUserFlags);
if (m_hSurfaceObj)
{
pServerDE->SetObjectUserFlags(m_hSurfaceObj, dwUserFlags);
}
// Tell the client about any special fx (fog)...
HMESSAGEWRITE hMessage = pServerDE->StartSpecialEffectMessage(this);
pServerDE->WriteToMessageByte(hMessage, SFX_VOLUMEBRUSH_ID);
//pServerDE->WriteToMessageByte(hMessage, DTRUE);
pServerDE->WriteToMessageByte(hMessage, (DBYTE)m_bFogEnable);
pServerDE->WriteToMessageFloat(hMessage, m_fFogFarZ);
pServerDE->WriteToMessageFloat(hMessage, m_fFogNearZ);
pServerDE->WriteToMessageVector(hMessage, &m_vFogColor);
pServerDE->EndMessage(hMessage);
pServerDE->SetNextUpdate(m_hObject, 0.001f);
// Save volume brush's initial flags...
m_dwSaveFlags = pServerDE->GetObjectFlags(m_hObject);
// Normalize viscosity (1 = no movement, 0 = full movement)...
if (m_fViscosity < 0.0) m_fViscosity = 0.0f;
else if (m_fViscosity > 1.0) m_fViscosity = 1.0f;
// Okay, internally we really want it the opposite way (i.e., 1 = full
// movement, 0 = no movement)...
m_fViscosity = 1.0f - m_fViscosity;
}
CBenchmark()
{
for (dword i = 0; i < 4; i++)
m_PerfData[i] = 0;
m_SurfID = CreateSurface(300, 200, 256, 256 + 16);
FillSurface(m_SurfID, 0xFFFFFFFF);
DrawFrameRect(m_SurfID, 0, 0, 256, 256 + 16, 0xFF808080);
ShowSurface(m_SurfID);
KeEnableNotification(Nf_VirtualKey);
KeEnableNotification(NfKe_TerminateProcess);
double T = 0.0;
dword FPS = 0;
dword T1 = KeGetTime();
for (;;)
{
for (dword i = 0; i < 6; i++)
DrawIter(T - 4.0 * (5 - i), 0xFFFFFFFF);
T += 1.0;
for (dword i = 0; i < 6; i++)
DrawIter(T - 4.0 * (5 - i), 0x004070FF | (((i + 1) * 0x10) << 24));
WaitRedraw();
FPS++;
dword T2 = KeGetTime();
if (T2 - T1 >= 1000)
{
dword AvgFPS = AddPerfData(FPS);
T1 = T2;
FPS = 0;
ShowStat(AvgFPS);
}
CNotification<4> Nf;
dword NfCount = KeGetNotificationCount();
for (dword i = 0; i < NfCount; i++)
{
Nf.Recv();
if (Nf.GetID() == Nf_VirtualKey)
{
if (Nf.GetByte(0) == VK_Esc)
return;
}
else if (Nf.GetID() == NfKe_TerminateProcess)
return;
}
}
}
SDL_Texture *TextureFactory::CreateWindowTexture(int width, int height, SDL_Color color, Renderer *renderer)
{
SDL_Surface *surface = CreateSurface(width, height);
SDL_Rect rect = { 0, 0, width, height};
ColorArea(rect, color, surface);
SDL_Color black = { 0, 0, 0, 255 };
DrawBox(rect, black, surface);
return CreateTexture(renderer, surface);
}
RageSurface* RageDisplay_D3D::CreateScreenshot()
{
#if defined(XBOX)
return NULL;
#else
/* Get the back buffer. */
IDirect3DSurface8* pSurface;
g_pd3dDevice->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &pSurface );
/* Get the back buffer description. */
D3DSURFACE_DESC desc;
pSurface->GetDesc( &desc );
/* Copy the back buffer into a surface of a type we support. */
IDirect3DSurface8* pCopy;
g_pd3dDevice->CreateImageSurface( desc.Width, desc.Height, D3DFMT_A8R8G8B8, &pCopy );
D3DXLoadSurfaceFromSurface( pCopy, NULL, NULL, pSurface, NULL, NULL, D3DX_DEFAULT, 0 );
pSurface->Release();
/* Update desc from the copy. */
pCopy->GetDesc( &desc );
D3DLOCKED_RECT lr;
{
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = desc.Width;
rect.bottom = desc.Height;
pCopy->LockRect( &lr, &rect, D3DLOCK_READONLY );
}
RageSurface *surface = CreateSurfaceFromPixfmt( FMT_RGBA8, lr.pBits, desc.Width, desc.Height, lr.Pitch);
ASSERT( surface );
/* We need to make a copy, since lr.pBits will go away when we call UnlockRect(). */
RageSurface *SurfaceCopy =
CreateSurface( surface->w, surface->h,
surface->format->BitsPerPixel,
surface->format->Rmask, surface->format->Gmask,
surface->format->Bmask, surface->format->Amask );
RageSurfaceUtils::CopySurface( surface, SurfaceCopy );
delete surface;
pCopy->UnlockRect();
pCopy->Release();
return SurfaceCopy;
#endif
}
//-----------------------------------------------------------------------------
// Name: LoadSpriteImage24(CBITMAP framesofAnim)
// Desc: creates surfaces for all the cells and copies image to surface cx and
// cy are absolute quards i.e. (0,0) (1,0)...
//-----------------------------------------------------------------------------
int CSPRITE::LoadSpriteImage24(char * filename)
{
DWORD *source_ptr, // working pointers
*dest_ptr;
int index_y=0, column=0,row=0,cx=0,cy=0;
CBITMAP bitmap(filename);
bitmap.LoadBitmapFile();
for(int frame=0; frame<= m_iNumberofFrames-1; frame++)
{
m_lpddsImage[frame] = CreateSurface(m_iWidth, m_iHeight,TransColor);
//clear out the ddsd
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
if(!Lock(m_lpddsImage[frame]))
return(0);
dest_ptr = (DWORD*) ddsd.lpSurface;
cx=column; cy=row;
//compute x,y
cx = cx*(m_iWidth+1) + 1;
cy = cy*(m_iHeight+1) + 1;
// extract bitmap data
source_ptr = (DWORD*)bitmap.GetImageData() + (cy*bitmap.GetWidth()+cx);
// iterate thru each scanline and copy bitmap
for (int index_y=0; index_y < m_iHeight; index_y++)
{
// copy next line of data to destination
memcpy(dest_ptr, source_ptr,m_iWidth*4);
// advance pointers
dest_ptr += (ddsd.lPitch >> 2);
source_ptr += bitmap.GetWidth();
} // end for index_y
if(!UnLock(m_lpddsImage[frame]))
return(0);
column++;
if(column > m_iCol-1)
{
column=0; row++;
}
}//End for(int i=0; i<= m_iNumberofFrames; i++)
m_iAttr = SPRITE_ATTR_LOADED;
return (1);
}
int eiTextureCell::CreateFromSurface(int sx,int sy,int color,eiDDSurface *pSurface,RECT *pSrcRect)
{
CreateTexture(sx,sy,color);
CreateSurface();
if(Data.Color <= 8){//TextureSurfaceColor/*8*/){
if(CreatePalette()){
Texture.lpSurface->SetPalette(Palette.lpPalette);
}
}
return LoadFromSurface(pSurface,pSrcRect);
}
bool RageSurfaceUtils::SaveBMP( RageSurface *surface, RageFile &f )
{
/* Convert the surface to 24bpp. */
RageSurface *converted_surface;
converted_surface = CreateSurface( surface->w, surface->h, 24,
Swap24LE( 0xFF0000 ), Swap24LE( 0x00FF00 ), Swap24LE( 0x0000FF ), 0 );
RageSurfaceUtils::CopySurface( surface, converted_surface );
RString sError;
int iFilePitch = converted_surface->pitch;
iFilePitch = (iFilePitch+3) & ~3; // round up a multiple of 4
int iDataSize = converted_surface->h * iFilePitch;
const int iHeaderSize = 0x36;
WriteBytes( f, sError, "BM", 2 );
write_le32( f, sError, iHeaderSize+iDataSize ); // size (offset 0x2)
write_le32( f, sError, 0 ); // reserved (offset 0x6)
write_le32( f, sError, iHeaderSize ); // bitmap offset (offset 0xA)
write_le32( f, sError, 0x28 ); // header size (offset 0xE)
write_le32( f, sError, surface->w ); // width (offset 0x14)
write_le32( f, sError, surface->h ); // height (offset 0x18)
write_le16( f, sError, 1 ); // planes (offset 0x1A)
write_le16( f, sError, (uint16_t) converted_surface->fmt.BytesPerPixel*8 ); // bpp (offset 0x1C)
write_le32( f, sError, 0 ); // compression (offset 0x1E)
write_le32( f, sError, iDataSize ); // bitmap size (offset 0x22)
write_le32( f, sError, 0 ); // horiz resolution (offset 0x26)
write_le32( f, sError, 0 ); // vert resolution (offset 0x2A)
write_le32( f, sError, 0 ); // colors (offset 0x2E)
write_le32( f, sError, 0 ); // important colors (offset 0x32)
for( int y = converted_surface->h-1; y >= 0; --y )
{
const uint8_t *pRow = converted_surface->pixels + converted_surface->pitch*y;
WriteBytes( f, sError, pRow, converted_surface->pitch );
/* Pad the row to the pitch. */
uint8_t padding[4] = { 0,0,0,0 };
WriteBytes( f, sError, padding, iFilePitch-converted_surface->pitch );
}
delete converted_surface;
if( sError.size() != 0 )
return false;
if( f.Flush() == -1 )
return false;
return true;
}