void init_defaultstate(IDirect3DDevice9 *device){
int i;
matrix projection_matrix, view_matrix;
IDirect3DDevice9_SetVertexShader(device, NULL);
IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CCW);
IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
IDirect3DDevice9_SetRenderState(device, D3DRS_SPECULARENABLE, TRUE);
IDirect3DDevice9_SetRenderState(device, D3DRS_NORMALIZENORMALS, TRUE);
for(i=0;i<8;i++){
IDirect3DDevice9_SetTextureStageState(device, i, D3DTSS_COLOROP, D3DTOP_DISABLE);
IDirect3DDevice9_SetTextureStageState(device, i, D3DTSS_COLORARG1, D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(device, i, D3DTSS_COLORARG2, D3DTA_CURRENT);
IDirect3DDevice9_SetTextureStageState(device, i, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
IDirect3DDevice9_SetTextureStageState(device, i, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
// IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
}
matrix_project( projection_matrix, 45.f, 4.f/3.f, 1.f, 1000.f );
IDirect3DDevice9_SetTransform( device, D3DTS_PROJECTION, (D3DMATRIX*)&projection_matrix );
matrix_identity( view_matrix );
IDirect3DDevice9_SetTransform( device, D3DTS_VIEW, (D3DMATRIX*)&view_matrix );
}
static void D3D_UpdateTextureScaleMode(D3D_RenderData *data, D3D_TextureData *texturedata, unsigned index)
{
if (texturedata->scaleMode != data->scaleMode[index]) {
IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_MINFILTER,
texturedata->scaleMode);
IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_MAGFILTER,
texturedata->scaleMode);
data->scaleMode[index] = texturedata->scaleMode;
}
}
void d3d_set_sampler_magfilter(LPDIRECT3DDEVICE dev,
unsigned sampler, unsigned value)
{
#if defined(_XBOX1)
D3D__DirtyFlags |= (D3DDIRTYFLAG_TEXTURE_STATE_0 << sampler);
D3D__TextureState[sampler][D3DTSS_MAGFILTER] = value;
#elif defined(_XBOX360)
D3DDevice_SetSamplerState_MagFilter(dev, sampler, value);
#elif defined(HAVE_D3D9) && !defined(__cplusplus)
IDirect3DDevice9_SetSamplerState(dev, sampler, D3DSAMP_MAGFILTER, value);
#else
dev->SetSamplerState(sampler, D3DSAMP_MAGFILTER, value);
#endif
}
void d3d_set_sampler_address_v(LPDIRECT3DDEVICE dev,
unsigned sampler, unsigned value)
{
#if defined(_XBOX1)
D3D__DirtyFlags |= (D3DDIRTYFLAG_TEXTURE_STATE_0 << sampler);
D3D__TextureState[sampler][D3DTSS_ADDRESSV] = value;
#elif defined(_XBOX360)
D3DDevice_SetSamplerState_AddressV_Inline(dev, sampler, value);
#elif defined(HAVE_D3D9) && !defined(__cplusplus)
IDirect3DDevice9_SetSamplerState(dev, sampler, D3DSAMP_ADDRESSV, value);
#else
dev->SetSamplerState(sampler, D3DSAMP_ADDRESSV, value);
#endif
}
/** @brief Create D3D Offscreen and Backbuffer surfaces. Each
* surface is created only if it's not already present.
* @return 1 on success, 0 on failure
*/
static int create_d3d_surfaces(void)
{
int osd_width = vo_dwidth, osd_height = vo_dheight;
int tex_width = osd_width, tex_height = osd_height;
mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>create_d3d_surfaces called.\n");
if (!priv->d3d_surface &&
FAILED(IDirect3DDevice9_CreateOffscreenPlainSurface(
priv->d3d_device, priv->src_width, priv->src_height,
priv->movie_src_fmt, D3DPOOL_DEFAULT, &priv->d3d_surface, NULL))) {
mp_msg(MSGT_VO, MSGL_ERR,
"<vo_direct3d>Allocating offscreen surface failed.\n");
return 0;
}
if (!priv->d3d_backbuf &&
FAILED(IDirect3DDevice9_GetBackBuffer(priv->d3d_device, 0, 0,
D3DBACKBUFFER_TYPE_MONO,
&priv->d3d_backbuf))) {
mp_msg(MSGT_VO, MSGL_ERR, "<vo_direct3d>Allocating backbuffer failed.\n");
return 0;
}
/* calculate the best size for the OSD depending on the factors from the device */
if (priv->device_caps_power2_only) {
tex_width = 1;
tex_height = 1;
while (tex_width < osd_width ) tex_width <<= 1;
while (tex_height < osd_height) tex_height <<= 1;
}
if (priv->device_caps_square_only)
/* device only supports square textures */
tex_width = tex_height = tex_width > tex_height ? tex_width : tex_height;
// better round up to a multiple of 16
tex_width = (tex_width + 15) & ~15;
tex_height = (tex_height + 15) & ~15;
// make sure we respect the size limits without breaking aspect or pow2-requirements
while (tex_width > priv->max_texture_width || tex_height > priv->max_texture_height) {
osd_width >>= 1;
osd_height >>= 1;
tex_width >>= 1;
tex_height >>= 1;
}
priv->osd_width = osd_width;
priv->osd_height = osd_height;
priv->osd_texture_width = tex_width;
priv->osd_texture_height = tex_height;
mp_msg(MSGT_VO, MSGL_V, "<vo_direct3d>OSD texture size (%dx%d), requested (%dx%d).\n",
vo_dwidth, vo_dheight, priv->osd_texture_width, priv->osd_texture_height);
/* create OSD */
if (!priv->d3d_texture_system &&
FAILED(IDirect3DDevice9_CreateTexture(priv->d3d_device,
priv->osd_texture_width,
priv->osd_texture_height,
1,
D3DUSAGE_DYNAMIC,
D3DFMT_A8L8,
D3DPOOL_SYSTEMMEM,
&priv->d3d_texture_system,
NULL))) {
mp_msg(MSGT_VO,MSGL_ERR,
"<vo_direct3d>Allocating OSD texture in system RAM failed.\n");
return 0;
}
if (!priv->device_texture_sys) {
/* only create if we need a shadow version on the external device */
if (!priv->d3d_texture_osd &&
FAILED(IDirect3DDevice9_CreateTexture(priv->d3d_device,
priv->osd_texture_width,
priv->osd_texture_height,
1,
D3DUSAGE_DYNAMIC,
D3DFMT_A8L8,
D3DPOOL_DEFAULT,
&priv->d3d_texture_osd,
NULL))) {
mp_msg(MSGT_VO,MSGL_ERR,
"<vo_direct3d>Allocating OSD texture in video RAM failed.\n");
return 0;
}
}
/* setup default renderstate */
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_SRCBLEND, D3DBLEND_ONE);
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHAFUNC, D3DCMP_GREATER);
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHAREF, (DWORD)0x0);
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_LIGHTING, FALSE);
IDirect3DDevice9_SetSamplerState(priv->d3d_device, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(priv->d3d_device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
return 1;
}
/**
\fn setup
\brief Allocate stuff for a given display with/height. It is called again each time the zoom is changed
*/
bool dxvaRender::setup()
{
D3DVIEWPORT9 viewPort = {0, 0, displayWidth, displayHeight, 0, 1};
ADM_info("D3D (re)Setting up \n");
D3DPRESENT_PARAMETERS presentationParameters;
memset(&presentationParameters, 0, sizeof(presentationParameters));
presentationParameters.Windowed = TRUE;
presentationParameters.SwapEffect = D3DSWAPEFFECT_DISCARD; // We could use copy, but discard seems faster according to ms
presentationParameters.Flags = D3DPRESENTFLAG_VIDEO;
presentationParameters.hDeviceWindow = windowId;
presentationParameters.BackBufferWidth = displayWidth;
presentationParameters.BackBufferHeight = displayHeight;
presentationParameters.MultiSampleType = D3DMULTISAMPLE_NONE;
presentationParameters.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
presentationParameters.BackBufferFormat = displayMode.Format;
presentationParameters.BackBufferCount = 1;
presentationParameters.EnableAutoDepthStencil = FALSE;
#ifndef REUSE_DEVICE
if(ADM_FAILED(IDirect3D9_CreateDevice( d3dHandle,
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, presentationParameters.hDeviceWindow,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&presentationParameters, &d3dDevice)))
{
ADM_warning("Failed to create D3D device\n");
return false;
}
#else
d3dDevice=admD3D::getDevice();
#endif
//
D3DFORMAT yv12=(D3DFORMAT)MAKEFOURCC('Y','V','1','2');
//
if( ADM_FAILED(IDirect3DDevice9_CreateOffscreenPlainSurface(
d3dDevice, displayWidth,displayHeight,
displayMode.Format, D3DPOOL_DEFAULT, &mySurface, NULL)))
{
ADM_warning("D3D Cannot create surface\n");
return false;
}
if( ADM_FAILED(IDirect3DDevice9_CreateOffscreenPlainSurface(
d3dDevice, imageWidth,imageHeight,
yv12, D3DPOOL_DEFAULT, &myYV12Surface, NULL)))
{
ADM_warning("D3D Cannot create surface\n");
return false;
}
// put some defaults
IDirect3DDevice9_SetRenderState(d3dDevice, D3DRS_SRCBLEND, D3DBLEND_ONE);
IDirect3DDevice9_SetRenderState(d3dDevice, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
IDirect3DDevice9_SetRenderState(d3dDevice, D3DRS_ALPHAFUNC, D3DCMP_GREATER);
IDirect3DDevice9_SetRenderState(d3dDevice, D3DRS_ALPHAREF, (DWORD)0x0);
IDirect3DDevice9_SetRenderState(d3dDevice, D3DRS_LIGHTING, FALSE);
IDirect3DDevice9_SetSamplerState(d3dDevice, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(d3dDevice, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
//
if(ADM_FAILED(IDirect3DDevice9_SetViewport(d3dDevice, &viewPort)))
{
ADM_warning("D3D Cannot set D3D viewport\n");
return false;
}
scaler=new ADMColorScalerFull(ADM_CS_BICUBIC,imageWidth,imageHeight,displayWidth,displayHeight,
ADM_COLOR_YV12,
ADM_COLOR_RGB32A
);
videoBuffer=new uint8_t[displayWidth*displayHeight*4];
panScan.left =0;
panScan.right =imageWidth-1;
panScan.top =0;
panScan.bottom=imageHeight-1;
targetRect.left =0;
targetRect.right =displayWidth-1;
targetRect.top =0;
targetRect.bottom=displayHeight-1;
ADM_info("Setup done\n");
return true;
}
int main(){
BOOL done = FALSE;
MSG msg;
IDirect3DDevice9 *device = NULL;
IDirect3DSurface9 *main_rendertarget = NULL;
D3DFORMAT format;
float old_time = 0;
/* render-to-texture-stuff */
IDirect3DTexture9 *rtt_texture;
IDirect3DSurface9 *rtt_surface;
IDirect3DTexture9 *rtt_32_texture;
IDirect3DSurface9 *rtt_32_surface;
/* textures used from mainloop */
int white, black;
int odd_is_back_again[4];
int at_the_gathering_2003[4];
int o_d_d_in_your_face[4];
int world_domination[4];
int back_once_again[3];
int were_back;
int cred[4];
int mad_props[4];
int not_eph[4];
int piss_the_fuck_off[11];
int hardcore;
int refmap, refmap2;
int eatyrcode;
int code_0, code_1;
int overlaytest;
int circle_particle;
/* special-textures */
int rtt_texture_id;
int rtt_32_texture_id;
int video_texture_id;
int dilldall,dilldall2;
int metaball_text;
/* videos */
video *vid;
/* 3d-scenes */
scene *fysikkfjall;
scene *startblob;
scene *inni_abstrakt;
scene *korridor;
scene *skjerm_rom;
scene *bare_paa_lissom;
format = D3DFMT_X8R8G8B8;
device = d3dwin_open(TITLE, WIDTH, HEIGHT, format, FULLSCREEN);
if(!device){
format = D3DFMT_A8R8G8B8;
device = d3dwin_open(TITLE, WIDTH, HEIGHT, format, FULLSCREEN);
if(!device){
format = D3DFMT_X1R5G5B5;
device = d3dwin_open(TITLE, WIDTH, HEIGHT, format, FULLSCREEN);
if(!device){
format = D3DFMT_R5G6B5;
device = d3dwin_open(TITLE, WIDTH, HEIGHT, format, FULLSCREEN);
if(!device) error("failed to initialize Direct3D9");
}
}
}
#ifdef BIGSCREEN
set_gamma(device,1.05f);
#endif
if (!BASS_Init(1, 44100, BASS_DEVICE_LATENCY, win, NULL)) error("failed to initialize BASS");
fp = file_open("worlddomination.ogg");
if (!fp) error("music-file not found");
music_file = BASS_StreamCreateFile(1, fp->data, 0, fp->size, 0);
/*** music ***/
// if(!pest_open(win)) error("failed to initialize DirectSond");
// if(!pest_load("worlddomination.ogg",0)) error("failed to load music-file");
/*** subsystems ***/
init_tunnel();
video_init();
if(!init_particles(device)) error("failed to initialize");
if(!init_overlays(device)) error("f**k a duck");
if(!init_marching_cubes(device)) error("screw a kangaroo");
make_random_particles(particles, PARTICLES, vector_make(0,-180,0), 500);
make_random_particles(particles2, PARTICLES2, vector_make(0,-180,0), 500);
make_random_particles(particles3, PARTICLES3, vector_make(0,0,0), 800);
/*** rendertextures ***/
if (IDirect3DDevice9_CreateTexture(device, 512, 256, 0,D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &rtt_texture, NULL)!=D3D_OK) error("failed to create rendertarget-texture");
if (IDirect3DTexture9_GetSurfaceLevel(rtt_texture,0,&rtt_surface)!=D3D_OK) error("could not get kvasi-backbuffer-surface");
if ((rtt_texture_id=texture_insert(device, "rendertexture.jpg", rtt_texture))==-1) error("fakk off!");
if(IDirect3DDevice9_CreateTexture(device,16,16,0,D3DUSAGE_RENDERTARGET|D3DUSAGE_AUTOGENMIPMAP,D3DFMT_X8R8G8B8,D3DPOOL_DEFAULT, &rtt_32_texture, NULL)!=D3D_OK) error("failed to create rendertarget-texture");
if(IDirect3DTexture9_GetSurfaceLevel(rtt_32_texture,0,&rtt_32_surface)!=D3D_OK) error("could not get kvasi-backbuffer-surface");
if((rtt_32_texture_id=texture_insert(device, "rendertexture2.jpg", rtt_32_texture))==-1) error("fakk off!");
/*** textures ***/
/* solid colors for fades etc */
if((white=texture_load(device,"white.png",FALSE))==-1) error("shjit!");
if((black=texture_load(device,"black.png",FALSE))==-1) error("shjit!");
/* textoverlays */
if((odd_is_back_again[0]=texture_load(device,"odd_is_back_again_0.png",FALSE))==-1) error("failed to load image");
if((odd_is_back_again[1]=texture_load(device,"odd_is_back_again_1.png",FALSE))==-1) error("failed to load image");
if((odd_is_back_again[2]=texture_load(device,"odd_is_back_again_2.png",FALSE))==-1) error("failed to load image");
if((odd_is_back_again[3]=texture_load(device,"odd_is_back_again_3.png",FALSE))==-1) error("failed to load image");
if((at_the_gathering_2003[0]=texture_load(device,"at_the_gathering_2003_0.png",FALSE))==-1) error("failed to load image");
if((at_the_gathering_2003[1]=texture_load(device,"at_the_gathering_2003_1.png",FALSE))==-1) error("failed to load image");
if((at_the_gathering_2003[2]=texture_load(device,"at_the_gathering_2003_2.png",FALSE))==-1) error("failed to load image");
if((at_the_gathering_2003[3]=texture_load(device,"at_the_gathering_2003_3.png",FALSE))==-1) error("failed to load image");
if((back_once_again[0]=texture_load(device,"back_once_again_0.png",TRUE))==-1) error("failed to load image");
if((back_once_again[1]=texture_load(device,"back_once_again_1.png",TRUE))==-1) error("failed to load image");
if((back_once_again[2]=texture_load(device,"back_once_again_2.png",TRUE))==-1) error("failed to load image");
if((o_d_d_in_your_face[0]=texture_load(device,"o_d_d_in_your_face_0.png",TRUE))==-1) error("failed to load image");
if((o_d_d_in_your_face[1]=texture_load(device,"o_d_d_in_your_face_1.png",TRUE))==-1) error("failed to load image");
if((o_d_d_in_your_face[2]=texture_load(device,"o_d_d_in_your_face_2.png",TRUE))==-1) error("failed to load image");
if((o_d_d_in_your_face[3]=texture_load(device,"o_d_d_in_your_face_3.png",TRUE))==-1) error("failed to load image");
if((world_domination[0]=texture_load(device,"world_domination_0.png",TRUE))==-1) error("failed to load image");
if((world_domination[1]=texture_load(device,"world_domination_1.png",TRUE))==-1) error("failed to load image");
if((world_domination[2]=texture_load(device,"world_domination_2.png",TRUE))==-1) error("failed to load image");
if((world_domination[3]=texture_load(device,"world_domination_3.png",TRUE))==-1) error("failed to load image");
if((were_back=texture_load(device,"were_back.png",TRUE))==-1) error("failed to load image");
if((cred[0]=texture_load(device,"cred_0.png",TRUE))==-1) error("failed to load image");
if((cred[1]=texture_load(device,"cred_1.png",TRUE))==-1) error("failed to load image");
if((cred[2]=texture_load(device,"cred_2.png",TRUE))==-1) error("failed to load image");
if((cred[3]=texture_load(device,"cred_3.png",TRUE))==-1) error("failed to load image");
if((mad_props[0]=texture_load(device,"mad_props_0.png",TRUE))==-1) error("failed to load image");
if((mad_props[1]=texture_load(device,"mad_props_1.png",TRUE))==-1) error("failed to load image");
if((mad_props[2]=texture_load(device,"mad_props_2.png",TRUE))==-1) error("failed to load image");
if((mad_props[3]=texture_load(device,"mad_props_3.png",TRUE))==-1) error("failed to load image");
if((not_eph[0]=texture_load(device,"not_eph_0.png",TRUE))==-1) error("failed to load image");
if((not_eph[1]=texture_load(device,"not_eph_1.png",TRUE))==-1) error("failed to load image");
if((not_eph[2]=texture_load(device,"not_eph_2.png",TRUE))==-1) error("failed to load image");
if((not_eph[3]=texture_load(device,"not_eph_3.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[0]=texture_load(device,"piss_the_fuck_off_0.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[1]=texture_load(device,"piss_the_fuck_off_1.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[2]=texture_load(device,"piss_the_fuck_off_2.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[3]=texture_load(device,"piss_the_fuck_off_3.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[4]=texture_load(device,"piss_the_fuck_off_4.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[5]=texture_load(device,"piss_the_fuck_off_5.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[6]=texture_load(device,"piss_the_fuck_off_6.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[7]=texture_load(device,"piss_the_fuck_off_7.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[8]=texture_load(device,"piss_the_fuck_off_8.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[9]=texture_load(device,"piss_the_fuck_off_9.png",TRUE))==-1) error("failed to load image");
if((piss_the_fuck_off[10]=texture_load(device,"piss_the_fuck_off_10.png",TRUE))==-1) error("failed to load image");
if((hardcore=texture_load(device,"hardcore.png",TRUE))==-1) error("failed to load image");
/* other textures */
if((circle_particle=texture_load(device,"circle_particle.jpg",FALSE))==-1) error("shjit!");
if((refmap=texture_load(device,"fysikkfjall/refmap.jpg",FALSE))==-1) error("shjit!");
if((refmap2=texture_load(device,"refmap2.jpg",FALSE))==-1) error("shjit!");
if((eatyrcode=texture_load(device,"eatyrcode.jpg",FULLSCREEN_HACK))==-1) error("shjit!");
if((code_0=texture_load(device,"code-0.jpg",FALSE))==-1) error("shjit!");
if((code_1=texture_load(device,"code-1.jpg",FALSE))==-1) error("shjit!");
if((overlaytest=texture_load(device,"overlaytest.jpg",FALSE))==-1) error("shjit!");
if((dilldall=texture_load(device,"dilldall.png",FALSE))==-1) error("shjit!");
if((dilldall2=texture_load(device,"dilldall2.png",FALSE))==-1) error("shjit!");
if((metaball_text=texture_load(device,"metaballs.png",TRUE))==-1) error("shjit!");
/*** video ***/
if(!(vid=video_load(device,"test.kpg"))) error("fæck!");
video_texture_id = texture_insert(device, "skjerm_rom/skjerm_tom.tga", vid->texture);
/*** misc stuff ***/
/* main rendertarget */
IDirect3DDevice9_GetRenderTarget(device,0,&main_rendertarget);
/* default state */
IDirect3DDevice9_CreateStateBlock(device, D3DSBT_ALL, &default_state);
init_defaultstate(device);
IDirect3DStateBlock9_Capture(default_state);
/*** 3d scenes ***/
if(!(fysikkfjall=load_scene(device,"fysikkfjall/fysikkfjall.krs"))) error("failed to load 3d scene");
if(!(startblob=load_scene(device,"startblob/startblob.krs"))) error("failed to load 3d scene");
if(!(inni_abstrakt=load_scene(device,"inni_abstrakt/inni_abstrakt.krs"))) error("failed to load 3d scene");
if(!(korridor=load_scene(device,"korridor/korridor.krs"))) error("failed to load 3d scene");
if(!(skjerm_rom=load_scene(device,"skjerm_rom/skjerm_rom.krs"))) error("failed to load 3d scene");
if(!(bare_paa_lissom=load_scene(device,"bare_paa_lissom/bare_paa_lissom.krs"))) error("failed to load 3d scene");
// pest_play();
BASS_Start();
BASS_StreamPlay(music_file, 1, 0);
do{
grid g;
int i;
matrix m, temp, temp_matrix;
matrix marching_cubes_matrix;
long long bytes_played = BASS_ChannelGetPosition(music_file);
float time = bytes_played * (1.0 / (44100 * 2 * 2));
// float time = pest_get_pos()+0.05f;
float delta_time = time-old_time;
int beat = (int)(time*((float)BPM/60.f));
if(time_index<(sizeof(timetable)/4)){
while(timetable[time_index]<time) time_index++;
}
#ifdef _DEBUG
printf("time: %2.2f, delta_time: %2.2f, time_index: %i, beat: %i \r",time,delta_time,time_index,beat);
#endif
IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
IDirect3DStateBlock9_Apply(default_state);
IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0, 1.0f, 0);
// IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
IDirect3DDevice9_BeginScene(device);
#if 1
if(time_index<40){
if(time_index>0&&time_index<5){
draw_overlay(device,odd_is_back_again[time_index-1],0,0,1,FALSE);
}else if(time_index>4&&time_index<19){
float itime = time*10;
grid_flat(g,0,0);
for(i=0;i<7;i++){
int scale = (time_index&1);
grid_wave(g,(float)sin(itime-i+sin(i-itime))*0.3f*scale,(float)cos(itime*0.69f+i*0.733f)*0.3f*scale,7,(float)sin(itime+i*0.1f)*0.5f*scale);
}
draw_grid(device, g, odd_is_back_again[3], FALSE);
}else if(time_index>=19){
float itime = (time-timetable[18])*0.5f;
grid_flat(g,0,0);
for(i=0;i<7;i++){
grid_wave(g,(float)sin(time-i+sin(i-time))*0.3f,(float)cos(time*0.69f+i*0.733f)*0.3f,7, itime*itime);
}
draw_grid(device, g, odd_is_back_again[3], FALSE);
}
if(time_index>20&&time_index<25){
draw_overlay(device,at_the_gathering_2003[(time_index-21)%4],0,0,1,TRUE);
}else if(time_index>=25&&time_index<38){
float itime = time*10;
grid_flat(g,0,0);
for(i=0;i<10;i++){
int scale = (time_index&1);
grid_wave(g,(float)sin(itime-i+sin(i-itime))*0.3f*scale,(float)cos(itime*0.69f+i*0.733f)*0.3f*scale,7,(float)sin(itime+i*0.1f)*0.5f*scale);
}
draw_grid(device,g,at_the_gathering_2003[3],TRUE);
}else if(time_index>=38){
float itime = (time-timetable[37])*0.5f;
grid_flat(g,0,0);
for(i=0;i<10;i++){
grid_wave(g,(float)sin(time-i+sin(i-time))*0.3f,(float)cos(time*0.69f+i*0.733f)*0.3f,7, itime*itime);
}
draw_grid(device,g,at_the_gathering_2003[3],TRUE);
}
}else if(time_index<52){
animate_scene(inni_abstrakt,(time-timetable[39]));
draw_scene(device,inni_abstrakt,0,TRUE);
flash(device,white,time,timetable[39],1);
if(time_index<43){
draw_overlay(device, back_once_again[(time_index-40)%3],0,0,1,FALSE);
}else if(time_index<47){
draw_overlay(device, o_d_d_in_your_face[(time_index-43)%4],0,0,1,FALSE);
}else if(time_index<51){
draw_overlay(device, world_domination[(time_index-47)%4],0,0,1,FALSE);
}else{
draw_overlay(device, were_back,0,0,(time-timetable[51]),FALSE);
}
draw_overlay(device,dilldall,sin(sin(time)*0.07f+(((beat+1)/2)*0.8f)),sin(time*0.03337f+(((beat+1)/2)*0.14f)),0.5f,TRUE);
draw_overlay(device,dilldall2,sin(sin(time*0.1f)*0.07f+time*0.1f+(((beat+1)/2)*0.8f)),sin(time*0.01337f+(((beat+1)/2)*0.14f)),0.5f,TRUE);
}else if(time_index<69){
animate_scene(startblob,(time-timetable[39]-0.27f+((beat+1)&2))*0.74948f);
startblob->cameras[0].fog = TRUE;
startblob->cameras[0].fog_start = 100.f;
startblob->cameras[0].fog_end = 700.f;
if(time_index>=53 && time_index<66 && time_index&1 ){
float f = fade(timetable[time_index-1],1.7f,time,0.5f,0);
f *= f;
f *= 2;
if(f>0.f)
IDirect3DDevice9_SetRenderTarget(device,0,rtt_surface);
draw_scene(device,startblob,0,TRUE);
draw_particles(device, particles3, PARTICLES3, code_0);
if(f>0.f){
IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
draw_radialblur(device,0,0,f,0,rtt_texture_id, FALSE);
}
if(time_index<61) draw_overlay(device,cred[((time_index/2)-2)%4],0,0,f*3,FALSE);
}else{
draw_scene(device,startblob,0,TRUE);
draw_particles(device, particles3, PARTICLES3, circle_particle);
}
if(time_index>=54&& !(time_index&1)){
float f = fade(timetable[time_index-1],1.8f,time,1.f,0)*0.8f;
IDirect3DDevice9_SetRenderTarget(device,0,rtt_32_surface);
draw_scene(device,startblob,0,TRUE);
draw_particles(device, particles3, PARTICLES3, code_0);
IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
draw_overlay(device,rtt_32_texture_id,0,0,f,TRUE);
draw_overlay(device,rtt_32_texture_id,0,0,f,TRUE);
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
}
flash(device,were_back,time,timetable[51],2);
flash(device,white,time,timetable[51],1);
}else if(time_index<79){
for(i=0;i<BALLS;i++){
balls[i].pos.x = (float)sin(time+i-sin((float)i*0.1212111f))*0.35f;
balls[i].pos.y = (float)cos(time-(float)i*0.29342111f)*0.35f;
balls[i].pos.z = (float)sin(time*0.31121f+sin(i-time))*0.35f;
balls[i].r = 0.15f + (float)sin(time+i)*0.01f;
balls[i].pos = vector_normalize(balls[i].pos);
balls[i].pos = vector_scale(balls[i].pos, (float)(cos(i*0.11131f-time*0.55311f)+sin(time+(float)sin(time-i+time*0.3f)))*0.2f );
}
animate_scene(korridor,(time-timetable[68])*0.65f );
draw_scene(device,korridor,(beat/4)&1,TRUE);
memcpy(temp,korridor->objects[korridor->object_count-1]->mat,sizeof(matrix));
matrix_scale(marching_cubes_matrix,vector_make(120,120,120));
matrix_multiply(marching_cubes_matrix,temp,marching_cubes_matrix);
matrix_rotate(temp,vector_make(time,-time,time*0.5f+sin(time)));
matrix_multiply(marching_cubes_matrix,marching_cubes_matrix,temp);
IDirect3DDevice9_SetTransform( device, D3DTS_WORLD, (D3DMATRIX*)&marching_cubes_matrix );
fill_metafield_blur(balls, BALLS,0.98f);
march_my_cubes_opt(balls, BALLS, 0.9f);
IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
set_texture(device,0,refmap2);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR );
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
draw_marched_cubes(device);
flash(device,white,time,timetable[68],1);
if(time_index>69&&time_index<74){
draw_overlay(device,mad_props[(time_index+2)%4],0,0,1,FALSE);
}else if(time_index>73&&time_index<77){
draw_overlay(device,not_eph[(time_index+2)%4],0,0,1,FALSE);
}else if(time_index==77){
float f = fade(timetable[76],2.5f,time,1,0);
draw_overlay(device,not_eph[3],0,0,f,FALSE);
}
}
if(time_index>77&&time_index<92){
float f = fade(timetable[77],timetable[78]-timetable[77],time,0,1);
draw_overlay(device,eatyrcode,0,0,f,FALSE);
if(time>109.5f){
IDirect3DStateBlock9_Apply(default_state);
animate_particles(particles, PARTICLES, delta_time*30);
animate_particles(particles2, PARTICLES2, delta_time*28);
draw_particles(device, particles, PARTICLES, code_0);
draw_particles(device, particles2, PARTICLES2, code_1);
}
if(time_index>79&&time_index<90){
draw_overlay(device,piss_the_fuck_off[(time_index-80)%11],0,0,1,FALSE);
}else if(time_index==90){
float f = fade(timetable[89],2,time,1,0);
draw_overlay(device,piss_the_fuck_off[10],0,0,f,FALSE);
}
if(time_index==91){
float f = fade(timetable[90],2,time,1,0);
draw_overlay(device,hardcore,0,0,f,FALSE);
}
}else if(time_index>91 && time_index<97){
animate_scene(skjerm_rom,time);
video_update(vid, time);
draw_scene(device,skjerm_rom,((beat/4)&1),TRUE);
draw_overlay(device,dilldall,sin(sin(time)*0.07f+(((beat+1)/2)*0.8f)),sin(time*0.03337f+(((beat+1)/2)*0.14f)),0.5f,TRUE);
draw_overlay(device,dilldall2,sin(sin(time*0.1f)*0.07f+time*0.1f+(((beat+1)/2)*0.8f)),sin(time*0.01337f+(((beat+1)/2)*0.14f)),0.5f,TRUE);
if(time_index>92)
draw_overlay(device, world_domination[(time_index-93)%4],0,0,1,FALSE);
}else if(time_index>96&&time_index<104){
grid_zero(g);
matrix_translate(m, vector_make(cos(time)*1.5f, sin(time)*1.5f,time*10));
matrix_rotate(temp_matrix, vector_make(sin(time*0.8111f)*0.2f,sin(time*1.2f)*0.2f,time));
matrix_multiply(m,m,temp_matrix);
render_tunnel(g,m);
matrix_rotate(temp_matrix, vector_make(0,M_PI,0));
matrix_multiply(m,m,temp_matrix);
render_tunnel(g,m);
matrix_rotate(temp_matrix, vector_make(M_PI,0,0));
matrix_multiply(m,m,temp_matrix);
render_tunnel(g,m);
grid_add_noice(g,sin(time)*0.1f);
draw_grid(device, g, circle_particle, FALSE);
if(time_index>97&&time_index<102){
float f = 1;
if(time_index==101) f = fade(timetable[100],3,time,1,0);
draw_overlay(device, o_d_d_in_your_face[(time_index-42)%4],0,0,f,FALSE);
}
}
if(time_index>101 && time_index<104){
float f = fade(timetable[101],8,time,0,1);
float f2 = fade(timetable[101],4,time,0,1);
draw_overlay(device,black,0,0,f2,FALSE);
IDirect3DDevice9_SetRenderTarget(device,0,rtt_surface);
IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
IDirect3DStateBlock9_Apply(default_state);
animate_scene(bare_paa_lissom,time-timetable[101]);
draw_scene(device,bare_paa_lissom,0,TRUE);
time *=0.5f;
for(i=0;i<BALLS2;i++){
balls2[i].pos.x = (float)sin(time+i-sin((float)i*0.1212111f))*0.35f;
balls2[i].pos.y = (float)cos(time-(float)i*0.29342111f)*0.35f;
balls2[i].pos.z = (float)sin(time*0.31121f+sin(i-time))*0.35f;
balls2[i].r = 0.15f + (float)sin(time+i)*0.01f;
balls2[i].pos = vector_normalize(balls2[i].pos);
balls2[i].pos = vector_scale(balls2[i].pos, (float)(cos(i*0.11131f-time*0.55311f)+sin(time+(float)sin(time-i+time*0.3f)))*0.2f );
}
memcpy(temp,bare_paa_lissom->objects[bare_paa_lissom->object_count-1]->mat,sizeof(matrix));
matrix_scale(marching_cubes_matrix,vector_make(120,120,120));
matrix_multiply(marching_cubes_matrix,temp,marching_cubes_matrix);
IDirect3DDevice9_SetTransform( device, D3DTS_WORLD, (D3DMATRIX*)&marching_cubes_matrix );
fill_metafield(balls2, BALLS2);
march_my_cubes_opt(balls2, BALLS2, 0.9f);
IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
set_texture(device,0,refmap);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR );
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
draw_marched_cubes(device);
IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
draw_overlay(device,rtt_texture_id,0,0,f,TRUE);
if(time_index==103){
float f;
time *= 2;
f = fade(timetable[time_index-1],3,time,1,0);
draw_overlay(device,metaball_text,0,0,f,FALSE);
flash(device,white,time,timetable[time_index-1],1);
}
}
if(time_index==104){
float f = fade(timetable[103],timetable[104]-timetable[103],time,0,1);
animate_scene(korridor,180-(time-timetable[time_index-1])*0.8f );
draw_scene(device,korridor,(beat/4)&1,TRUE);
draw_overlay(device,black,0,0,f,FALSE);
}
if(time_index==105){
float f = fade(timetable[104],timetable[105]-timetable[104],time,0,1);
float t = (time-timetable[time_index-1])*0.6f+2.2f;
animate_scene(fysikkfjall,t);
draw_scene(device,fysikkfjall,0,TRUE);
draw_overlay(device,black,0,0,f,FALSE);
}
#endif
/*
*/
/*
draw_overlay(device, were_back, (1+sin(time))*0.5f, TRUE);
*/
// animate_scene(risterom,time);
// draw_scene(device,risterom,0,TRUE);
#if 0 //helvete_har_frosset
draw_overlay(device, eatyrcode, 1,FALSE);
IDirect3DStateBlock9_Apply(default_state);
animate_particles(particles, PARTICLES, delta_time*30);
animate_particles(particles2, PARTICLES2, delta_time*28);
draw_particles(device, particles, PARTICLES, code_0);
draw_particles(device, particles2, PARTICLES2, code_1);
#endif
#ifdef pikk
// IDirect3DDevice9_SetRenderTarget(device,0,rtt_surface);
IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
draw_overlay(device, eatyrcode, TRUE);
animate_scene(startblob,(time-timetable[39]-0.27f)*0.7453f);
draw_scene(device,startblob,0,FALSE);
draw_particles(device, particles, PARTICLES, code_0);
draw_particles(device, particles2, PARTICLES2, code_1);
// IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
/*
draw_radialblur(device,
(float)sin(time)*0.2f,
(float)sin(-time*0.331f)*0.13f,
(float)(2+(float)sin(time*0.5f))*0.2f,
0,//sin(time)*0.25f,
rtt_texture_id, TRUE);
animate_scene(fysikkfjall,time);
draw_scene(device,fysikkfjall,0,FALSE);
*/
// draw_overlay(device, rtt_texture_id, TRUE);
#endif
// draw_overlay(device, eatyrcode, FALSE);
// video_update(vid, time);
#if 0
// IDirect3DDevice9_SetRenderTarget(device,0,rtt_surface);
animate_scene(testscene,time);
// morph_object(testscene->objects[0], time );
draw_scene(device,testscene,0,TRUE);
// draw_particles(device, particles, PARTICLES, particle);
// IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
#endif
#if 0
time *=0.5f;
for(i=0;i<BALLS2;i++){
balls2[i].pos.x = (float)sin(time+i-sin((float)i*0.1212111f))*0.35f;
balls2[i].pos.y = (float)cos(time-(float)i*0.29342111f)*0.35f;
balls2[i].pos.z = (float)sin(time*0.31121f+sin(i-time))*0.35f;
balls2[i].r = 0.15f + (float)sin(time+i)*0.01f;
balls2[i].pos = vector_normalize(balls2[i].pos);
balls2[i].pos = vector_scale(balls2[i].pos, (float)(cos(i*0.11131f-time*0.55311f)+sin(time+(float)sin(time-i+time*0.3f)))*0.2f );
// balls2[i].pos.x *= 2.8f;
}
matrix_translate(temp,vector_make(0,0,87));
matrix_scale(marching_cubes_matrix,vector_make(50,50,50));
matrix_multiply(marching_cubes_matrix,temp,marching_cubes_matrix);
IDirect3DDevice9_SetTransform( device, D3DTS_WORLD, (D3DMATRIX*)&marching_cubes_matrix );
fill_metafield(balls2, BALLS2);
// fill_metafield_blur(balls, BALLS,0.98f);
march_my_cubes_opt(balls2, BALLS2, 0.9f);
// march_my_cubes(0.9f);
IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CW);
set_texture(device,0,refmap);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR );
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
draw_marched_cubes(device);
#endif
#if 0
// time *= 0.5f;
grid_zero(g);
// for(i=0;i<10;i++)
// grid_wave(g,sin(time-i+sin(i-time))*0.3f,cos(time*0.69f+i*0.733f)*0.3f,7,sin(time+i*0.1f)*0.5f);
matrix_translate(m, vector_make(cos(time)*1.5f, sin(time)*1.5f,time*10));
matrix_rotate(temp_matrix, vector_make(sin(time*0.8111f)*0.2f,sin(time*1.2f)*0.2f,time));
matrix_multiply(m,m,temp_matrix);
// empty_grid( grid );
render_tunnel(g,m);
matrix_rotate(temp_matrix, vector_make(0,M_PI,0));
matrix_multiply(m,m,temp_matrix);
render_tunnel(g,m);
matrix_rotate(temp_matrix, vector_make(M_PI,0,0));
matrix_multiply(m,m,temp_matrix);
render_tunnel(g,m);
// tyfuus_expand_grid( screen, grid, texture );
grid_add_noice(g,sin(time)*0.1f);
draw_grid(device, g, circle_particle, FALSE);
#endif
// IDirect3DDevice9_SetRenderTarget(device,0,main_rendertarget);
// video_update(vid,time);
/*
draw_radialblur(device,
(float)sin(time)*0.2f,
(float)sin(-time*0.331f)*0.13f,
(float)(1+(float)sin(time*0.5f))*0.2f,
0,//sin(time)*0.25f,
rtt_texture_id, FALSE);
*/
// IDirect3DStateBlock9_Apply(default_state);
// draw_overlay(device,rtt_texture_id,FALSE);
// draw_overlay(device,fullscreen,FALSE);
// draw_radialblur(device,0,sin(time*0.2f)*2.f, rtt_texture_id);
// IDirect3DDevice9_StretchRect(device,main_rendertarget,NULL,rtt_surface,NULL,D3DTEXF_NONE);
// IDirect3DBaseTexture9_GenerateMipSubLevels(rtt_texture);
IDirect3DDevice9_EndScene(device);
if(IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL)==D3DERR_DEVICELOST)
error("fakkin lost device. keep your hands off alt-tab, looser.");
old_time = time;
while (PeekMessage(&msg,NULL,0,0,PM_REMOVE)){
TranslateMessage(&msg);
DispatchMessage(&msg);
if (msg.message == WM_QUIT ||
msg.message == WM_KEYDOWN && LOWORD(msg.wParam) == VK_ESCAPE)
done = TRUE;
}
}while(!done);
deinit_marching_cubes();
deinit_overlays();
deinit_particles();
free_scene(fysikkfjall);
free_scene(startblob);
free_scene(inni_abstrakt);
free_scene(korridor);
free_scene(skjerm_rom);
free_scene(bare_paa_lissom);
free_materials();
free_textures();
free_video(vid);
rtt_surface->lpVtbl->Release(rtt_surface);
rtt_32_surface->lpVtbl->Release(rtt_32_surface);
main_rendertarget->lpVtbl->Release(main_rendertarget);
IDirect3DStateBlock9_Release(default_state);
d3dwin_close();
if (music_file) BASS_StreamFree( music_file );
if (fp) file_close( fp );
BASS_Free();
// pest_close();
return 0;
}
static int
D3D_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
D3D_TextureData *texturedata = (D3D_TextureData *) texture->driverdata;
LPDIRECT3DPIXELSHADER9 shader = NULL;
float minx, miny, maxx, maxy;
float minu, maxu, minv, maxv;
DWORD color;
Vertex vertices[4];
HRESULT result;
if (D3D_ActivateRenderer(renderer) < 0) {
return -1;
}
minx = (float) dstrect->x - 0.5f;
miny = (float) dstrect->y - 0.5f;
maxx = (float) dstrect->x + dstrect->w - 0.5f;
maxy = (float) dstrect->y + dstrect->h - 0.5f;
minu = (float) srcrect->x / texture->w;
maxu = (float) (srcrect->x + srcrect->w) / texture->w;
minv = (float) srcrect->y / texture->h;
maxv = (float) (srcrect->y + srcrect->h) / texture->h;
color = D3DCOLOR_ARGB(texture->a, texture->r, texture->g, texture->b);
vertices[0].x = minx;
vertices[0].y = miny;
vertices[0].z = 0.0f;
vertices[0].color = color;
vertices[0].u = minu;
vertices[0].v = minv;
vertices[1].x = maxx;
vertices[1].y = miny;
vertices[1].z = 0.0f;
vertices[1].color = color;
vertices[1].u = maxu;
vertices[1].v = minv;
vertices[2].x = maxx;
vertices[2].y = maxy;
vertices[2].z = 0.0f;
vertices[2].color = color;
vertices[2].u = maxu;
vertices[2].v = maxv;
vertices[3].x = minx;
vertices[3].y = maxy;
vertices[3].z = 0.0f;
vertices[3].color = color;
vertices[3].u = minu;
vertices[3].v = maxv;
D3D_SetBlendMode(data, texture->blendMode);
if (texturedata->scaleMode != data->scaleMode) {
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
texturedata->scaleMode);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
texturedata->scaleMode);
data->scaleMode = texturedata->scaleMode;
}
result =
IDirect3DDevice9_SetTexture(data->device, 0, (IDirect3DBaseTexture9 *)
texturedata->texture);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, shader);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, NULL);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
return 0;
}
/**
* It allocates and initializes the resources needed to render the scene.
*/
static int Direct3DCreateScene(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
LPDIRECT3DDEVICE9 d3ddev = sys->d3ddev;
HRESULT hr;
/*
* Create a texture for use when rendering a scene
* for performance reason, texture format is identical to backbuffer
* which would usually be a RGB format
*/
LPDIRECT3DTEXTURE9 d3dtex;
hr = IDirect3DDevice9_CreateTexture(d3ddev,
sys->d3dpp.BackBufferWidth,
sys->d3dpp.BackBufferHeight,
1,
D3DUSAGE_RENDERTARGET,
sys->d3dpp.BackBufferFormat,
D3DPOOL_DEFAULT,
&d3dtex,
NULL);
if (FAILED(hr)) {
msg_Err(vd, "Failed to create texture. (hr=0x%lx)", hr);
return VLC_EGENERIC;
}
/*
** Create a vertex buffer for use when rendering scene
*/
LPDIRECT3DVERTEXBUFFER9 d3dvtc;
hr = IDirect3DDevice9_CreateVertexBuffer(d3ddev,
sizeof(CUSTOMVERTEX)*4,
D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY,
D3DFVF_CUSTOMVERTEX,
D3DPOOL_DEFAULT,
&d3dvtc,
NULL);
if (FAILED(hr)) {
msg_Err(vd, "Failed to create vertex buffer. (hr=0x%lx)", hr);
IDirect3DTexture9_Release(d3dtex);
return VLC_EGENERIC;
}
/* */
sys->d3dtex = d3dtex;
sys->d3dvtc = d3dvtc;
// Texture coordinates outside the range [0.0, 1.0] are set
// to the texture color at 0.0 or 1.0, respectively.
IDirect3DDevice9_SetSamplerState(d3ddev, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
IDirect3DDevice9_SetSamplerState(d3ddev, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
// Set linear filtering quality
IDirect3DDevice9_SetSamplerState(d3ddev, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(d3ddev, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
// set maximum ambient light
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_AMBIENT, D3DCOLOR_XRGB(255,255,255));
// Turn off culling
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_CULLMODE, D3DCULL_NONE);
// Turn off the zbuffer
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_ZENABLE, D3DZB_FALSE);
// Turn off lights
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_LIGHTING, FALSE);
// Enable dithering
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_DITHERENABLE, TRUE);
// disable stencil
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_STENCILENABLE, FALSE);
// manage blending
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_ALPHABLENDENABLE, TRUE);
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_ALPHATESTENABLE,TRUE);
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_ALPHAREF, 0x10);
IDirect3DDevice9_SetRenderState(d3ddev, D3DRS_ALPHAFUNC,D3DCMP_GREATER);
// Set texture states
IDirect3DDevice9_SetTextureStageState(d3ddev, 0, D3DTSS_COLOROP,D3DTOP_MODULATE);
IDirect3DDevice9_SetTextureStageState(d3ddev, 0, D3DTSS_COLORARG1,D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(d3ddev, 0, D3DTSS_COLORARG2,D3DTA_DIFFUSE);
// turn off alpha operation
IDirect3DDevice9_SetTextureStageState(d3ddev, 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
msg_Dbg(vd, "Direct3D scene created successfully");
return VLC_SUCCESS;
}
static int
D3D_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_FRect * dstrect,
const double angle, const SDL_FPoint * center, const SDL_RendererFlip flip)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
D3D_TextureData *texturedata = (D3D_TextureData *) texture->driverdata;
LPDIRECT3DPIXELSHADER9 shader = NULL;
float minx, miny, maxx, maxy;
float minu, maxu, minv, maxv;
float centerx, centery;
DWORD color;
Vertex vertices[4];
HRESULT result;
if (D3D_ActivateRenderer(renderer) < 0) {
return -1;
}
centerx = center->x;
centery = center->y;
if (flip & SDL_FLIP_HORIZONTAL) {
minx = dstrect->w - centerx - 0.5f;
maxx = -centerx - 0.5f;
}
else {
minx = -centerx - 0.5f;
maxx = dstrect->w - centerx - 0.5f;
}
if (flip & SDL_FLIP_VERTICAL) {
miny = dstrect->h - centery - 0.5f;
maxy = -centery - 0.5f;
}
else {
miny = -centery - 0.5f;
maxy = dstrect->h - centery - 0.5f;
}
minu = (float) srcrect->x / texture->w;
maxu = (float) (srcrect->x + srcrect->w) / texture->w;
minv = (float) srcrect->y / texture->h;
maxv = (float) (srcrect->y + srcrect->h) / texture->h;
color = D3DCOLOR_ARGB(texture->a, texture->r, texture->g, texture->b);
vertices[0].x = minx;
vertices[0].y = miny;
vertices[0].z = 0.0f;
vertices[0].color = color;
vertices[0].u = minu;
vertices[0].v = minv;
vertices[1].x = maxx;
vertices[1].y = miny;
vertices[1].z = 0.0f;
vertices[1].color = color;
vertices[1].u = maxu;
vertices[1].v = minv;
vertices[2].x = maxx;
vertices[2].y = maxy;
vertices[2].z = 0.0f;
vertices[2].color = color;
vertices[2].u = maxu;
vertices[2].v = maxv;
vertices[3].x = minx;
vertices[3].y = maxy;
vertices[3].z = 0.0f;
vertices[3].color = color;
vertices[3].u = minu;
vertices[3].v = maxv;
D3D_SetBlendMode(data, texture->blendMode);
// Rotate and translate
ID3DXMatrixStack_Push(data->matrixStack);
ID3DXMatrixStack_LoadIdentity(data->matrixStack);
ID3DXMatrixStack_RotateYawPitchRoll(data->matrixStack, 0.0, 0.0, (float)(M_PI * (float) angle / 180.0f));
ID3DXMatrixStack_Translate(data->matrixStack, (float)dstrect->x + centerx, (float)dstrect->y + centery, (float)0.0);
IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*)ID3DXMatrixStack_GetTop(data->matrixStack));
if (texturedata->scaleMode != data->scaleMode) {
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
texturedata->scaleMode);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
texturedata->scaleMode);
data->scaleMode = texturedata->scaleMode;
}
result =
IDirect3DDevice9_SetTexture(data->device, 0, (IDirect3DBaseTexture9 *)
texturedata->texture);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, shader);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, NULL);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
ID3DXMatrixStack_Pop(data->matrixStack);
ID3DXMatrixStack_Push(data->matrixStack);
ID3DXMatrixStack_LoadIdentity(data->matrixStack);
IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX*)ID3DXMatrixStack_GetTop(data->matrixStack));
ID3DXMatrixStack_Pop(data->matrixStack);
return 0;
}
static int
D3D_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
D3D_TextureData *texturedata = (D3D_TextureData *) texture->driverdata;
LPDIRECT3DPIXELSHADER9 shader = NULL;
float minx, miny, maxx, maxy;
float minu, maxu, minv, maxv;
DWORD color;
Vertex vertices[4];
HRESULT result;
if (data->beginScene) {
IDirect3DDevice9_BeginScene(data->device);
data->beginScene = SDL_FALSE;
}
minx = (float) dstrect->x - 0.5f;
miny = (float) dstrect->y - 0.5f;
maxx = (float) dstrect->x + dstrect->w - 0.5f;
maxy = (float) dstrect->y + dstrect->h - 0.5f;
minu = (float) srcrect->x / texture->w;
maxu = (float) (srcrect->x + srcrect->w) / texture->w;
minv = (float) srcrect->y / texture->h;
maxv = (float) (srcrect->y + srcrect->h) / texture->h;
color = D3DCOLOR_ARGB(texture->a, texture->r, texture->g, texture->b);
vertices[0].x = minx;
vertices[0].y = miny;
vertices[0].z = 0.0f;
vertices[0].rhw = 1.0f;
vertices[0].color = color;
vertices[0].u = minu;
vertices[0].v = minv;
vertices[1].x = maxx;
vertices[1].y = miny;
vertices[1].z = 0.0f;
vertices[1].rhw = 1.0f;
vertices[1].color = color;
vertices[1].u = maxu;
vertices[1].v = minv;
vertices[2].x = maxx;
vertices[2].y = maxy;
vertices[2].z = 0.0f;
vertices[2].rhw = 1.0f;
vertices[2].color = color;
vertices[2].u = maxu;
vertices[2].v = maxv;
vertices[3].x = minx;
vertices[3].y = maxy;
vertices[3].z = 0.0f;
vertices[3].rhw = 1.0f;
vertices[3].color = color;
vertices[3].u = minu;
vertices[3].v = maxv;
D3D_SetBlendMode(data, texture->blendMode);
if (texture->blendMode == SDL_BLENDMODE_MASK) {
shader = data->ps_mask;
}
switch (texture->scaleMode) {
case SDL_TEXTURESCALEMODE_NONE:
case SDL_TEXTURESCALEMODE_FAST:
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
D3DTEXF_POINT);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
D3DTEXF_POINT);
break;
case SDL_TEXTURESCALEMODE_SLOW:
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
D3DTEXF_LINEAR);
break;
case SDL_TEXTURESCALEMODE_BEST:
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MINFILTER,
D3DTEXF_GAUSSIANQUAD);
IDirect3DDevice9_SetSamplerState(data->device, 0, D3DSAMP_MAGFILTER,
D3DTEXF_GAUSSIANQUAD);
break;
}
result =
IDirect3DDevice9_SetTexture(data->device, 0, (IDirect3DBaseTexture9 *)
texturedata->texture);
if (FAILED(result)) {
D3D_SetError("SetTexture()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, shader);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
result =
IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLEFAN, 2,
vertices, sizeof(*vertices));
if (FAILED(result)) {
D3D_SetError("DrawPrimitiveUP()", result);
return -1;
}
if (shader) {
result = IDirect3DDevice9_SetPixelShader(data->device, NULL);
if (FAILED(result)) {
D3D_SetError("SetShader()", result);
return -1;
}
}
return 0;
}
static int _al_draw_prim_raw(ALLEGRO_BITMAP* texture, const void* vtx, const ALLEGRO_VERTEX_DECL* decl,
const int* indices, int num_vtx, int type)
{
int stride = decl ? decl->stride : (int)sizeof(ALLEGRO_VERTEX);
int num_primitives = 0;
ALLEGRO_DISPLAY *display;
LPDIRECT3DDEVICE9 device;
LPDIRECT3DBASETEXTURE9 d3d_texture;
DWORD old_wrap_state[2];
DWORD old_ttf_state;
int min_idx = 0, max_idx = num_vtx - 1;
if(indices)
{
int ii;
for(ii = 0; ii < num_vtx; ii++)
{
int idx = indices[ii];
if(ii == 0) {
min_idx = idx;
max_idx = idx;
} else if (idx < min_idx) {
min_idx = idx;
} else if (idx > max_idx) {
max_idx = idx;
}
}
}
display = al_get_current_display();
device = al_d3d_get_device(display);
if(decl) {
if(decl->d3d_decl) {
IDirect3DDevice9_SetVertexDeclaration(device, (IDirect3DVertexDeclaration9*)decl->d3d_decl);
} else {
return _al_draw_prim_soft(texture, vtx, decl, 0, num_vtx, type);
}
} else {
IDirect3DDevice9_SetFVF(device, A5V_FVF);
}
set_blender(display);
if (texture) {
int tex_x, tex_y;
D3DSURFACE_DESC desc;
float mat[4][4] = {
{1, 0, 0, 0},
{0, 1, 0, 0},
{0, 0, 1, 0},
{0, 0, 0, 1}
};
IDirect3DTexture9_GetLevelDesc(al_d3d_get_video_texture(texture), 0, &desc);
al_get_d3d_texture_position(texture, &tex_x, &tex_y);
if(decl) {
if(decl->elements[ALLEGRO_PRIM_TEX_COORD_PIXEL].attribute) {
mat[0][0] = 1.0f / desc.Width;
mat[1][1] = 1.0f / desc.Height;
} else {
mat[0][0] = (float)al_get_bitmap_width(texture) / desc.Width;
mat[1][1] = (float)al_get_bitmap_height(texture) / desc.Height;
}
} else {
mat[0][0] = 1.0f / desc.Width;
mat[1][1] = 1.0f / desc.Height;
}
mat[2][0] = (float)tex_x / desc.Width;
mat[2][1] = (float)tex_y / desc.Height;
IDirect3DDevice9_GetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, &old_ttf_state);
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *)&mat);
d3d_texture = (LPDIRECT3DBASETEXTURE9)al_d3d_get_video_texture(texture);
IDirect3DDevice9_SetTexture(device, 0, d3d_texture);
} else {
IDirect3DDevice9_SetTexture(device, 0, NULL);
}
IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_ADDRESSU, &old_wrap_state[0]);
IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_ADDRESSV, &old_wrap_state[1]);
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
if(!indices)
{
switch (type) {
case ALLEGRO_PRIM_LINE_LIST: {
num_primitives = num_vtx / 2;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_LINELIST, num_primitives, vtx, stride);
break;
};
case ALLEGRO_PRIM_LINE_STRIP: {
num_primitives = num_vtx - 1;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_LINESTRIP, num_primitives, vtx, stride);
break;
};
case ALLEGRO_PRIM_LINE_LOOP: {
int in[2];
in[0] = 0;
in[1] = num_vtx-1;
num_primitives = num_vtx - 1;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_LINESTRIP, num_primitives, vtx, stride);
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_LINELIST, 0, num_vtx, 1, in, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_LIST: {
num_primitives = num_vtx / 3;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLELIST, num_primitives, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_STRIP: {
num_primitives = num_vtx - 2;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, num_primitives, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_FAN: {
num_primitives = num_vtx - 2;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLEFAN, num_primitives, vtx, stride);
break;
};
case ALLEGRO_PRIM_POINT_LIST: {
num_primitives = num_vtx;
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, num_primitives, vtx, stride);
break;
};
}
} else {
switch (type) {
case ALLEGRO_PRIM_LINE_LIST: {
num_primitives = num_vtx / 2;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_LINELIST, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_LINE_STRIP: {
num_primitives = num_vtx - 1;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_LINESTRIP, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_LINE_LOOP: {
int in[2];
num_primitives = num_vtx - 1;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_LINESTRIP, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
in[0] = indices[0];
in[1] = indices[num_vtx-1];
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_LINELIST, min_idx, max_idx + 1, 1, in, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_LIST: {
num_primitives = num_vtx / 3;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_STRIP: {
num_primitives = num_vtx - 2;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLESTRIP, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_TRIANGLE_FAN: {
num_primitives = num_vtx - 2;
IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLEFAN, min_idx, max_idx + 1, num_primitives, indices, D3DFMT_INDEX32, vtx, stride);
break;
};
case ALLEGRO_PRIM_POINT_LIST: {
/*
* D3D does not support point lists in indexed mode, so we draw them using the non-indexed mode. To gain at least a semblance
* of speed, we detect consecutive runs of vertices and draw them using a single DrawPrimitiveUP call
*/
int ii = 0;
int start_idx = indices[0];
int run_length = 0;
for(ii = 0; ii < num_vtx; ii++)
{
run_length++;
if(indices[ii] + 1 != indices[ii + 1] || ii == num_vtx - 1) {
IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, run_length, (const char*)vtx + start_idx * stride, stride);
if(ii != num_vtx - 1)
start_idx = indices[ii + 1];
run_length = 0;
}
}
break;
};
}
}
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, old_wrap_state[0]);
IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, old_wrap_state[1]);
if(texture) {
IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, old_ttf_state);
}
return num_primitives;
}
static void test_filter(IDirect3DDevice9 *device) {
HRESULT hr;
IDirect3DTexture9 *texture;
IDirect3D9 *d3d9;
DWORD passes = 0;
unsigned int i;
struct filter_tests {
DWORD magfilter, minfilter, mipfilter;
BOOL has_texture;
HRESULT result;
} tests[] = {
{ D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_POINT, D3DTEXF_NONE, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_NONE, D3DTEXF_POINT, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_NONE, FALSE, D3D_OK },
{ D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_POINT, FALSE, D3D_OK },
{ D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_POINT, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_NONE, TRUE, D3D_OK },
{ D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_POINT, TRUE, D3D_OK },
{ D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_LINEAR, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER },
{ D3DTEXF_LINEAR, D3DTEXF_POINT, D3DTEXF_NONE, TRUE, E_FAIL },
{ D3DTEXF_POINT, D3DTEXF_LINEAR, D3DTEXF_NONE, TRUE, E_FAIL },
{ D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_LINEAR, TRUE, E_FAIL },
};
hr = IDirect3DDevice9_GetDirect3D(device, &d3d9);
ok(hr == D3D_OK, "IDirect3DDevice9_GetDirect3D(levels = 1) returned %08x\n", hr);
hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F);
if(FAILED(hr)) {
skip("D3DFMT_A32B32G32R32F not supported\n");
goto out;
}
hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DUSAGE_QUERY_FILTER,
D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F);
if(SUCCEEDED(hr)) {
skip("D3DFMT_A32B32G32R32F supports filtering\n");
goto out;
}
hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 0, 0, D3DFMT_A32B32G32R32F,
D3DPOOL_MANAGED, &texture, 0);
ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
/* Needed for ValidateDevice */
hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
for(i = 0; i < (sizeof(tests) / sizeof(tests[0])); i++) {
if(tests[i].has_texture) {
hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
} else {
hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
}
hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, tests[i].magfilter);
ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState returned %08x\n", hr);
hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, tests[i].minfilter);
ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState returned %08x\n", hr);
hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, tests[i].mipfilter);
ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState returned %08x\n", hr);
passes = 0xdeadbeef;
hr = IDirect3DDevice9_ValidateDevice(device, &passes);
ok(hr == tests[i].result, "ValidateDevice failed: Texture %s, min %u, mag %u, mip %u. Got %08x, expected %08x\n",
tests[i].has_texture ? "TRUE" : "FALSE", tests[i].magfilter, tests[i].minfilter,
tests[i].mipfilter, hr, tests[i].result);
if(SUCCEEDED(hr)) {
ok(passes != 0, "ValidateDevice succeeded, passes is %u\n", passes);
} else {
ok(passes == 0xdeadbeef, "ValidateDevice failed, passes is %u\n", passes);
}
}
hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture returned %#x.\n", hr);
IDirect3DTexture9_Release(texture);
out:
IDirect3D9_Release(d3d9);
}
/* Helper function */
static void set_states(ID3DXSpriteImpl *object)
{
D3DXMATRIX mat;
D3DVIEWPORT9 vp;
/* Miscellaneous stuff */
IDirect3DDevice9_SetVertexShader(object->device, NULL);
IDirect3DDevice9_SetPixelShader(object->device, NULL);
IDirect3DDevice9_SetNPatchMode(object->device, 0.0f);
/* Render states */
IDirect3DDevice9_SetRenderState(object->device, D3DRS_ALPHABLENDENABLE, TRUE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_ALPHAFUNC, D3DCMP_GREATER);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_ALPHAREF, 0x00);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_ALPHATESTENABLE, object->alphacmp_caps);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_BLENDOP, D3DBLENDOP_ADD);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_CLIPPING, TRUE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_CLIPPLANEENABLE, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_BLUE |
D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_CULLMODE, D3DCULL_NONE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_ENABLEADAPTIVETESSELLATION, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_FILLMODE, D3DFILL_SOLID);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_FOGENABLE, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_LIGHTING, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_RANGEFOGENABLE, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_SEPARATEALPHABLENDENABLE, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_SPECULARENABLE, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_SRGBWRITEENABLE, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_STENCILENABLE, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_VERTEXBLEND, FALSE);
IDirect3DDevice9_SetRenderState(object->device, D3DRS_WRAP0, 0);
/* Texture stage states */
IDirect3DDevice9_SetTextureStageState(object->device, 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(object->device, 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
IDirect3DDevice9_SetTextureStageState(object->device, 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
IDirect3DDevice9_SetTextureStageState(object->device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
IDirect3DDevice9_SetTextureStageState(object->device, 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
IDirect3DDevice9_SetTextureStageState(object->device, 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
IDirect3DDevice9_SetTextureStageState(object->device, 0, D3DTSS_TEXCOORDINDEX, 0);
IDirect3DDevice9_SetTextureStageState(object->device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
IDirect3DDevice9_SetTextureStageState(object->device, 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
IDirect3DDevice9_SetTextureStageState(object->device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
/* Sampler states */
IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
if(object->texfilter_caps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
else IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_MAXMIPLEVEL, 0);
IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_MAXANISOTROPY, object->maxanisotropy);
if(object->texfilter_caps & D3DPTFILTERCAPS_MINFANISOTROPIC)
IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
else IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
if(object->texfilter_caps & D3DPTFILTERCAPS_MIPFLINEAR)
IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
else IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_MIPMAPLODBIAS, 0);
IDirect3DDevice9_SetSamplerState(object->device, 0, D3DSAMP_SRGBTEXTURE, 0);
/* Matrices */
D3DXMatrixIdentity(&mat);
IDirect3DDevice9_SetTransform(object->device, D3DTS_WORLD, &mat);
IDirect3DDevice9_SetTransform(object->device, D3DTS_VIEW, &object->view);
IDirect3DDevice9_GetViewport(object->device, &vp);
D3DXMatrixOrthoOffCenterLH(&mat, vp.X+0.5f, (float)vp.Width+vp.X+0.5f, (float)vp.Height+vp.Y+0.5f, vp.Y+0.5f, vp.MinZ, vp.MaxZ);
IDirect3DDevice9_SetTransform(object->device, D3DTS_PROJECTION, &mat);
}
int main( void )
{
LPDIRECT3DVERTEXBUFFER9 v_buffer;
sgui_window_description desc;
IDirect3DTexture9* texture;
sgui_d3d9_context* ctx;
sgui_canvas* texcanvas;
IDirect3DDevice9* dev;
sgui_widget* check2;
sgui_widget* check;
sgui_widget* butt;
sgui_window* wnd;
float a=0.0f;
VOID* pVoid;
float m[16];
sgui_init( );
/*************************** create a window **************************/
desc.parent = NULL;
desc.share = NULL;
desc.width = 640;
desc.height = 480;
desc.flags = SGUI_FIXED_SIZE|SGUI_DOUBLEBUFFERED;
desc.backend = SGUI_DIRECT3D_9;
desc.bits_per_pixel = 32;
desc.depth_bits = 16;
desc.stencil_bits = 0;
desc.samples = 0;
wnd = sgui_window_create_desc( &desc );
sgui_window_set_title( wnd, "Direct3D 9 Texture Canvas" );
sgui_window_move_center( wnd );
sgui_window_set_visible( wnd, SGUI_VISIBLE );
sgui_window_set_vsync( wnd, 1 );
/************************ createtexture canvas ************************/
texcanvas = sgui_tex_canvas_create( wnd, sgui_window_get_context( wnd ),
128, 128 );
butt = sgui_button_create( 10, 10, 60, 25, "Button", 0 );
check = sgui_checkbox_create( 10, 40, "Direct3D" );
check2 = sgui_checkbox_create( 10, 65, "Texture" );
sgui_button_set_state( check, 1 );
sgui_button_set_state( check2, 1 );
sgui_widget_add_child( &texcanvas->root, butt );
sgui_widget_add_child( &texcanvas->root, check );
sgui_widget_add_child( &texcanvas->root, check2 );
/************** connect keyboard input to texture canvas **************/
sgui_event_connect( wnd, SGUI_KEY_PRESSED_EVENT,
sgui_canvas_send_window_event, texcanvas,
SGUI_FROM_EVENT, SGUI_EVENT );
sgui_event_connect( wnd, SGUI_KEY_RELEASED_EVENT,
sgui_canvas_send_window_event, texcanvas,
SGUI_FROM_EVENT, SGUI_EVENT );
sgui_event_connect( wnd, SGUI_CHAR_EVENT,
sgui_canvas_send_window_event, texcanvas,
SGUI_FROM_EVENT, SGUI_EVENT );
/*************************** Direct3D setup ***************************/
/* get the device context, set new present parameters */
ctx = (sgui_d3d9_context*)sgui_window_get_context( wnd );
dev = ctx->device;
IDirect3DDevice9_Reset( dev, &ctx->present );
/* create a vertex buffer */
IDirect3DDevice9_CreateVertexBuffer( dev, sizeof(vertices), 0,
CUSTOMFVF, D3DPOOL_MANAGED,
&v_buffer, NULL );
/* load vertex data */
IDirect3DVertexBuffer9_Lock( v_buffer, 0, 0, (void**)&pVoid, 0 );
memcpy( pVoid, vertices, sizeof(vertices) );
IDirect3DVertexBuffer9_Unlock( v_buffer );
/* setup renderer state */
IDirect3DDevice9_SetRenderState( dev, D3DRS_CULLMODE, D3DCULL_NONE );
IDirect3DDevice9_SetRenderState( dev, D3DRS_LIGHTING, FALSE );
IDirect3DDevice9_SetRenderState( dev, D3DRS_ZENABLE, TRUE );
/* set up perspective projection matrix */
perspective( m, 45.0f, (float)desc.width/(float)desc.height,
0.1f, 100.0f );
IDirect3DDevice9_SetTransform( dev, D3DTS_PROJECTION, (D3DMATRIX*)m );
/* set up texturing, bind canvas texture to stage 0 */
texture = sgui_tex_canvas_get_texture( texcanvas );
IDirect3DDevice9_SetTexture( dev, 0, (IDirect3DBaseTexture9*)texture );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_COLOROP,
D3DTOP_BLENDTEXTUREALPHA );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_COLORARG1,
D3DTA_TEXTURE );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_COLORARG2,
D3DTA_DIFFUSE );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_ALPHAOP,
D3DTOP_DISABLE );
IDirect3DDevice9_SetSamplerState(dev,0,D3DSAMP_MINFILTER,D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(dev,0,D3DSAMP_MAGFILTER,D3DTEXF_LINEAR);
/****************************** main loop *****************************/
while( sgui_main_loop_step( ) )
{
/* redraw widgets in dirty areas */
sgui_canvas_redraw_widgets( texcanvas, 1 );
/* draw scene */
IDirect3DDevice9_Clear( dev, 0, NULL,
D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
0, 1.0f, 0 );
IDirect3DDevice9_BeginScene( dev );
transform( m, a );
IDirect3DDevice9_SetTransform( dev, D3DTS_VIEW, (D3DMATRIX*)m );
a += 0.01f;
IDirect3DDevice9_SetFVF( dev, CUSTOMFVF );
IDirect3DDevice9_SetStreamSource( dev, 0, v_buffer, 0,
sizeof(CUSTOMVERTEX) );
IDirect3DDevice9_DrawPrimitive( dev, D3DPT_TRIANGLELIST, 0, 8 );
IDirect3DDevice9_EndScene( dev );
/* swap front and back buffer */
sgui_window_swap_buffers( wnd );
}
/****************************** clean up ******************************/
sgui_canvas_destroy( texcanvas );
sgui_widget_destroy( check2 );
sgui_widget_destroy( check );
sgui_widget_destroy( butt );
IDirect3DVertexBuffer9_Release( v_buffer );
sgui_window_destroy( wnd );
sgui_deinit( );
return 0;
}
