VDP Info:
Right before you get started reading this one, make sure you have a few
cans of cokes at the ready and you have your thinking cap on. You may
also want a nap before reading this as it is a real meaty section of the
site.
Emulating the Texas Instrument TMS9918a can be quite daunting at first
compared to the Gameboy VDP as there is a lot more to it. However if you
break down each part of the VDP it isnt too bad. Lets start with the
VDP memory map:
0x0000 - 0x1FFF = Sprite / tile patters (numbers 0 to 255)
0x2000 - 0x37FF = Sprite / tile patters (numbers 256 to 447)
0x3800 - 0x3EFF = Name Table
0x3F00 - 0x3FFF = Sprite Info Table
BYTE m_VRAM[0x4000] ;
BYTE m_ColourRam[32] ;
The VDP has 11 control registers and one status register. I shall go over the control registers in more detail later. The status register is a BYTE in size but only bits 5-7 are used. Here is the layout of the status register but I shall go through their meanings later.
BIT 7 = VSync Interrupt Pending
BIT 6 = Sprite Overflow
BIT 5 = Sprite Collision
BIT 4-0 = Unused
Like all the hardware on the SMS the CPU communicates with the VDP by ports and it is the ports that the programmer uses to control the VDP.
0x7E = VCounter (read only)
0x7F = HCounter( read only)
0xBE = Data Port (read/write)
0xBF = Control Port ( read/write).
Interrupts:
The screen draws itself at a rate of 50Hz or 60hz (depending whether
it's PAL or NTSC, discussed later). This means the screen redraws itself
50 or 60 times a second. Each one of these screen redraws is known as a
frame. Each frame has an active period and an inactive period. The
active period is when the VDP is actually drawing one of the visible
lines of the screen and the inactive period is when it has drawn all the
visible lines of the screen. The inactive period is very important to
programmers because they can programme the VDP in ways they couldnt
while it was in an active period (like change the vertical scroll value,
discussed later). So whenever the VDP leaves the active period and
enters the inactive period it tries to signal an interrupt so the ROM
becomes aware of this. As you will see in the Interrupts section the VDP
interrupts can be ignored. When the vdp enters the inactive display
period it sets bit 7 of the status register to show there is a VSync
interrupt pending. However a vsync interrupt is only requested if Bit7
of the status flag is set and the bit 5 of control register 1 is set
(this is the flag set by the programmer to enable vertical sync
interrupts, discussed later). If both of these flags are set then the
VDP requests a vsync interrupt and the cpu will either respond to it or
ignore it.
There is another vdp interrupt called the line interrupt. This is a
value set by the programmer which counts down during the active display
period (and the first line of the inactive display period)each time the
vdp moves onto a new scanline. This is so the programmer can be informed
of when the vdp starts drawing a specific scanline. When the line
counter goes below zero then the vdp requests an interrupt (only if the
line interrupts are enabled by setting bit 4 of control register 0) and
the line counter is reset to the value of register 10. If the cpu
decides to ignore the vdp interrupt then the request is lost so this
interrupt is either handled straight away or not at all. The value of
the line counter is set to the value of register 10 however the line
counter is only set to the value of register 10 when the current
scanline is past the FIRST scanline of the inactive display period.
I shall show how to implement both interrupts in the "Update Cycle" section of this page.
Regions:
The two different regions are PAL and NTSC. Throughout the rest of this document I shall be working with NTSC however this section will give the details for both. As I have already explained each VDP frame consists of an active section and an inactive section. The amount of active+inactive gives us the total amount of scanlines each frame has. PAL has 313 scanlines and NTSC has 262. Because of this difference the amount of NTSC frames drawn every second is more than PAL. NTSC can draw 60 frames a second and PAL can draw 50. Because both regions have different number of scanlines the amount of scanlines in the active period and the inactive period differ for each region. Not only this but each region can change its screen resolution (meaning the amount of active screen scanlines change but not the total number of scanlines). I shall refer to the three different screen resolutions as "small", "medium" and "large". The default used by the majority of games is "small". The astute amongst you will have noticed that if reading port 0x7E returns a byte which is the vcounter yet the number of total scanlines is 262 or 313 (depending on the regions) then not all scanlines can be returned because the maximum value of an unsigned byte is 255. So if the vcounter is 260 then this cannot be represented within a bytes range. The answer is quite simple. Although the VDP will go through 262 or 313 scanlines it can only do this by going over scanlines more than once in each frame. This means the vcounter will go from 0 to 255 but some of these will be repeated giving a total of 262 or 313. To help explain this lets have a look at how the small ntsc resolution is broken down:
NTSC 256x192 (small)
0-191 = active display
192-255 = inactive display
Vcounter values = 0x0-0xDA, 0xD5-0xFF
NTSC 256x224(medium)
0-223 = active display
224-255 = inactive display
VCounter values = 0x0-0xEA, 0x0E5-0xFF
NTSC 256x240(large)
doesnt work in NTSC
PAL 256x224(small)
0 - 191 = active display
192 - 255 = inactive display
VCounter Values = 0x0-0xF2,0xBA-0xFF
PAL 256-224(medium)
0-223 = active display
224-255 = inactive display
VCounter values = 0x0-0xFF, 0x0-0x02, 0xCA-0xFF
PAL 256x240(large)
0-239 = active display
240-255 = inactive display
VCounter Values = 0x0-0xFF,0-0x0A,0xD2,0xFF
Control Registers:
There are 11 control registers and they are write only. You will see in the next section how data is written to VRAM, CRAM and the control registers. Each register is a byte in size, and they all have different purposes. The majority of the bits in the register are unused so i'll just show the bits that are used for each register and what they do.
Register 0x0:
Bit7 = If set then vertial scrolling for columns 24-31 are disabled
Bit6 = If set then horizontal scrolling for colums 0-1 are disabled
Bit5 = If set then column 0 is set to the colour of register 0x7
Bit4 = If set then line interrupt is enabled
Bit3 = If set sprites are moved left by 8 pixels
Bit2 = If set use Mode 4
Bit1 = If set use Mode 2. Must also be set for mode4 to change screen resolution
Register 0x1:
Bit6 = If set the screen is enabled
Bit5 = If set vsync interrupts are enabled
Bit4 = If set active display has 224 (medium) scanlines. Reg 0 bit1 must be set
Bit3 = If set active display has 240 (large) scanlines. Reg0 bit1 must be set
Bit1 = If set sprites are 16x16 otherwise 8x8
Bit0 = If set sprites are zoomed (double in size)
Register 0x2:
Bit3 = Bit13 of the name base table address
Bit2 = Bit12 of the name base table address
Bit1 = Bit11 of the name base table address if resolution is "small" otherwise unused
As I mentioned earlier both the name table and the sprite info table can
be moved and this is the register that sets where the name table is. To
convert from this register to the name table you need to logically and
this register with 0xE which will get the results of bits 3-1 (including
bit 0 which is "off"), you then shift this 10 times so Bit3 aligns with
Bit 13. So if bits 3-0 are 1110, then this would get shifted left 10
times to give<PHONE_NUMBER>0000 which gives the name table address of
0x3800. However it works slightly differently if you are not using the
"small" resolution (meaning register 1 has bits 3 or 4 set). You need to
logically and register 2 with 0xC and shift it left 10 places. You then
need to logically or this with 0x700 to get the name table. For example
if bits 3-0 is 1110 you and this with 0xC to give 1100, left shift 10
and logically or with 0x700 to give name table address 0x3700.
Register 0x3 and 0x4:
Unused
Register 0x5:
Bit 6 = Bit13 of sprite info base table
Bit 5 = Bit12 of sprite info base table
Bit 4 = Bit11 of sprite info base table
Bit 3 = Bit10 of sprite info base table
Bit 2 = Bit9 of sprite info base table
Bit 1 = Bit8 of sprite info base table
This register gives the base address of the sprite attribute table. As
bits 7 and 0 are ignored you need to logical and this register with
binary value 01111110 (hex 0x7E) and then shift it left 7 places so the
bits align
Reister 0x6:
Bit 2 = If set sprites use tiles in memory 0x2000 (tiles 256..511), else memory 0x0 (tiles 0 - 256)
Register 0x7:
Bits 3-0 = Defines the colour to use for the overscan order
Register 0x8:
The entire 8 bit register is the Background X Scrolling position (explained later)
Register 0x9:
The entire 8 bit register is the Background Y Scrolling position (explained later).
Register 0xA:
The entire 8 bit register is what the line counter should be set to (explained later)
All the registers can be emulated as simple as this:
BYTE m_VDPRegisters[11] ;
The ports:
Data needs to be written to the vdp in three places. VRAM, CRAM and the
VDP Registers. There are two ports used for writing data to the vdp.
Port 0xBE is where the data to be stored in VRAM, CRAM or the VDP
registers is written to. Port 0xBF controls which of these three memory
regions the data written to port 0xBE is intended for.
The way the control port (0xBF) works is by the programmer writing two
bytes of data to this port, this is called the control word. The way the
control word function is bits 15-14 contain where the data written to
port 0xBE is for, this is called the control word code. Bits 13-0 is
interpreted based on what the control word code is set to. This is what
the values of the control word code represent:
0 = Read a byte of data from the address register and store it in the
read buffer. Increment the address register. With this control word code
any writes to port 0xBE will go to VRAM at the memory pointed to by the
newly incremented address register
1 = Writing to port 0xBE will go to VRAM at the memory pointed to by the address register
2 = Writing to port 0xBE will go to VRAM at the memory pointed to by the
address register. However this control word code will also write data
to the vdp registers
3 = Writing to port 0xBE will go to CRAM
The one point I belive I still need to make clear before I show the implementation of port 0xBF writes is how the control word is updated. Because the control word is 2 byes and you can only write 1 byte at a time the control word gets updated in two stages. The first byte written updates the least significant byte of the control word (bits 7-0) and the second byte written updates the most significant byte (bits 15-8). It is only when the second byte is written that action is taken on the control word code. If the first byte is written but not the second byte the control word is a mixture of the new byte and the old byte. As you will see later it is possible to reset the control word so the next byte rewritten is the first byte even though it might have previously been waiting for the second byte to be written.
WORD m_ControlWord ;
BIT m_IsSecondControlWrite ;
BYTE m_ReadBuffer ;
void TMS9918A::WriteVDPAddress(BYTE data)
{
if (m_IsSecondControlWrite)
{
// update the top byte
m_ControlWord &= 0xFF ;
m_ControlWord |= data << 8 ;
m_IsSecondControlWrite = false ;
// act on the control code
switch (GetCodeRegister())
{
case 0: m_ReadBuffer = m_VRAM[GetAddressRegister()];
IncrementAddress(); break ;
case 2: SetRegData() ;break ;
default: break ;
}
}
else
{
// update lower byte
m_IsSecondControlWrite = true ;
m_ControlWord &= 0xFF00 ;
m_ControlWord |= data ;
}
}
void TMS9918A::IncrementAddress( )
{
// wrap address register at 0x3FFF
if (GetAddressRegister() == 0x3FFF)
m_ControlWord &= 0xC000 ; // keep coontrol word code unchanged
else
m_ControlWord++ ;
}
WORD TMS9918A::GetAddressRegister( ) const
{
return m_ControlWord & 0x3FFF ;
}
void TMS9918A::SetRegData( )
{
// the new reg data is the lower byte
BYTE data = m_ControlWord & 0xFF ;
// reg is lower 4 bits of upper byte
BYTE reg = m_ControlWord >> 8 ;
reg &= 0xF ;
if (reg > 11)
return ;
m_VDPRegisters[reg] = data ;
// is this reg write enabling vsync interrupts?
// If so do we have an irq pending?
if (reg == 1)
{
if (TestBit(m_Status,7) && IsRegBitSet(1,5))
m_RequestInterupt = true ;
}
}
BYTE TMS9918A::GetCodeRegister() const
{
WORD w = m_ControlWord >> 14 ;
return (BYTE)w ;
}
I have finished discussing emulation of port 0xBF (the control port) and need to explain how the 0xBE port (data port) is emulated. This is the port that will write values to either VRAM or CRAM depending on the control word code. It is really quite simple to emulate as we know whether to write to eithr VRAM or CRAM based on the control word code and we know where to write those values to based on the control word address. After a byte is written to memory via port 0xBE the control address register is incremented. This is really usefull for the programmer because they can write lots of data to memory without constantly updating the control word address to point to the next area of memory. When a value is written to memory will set the read buffer to the value being written. Writing to the data port will also reset the m_IsSecondControlWrite flag to false so any more writes to the control port will start updating the control word from the least significant byte.
void TMS9918A::WriteDataPort(BYTE data)
{
m_IsSecondControlWrite = false ;
BYTE code = GetCodeRegister( ) ;
switch (code)
{
case 0: m_VRAM[ GetAddressRegister() ] = data ; break ;
case 1: m_VRAM[ GetAddressRegister() ] = data ; break ;
case 2: m_VRAM[ GetAddressRegister() ] = data ; break ;
case 3: m_CRAM[ GetAddressRegister() & 31 ] = data ; break ;
}
m_ReadBuffer = data ;
IncrementAddress( ) ;
}
We now know what happens when the VDP ports are written to but what happens when they are read? Reading the data port (0xBE) return the read buffer. It then assigns a new value to the read buffer which is the incremented address of the control word address. The reason why it is incremented on read is the same as why it is incrememnted on write, this is so the programmer doesnt have to keep updating the control word to point to the next location in memory. Reading the control port (0xBF) returns the status register which I have previously discussed. Only Bits 7-5 are used in the status register and these all get reset when reading the conrol port, except when using vdp mode 2 which only resets bits 7 and 5. As well as resetting the status register when reading the control port the m_IsSecondControlWrite is also reset along with IRQs.
BYTE TMS9918A::GetStatus( )
{
BYTE res = m_Status ;
if (GetVDPMode() == 2)
{
m_Status &= 0x2F; // turn off bits 7 and 5
}
else
{
m_Status &= 0x1F; // turn off top 3 bits
}
m_IsSecondControlWrite = false ;
m_RequestInterupt = false ;
return res ;
}
BYTE TMS9918A::ReadDataPort( )
{
m_IsSecondControlWrite = false ;
BYTE res = m_ReadBuffer ;
m_ReadBuffer = m_VRAM[ GetAddressRegister() ]; break ;
IncrementAddress( ) ;
return res ;
}
Timing:
The VDP is half the speed of the machine clock. In order to move onto the next scanline we need to know how long should be spent drawing each scanline. This is where we need to emulate the horizontal counter (hcounter). The hcounter is increased at the same rate as the machine clock meaning forevery vdp clock the hcounter is incrememnted twice. The hcounter tackes 684 machine cycles before moving onto the next scanline. Because we know how long to spend on each scanline and we know how many scanlines are in the a frame it is relatively straight forward to get the vdp timing correct. All we need to do is make sure to move onto the next scanline at the correct time and we draw the correct amount of scanlines. Once the frame is drawn we then start drawing the next frame only when the required time has passed (1/50th of a second for PAL at 50hz and 1/60th of a second for NTSC at 60hz), however this is something we have already emulated in the main emulation update cycle (see "The Hardware" chapter of these tutorials). In the next section below I'll show how to emulate this along with everything else that the update of the vdp needs to do.
Update Cycle:
void TMS9918A::Update(float nextCycle)
{
m_RequestInterupt = false ;
WORD hcount = m_HCounter ;
bool nextline = false ;
m_IsVBlank = false ;
m_Refresh = false ;
m_RunningCycles += nextCycle ;
// ignore everything after the decimal point
int clockInfo = floorf(m_RunningCycles) ;
// The machine cycle is twice the speed of the vdp and this is the
// speed the hcounter increments at
int cycles = clockInfo * 2 ;
// are we moving off this scanline onto the next?
if ((hcount + cycles) > 684)
nextline = true ;
// if we are starting a new scanline reset the hcounter
m_HCounter = (m_HCounter + cycles) % 685;
// we are moving onto the next scanline
if (nextline)
{
// store current scanline
BYTE vcount = m_VCounter ;
m_VCounter++ ; // move onto next scanline
// are we coming to the end of the vertical refresh?
// if so we are starting a new frame from scanline 0
if (vcount == 255)
{
m_VCounter = 0 ;
m_VCounterFirst = true ;
Render( ) ;
m_Refresh = true ;
}
// is it time to jump the vcounter backwards?
else if ((vcount == GetVJump()) && m_VCounterFirst)
{
m_VCounterFirst = false ;
m_VCounter = GetVJumpTo() ;
}
// are we just about to enter vertical refresh?
else if (m_VCounter == m_Height)
{
m_IsVBlank = true ;
m_Status = BitSet(m_Status, 7) ; // irq pending
}
if (m_VCounter >= m_Height)
{
// do not reload the line interupt until we are past the
// FIRST line of the none active display period
if (m_VCounter != m_Height)
m_LineInterupt = m_VDPRegisters[0xA] ;
// we can now update the vertical scroll value
m_VScroll = m_VDPRegisters[0x9] ;
BYTE mode = GetVDPMode( ) ;
// are we chaning the screen resolution?
if (mode == 11)
m_Height = NUM_RES_VERT_MED ;
else if (mode == 14)
m_Height = NUM_RES_VERT_HIGH ;
else
m_Height = NUM_RES_VERTICAL ;
}
// if we are in active display then draw next scanline
if (m_VCounter < m_Height)
{
m_ScreenDisabled = !IsRegBitSet(1,6) ;
Render( ) ;
}
// decrement the line interupt counter during the active period
// including the first line of the none active display period
if (m_VCounter <= m_Height)
{
bool underflow = false ;
if (m_LineInterupt == 0)
{
underflow = true ;
}
m_LineInterupt-- ;
// it is going to underflow
if (underflow)
{
m_LineInterupt = m_VDPRegisters[0xA] ;
if (IsRegBitSet(0,4))
m_RequestInterupt = true ;
}
}
}
// do we want to signal an interrupt
if (TestBit(m_Status,7) && IsRegBitSet(1,5))
m_RequestInterupt = true ;
}
When moving onto the next scanline the first thing we need to do is increment the vcounter to show which scanline we're drawing. If the previous vcounter was 255(0xFF) then we have come to the end of the inactive display period and are ready to draw the first line of the active display period.
As discussed in the "Regions" section on this page in order to fit the 262 scanlines into a one byte variable the vcounter needs to jump backwards when it hits a specific scanline, this is what the next section section is doing. For example the standard NTSC small resolution will jump backwards after drawing scanline 0xDA back to 0xD5 and then it continues to 255. This is also what the m_VCounterFirst flag is doing so it isnt constantly jumping back to 0xD5 everytime it reaches 0xDA as we only want to do that once a frame.
Whenever we start the first line of the inactive display period (meaning we have drawn all the active scanlines which is the value of m_Height) we must set bit7 of the status register to signal we have an interrupt request pending.
When we are in the inactive display period (m_VCounter >= m_Height) we are then allowed to reset the vertical scroll value to the contents of register 9 (discussed later) aswell as changing the screen resolution to large, medium or small. I'll discuss in the next section how to determine what vdp mode we are in.
Obviously if we are still in the active display period (m_VCounter < m_Height) then we want to draw the next scanline but only if the screen is enabled.
Finally we want to decrement the line counter each time we move onto a new line in the active display period (including the first line of the inactive display period) and if it underflows we request an interrupt if line interrupts are enabled.
We are then left with checking if we need to request a vdp interrupt.
Display Modes
As previously mentioned there are 2 vdp modes the master system uses (all games use mode 4 apart from F-16 Fighter which uses mode 2). However the vdp mode represents more than whether it is in mode 4 or mode 2. It also represents what the screen resolution is. The vdp mode is comprised of the following 4 bits.
Bit 3: Mode 4 (The same as control register 0 bit 2)
Bit 2: Mode 3 (The same as control register 1 bit 3)
Bit 1: Mode 2 (The same as control register 0 bit 1)
Bit 0: Mode 1 (The same as control register 1 bit 4)
0010 = Mode 2
1000 = Mode 4
1010 = Mode 4
1011 = Mode 4 with medium display res
1100 = Mode 4
1110 = Mode 4 with large display res
1111 = Mode 4
BYTE TMS9918A::GetVDPMode( ) const
{
BYTE res = 0 ;
res |= BitGetVal(m_VDPRegisters[0x0],2) << 3;
res |= BitGetVal(m_VDPRegisters[0x1],3) << 2;
res |= BitGetVal(m_VDPRegisters[0x0],1) << 1;
res |= BitGetVal(m_VDPRegisters[0x1],4) ;
return res ;
}
Codemasters:
I've mentioned already how the screen resolution can be changed to make the amount of scanlines in the vertical active display period larger. The only games to actually use this feature are Codemasters games. You dont need to worry about detecting if it is a codemasters game or not, you just need to handle the change when the appropriate values are written to the control registers. Remember that the namebase address is interpreted differently when using a higher screen resoultion. This was discussed in the control registers section.
Rendering:
I will now go on to explain how rendering is done for mode 4 only not
mode 2, mainly because everything you need to render mode 2 I'll cover
in mode 4. To tackle mode 2 yourself you will need to read Sean Youngs
VDP documentation that I link to in the "Resources" section of these
tutorials.
You will notice in the UpdateCycle section I referred to the Render function. This is its implementation:
void TMS9918A::Render( )
{
BYTE mode = GetVDPMode();
if ( mode == 2 )
{
RenderSpritesMode2( ) ;
RenderBackgroundMode2( ) ;
}
else
{
RenderSpritesMode4( ) ;
RenderBackgroundMode4( ) ;
}
}
Sprite Rendering Mode 4:
Before I go into detail about how sprites are rendered there are still a
few loose ends I need to tie up. Firstly the VDP cannot draw more than 8
sprites on any scanline and if it tries to draw more than 8 sprites
then it sets the sprite overflow flag in the status register and stops
drawing the remaining sprites on the scanline.
There are 64 sprites available to draw which are referenced in the
sprite attribute table. The order in which sprites are drawn is the
order they appear in the sprite attributes table. Obviously a sprite is
only drawn if its current position falls withing range of the current
vcounter. However if a sprite with a Y axis position of 0xD0 is
encountered when the screen resoultion is set to "small" then this
sprite and all remainging sprites are NOT drawn.
If two sprites overlap each other then the appropriate flag in the
status register is set. Now you may be wondering why im explaining how
to emulate sprites before I've discussed how to emulate tiles. There are
two reasons for this, the first being it is easier to render sprites
because they cannot be scrolled (which is the most difficult part of
this VDPs emulation) and the second reason is I find it easier to detect
sprite collisions by rendering the sprites first. The way I go about
emulating the VDP rendering is at the start of every frame I clear the
render buffer so each pixel is set to a known colour. I then draw a line
at a time firstly drawing the sprites on that line and then the tiles.
When I colour one of the pixels in the render buffer for the current
sprite being drawn I test to see if the current colour of the pixel is
the same colour what I preset it to when drawing a new frame. If it is
the same colour then it is not a sprite collision, however if it is a
different colour then it must be a sprite collision. When I come to
drawing tiles I only ever draw the pixel if the current pixel colour is
the same as what I preset it to otherwise there is a sprite drawn there
and sprites have a higher priority by default than tiles. However it is
possible for a tile to have a higher priority than a sprite and if this
is the case then I overwrite the drawn sprite.
Now we have armed ourselves with enough information to start emulating
sprites. Firstly we need to know what sprites out of the 64 need drawing
on the current scanline (if any). So we first loop through the sprite
attribute table a sprite at a time and determine if the sprites position
lies within range of the current scanline. We also need to take into
account the size of the sprite as this will affect the range of
scanlines it will appear on. Now seems a good time to show the code for
determing where in memory the sprite attribute table resides and what
information can be obtained for each sprite.
Control register 0x5 is used to set the base of the sprite attribute
table. As previously mentioned this 8 bit register value has bits 7 and 0
ignored and it is shifted left 7 places to get the starting address of
the sprite attribute table.
WORD TMS9918A::GetSATBase( ) const
{
BYTE reg5 = m_VDPRegisters[0x5] ;
// bits 7 and 0 are ignored
reg5 &= 0x7E ;
WORD res = reg ;
return (res << 7) ;
}
Now we know the x and y position of the sprite we need to remember that the x position can be shifted left by 8 pixels if control register 0 bit 3 is set. Also the y position actually represents a position of y + 1. So if the y position is 0 then it starts on scanline 1.
The pattern index is a lookup for the pattern located in vdp memory 0x0 - 0x37FF. A pattern is the data needed to actually draw the specified sprite/tile. The 448 patterns in the pattern table are split into two tables. The first pattern table stores pattern indexes of 0-255 and the second pattern table store the indexes 256-447. The pattern index value retrieved from the SAT will either refer to the first or the second table. If it refers to the second table then the pattern index value is increased by 256, so a pattern index value of 7 will become 263 if using the second table. To determine which pattern table to use it is the value of bit 2 of control register 6. If the value is 1 then it uses the second pattern table, otherwise it is the first. You also need to reset bit 0 of the pattern index if the second pattern table is used and the sprite is 8x16 in size.
Each pattern takes 32 bytes of memory and there are a total of 448 patterns. So to find the pattern address in memory it is as simple as multiplying the pattern index by 32. These 32 bytes represent each pixel colour of the 8x8 pattern. Each 4 bytes of the total 32 bytes gives a description of the colour for a single line of the pattern. As there are 8 lines and 4 bytes for each this gives us the magic number of 32. So the first 4 bytes give the first line data, the second 4 bytes gives the second line data etc. So how do these 4 bytes give the colour of a pattern line? First you must understand that the 32 bytes of data do not encode the pixel colour but a palette. The value retrieved from the 32 bytes of data is used as a lookup in the palette to find the exact colour. The reason for this is the programmer can change the palette colours without changing the pattern data which would change the pattern to have a completely different colour. A pattern line has 8 pixels and is drawn from left to right. A byte has 8 bits so each bit can be used to represent one of the 8 pixels. So bit 7 represents the left most pixel, bit 6 represents the left most pixel +1.... bit 0 represents the right most pixel. So to get the palette lookup index of the left most pixel you combine all the bit 7 values of the 4 bytes.
BYTE palette = 0 ;
BYTE bit = BitGetVal(data4,col) ;
palette = (bit << 3) ;
bit = BitGetVal(data3,col) ;
palette |= (bit << 2) ;
bit = BitGetVal(data2,col) ;
palette |= (bit << 1) ;
bit = BitGetVal(data1, col) ;
palette |= bit ;
BYTE colour = m_CRAM[palette+16] ;
What does this colour byte represnt though? Bits 1-0 of this colour byte represent the red shade. Bits 3-2 represent the green shade. Bits 5-4 represent the blue shade. Now I never managed to find exactly how this mapped on to specific colours so I had a guess and it seems to work perfectly (if you dont believe me check out my screenshots). The way I figured it was if each of the red, green and blue shades are represented by 2 bits then this gives 4 different possible shades of the colour (values 0-3). Each shade will be between 0 and 255.  The logical values are 85 for a value of 1 and 170 for a value of 2. If you are wondering why these are logical it is because values 85 and 170 evenly space out the two midpoints of the range 0-255.
BYTE TMS9918A::GetColourShade(BYTE val) const
{
switch (val)
{
case 0: return 0 ; break ;
case 3: return 255 ; break ;
case 1: return 85 ; break ;
case 2: return 170 ; break ;
default : assert(false); return 0 ; break ;
}
}
You will notice that I use the function WriteToScreen in sprite rendering and tile rendering. This is its implementation:
void TMS9918A::WriteToScreen(BYTE x, BYTE y,BYTE red, BYTE green, BYTE blue)
{
if (m_Height == NUM_RES_VERTICAL)
{
m_ScreenStandard[y][x][0] = red ;
m_ScreenStandard[y][x][1] = green ;
m_ScreenStandard[y][x][2] = blue ;
}
else if (m_Height == NUM_RES_VERT_MED)
{
m_ScreenMed[y][x][0] = red ;
m_ScreenMed[y][x][1] = green ;
m_ScreenMed[y][x][2] = blue ;
}
else if (m_Height == NUM_RES_VERT_HIGH)
{
m_ScreenHigh[y][x][0] = red ;
m_ScreenHigh[y][x][1] = green ;
m_ScreenHigh[y][x][2] = blue ;
}
}
Background Rendering Mode 4:
The rendering of the background tiles is very similar to the sprites. It
still gets a pattern number and draws them in the same way as the
sprites did however it has the extra complication of priorities,
scrolling and masking. This is what I shall go into detail with and not
the rest of the emulation which was covered in the sprite section.
Firstly lets determine how the tiles are stored in vdp memory. Tile
information is stored in the name table of vdp memory. The size of the
name table is 2 bytes for each tile ("small" resolution has 32x28 tiles,
the others have 32x32). The following is how to interpret the 2 bytes
for each tile:
Bit 15 - 13: Unused
Bit 12: Priority flag
Bit 11: Which palette to use
Bit 10: Vertical Flip Flag
Bit 09: Horizontal Flip Flag
Bit 08 - 00 : Pattern Index
WORD TMS9918A::GetNameBase( ) const
{
BYTE reg2 = m_VDPRegisters[0x2] ;
if (m_Height == 192) // using small res
{
// bit 0 is ignored so is top nibble
reg2 &= 0xF ;
reg2 = BitReset(reg2,0) ;
return ((WORD)reg2) << 10 ;
}
// must be medium or large res
reg2 &= 0xC;
WORD res = reg2 ;
res <<= 10 ;
res |= 0x700 ;
return res ;
}
Typically a tile will always be drawn behind the sprite however if the priority bit for the tile data is set (bit 12) then it will appear in front of the sprite. The only exception to this rule is if the palette for the tile is 0 which means the tile is transparent and shouldnt be drawn.
We also need to be aware of the masking of the first column. This means that if the masking flag is set (bit 5 of register 0) then the first 8 pixels of each scanline will be set to the colour of the backdrop colour specified in register 07. The first column mask has the highest priority and will always appear in front of tiles and sprites if bit 5 of register 0 is set.
In my opinion the most compilcated part of the VDP emulation is the scrolling of the background. Your best bet at understanding this is to read Charles MacDonald's VDP document that I list in the resource section of the SMS tutorials. Charles refers to the horizontal scrolling as seperated into two sections the starting column and the fine scroll value. I interpret this as the starting column is which column to start drawing from in the name table. So it is possible that this is set to the arbitary number 4 (of 32) which means that the 4th tile will be drawn against the left edge of the screen. After drawing each column the starting column is incrememented until it gets to 32 and then it starts from 0 again. The fine scroll value is simply which pixel inside the starting column we start drawing from. For eaxample if the starting column is 4 and the fine scroll is 3 then the 3rd pixel of the 4th column will be drawn at the left hand edge of the screen. The starting column is taken from the upper 5 bits of register 0x8 and the fine scroll value is taken from the lower 3 bits. The only other part to horizontal scrolling is if bit 6 of register 0 is set then the first row of the screen remains fix and does not scroll horizontally.
Vertical scrolling works similar to horizontal scrolling with the exception that it has a starting row instead of a starting column. This works in the same way as the starting column except it specifies which row is drawn at the top of the screen. So if the starting row is set to 5 then the fifth row is drawn at the top of the screen, and after drawing the fifth row then it will increment to row 6 etc until it reaches either 28 for small resolution or 32 for medium and large which it will then start from 0 again. The fine scroll value works in the same way as horizontal scrolling in the way that it specifies which pixel of the starting row is drawn first. If bit 7 of register 0 is set then the columns 24-32 are fixed and does not scroll vertically. Although the starting row is taken from the top 5 bits of register 9 and the fine scroll is the bottom 3. Any changes to this register does not get updated until after the active display period.
We are almost done with the information gathering for tile emulation, the only parts left to mention is that a tile can be flipped vertically or horizontally (or both) based on its tile data and it can use either the background tile palettes or the sprite palettes which can also be obtained from the tile data. The following is pseudo code for gathering a tiles data:
WORD nameBaseOffset = GetNameBase() ;
nameBaseOffset += currentRow * 64 ; //each scanline has 32 tiles which is 2 bytes in memory
nameBaseOffset += currentCol * 2 ; // each tile is two bytes in memory
WORD tileData = m_VRAM[nameBaseOffset+1] << 8 ;
tileData |= m_VRAM[nameBaseOffset] ;
bool hiPriority = TestBit(tileData,12) ;
bool useSpritePalette = TestBit(tileData,11) ;
bool vertFlip = TestBit(tileData,10) ;
bool horzFlip = TestBit(tileData,9) ;
WORD tileDefinition = tileData & 0x1FF ;


The extensions tooltip supports rich content, its APIs are exactly the same as material tooltip. You should use prefix mtx instead of mat.
mtx
mat


Twitter reacts to Rohit Sharma's carnage in Rajkot
by Srijith GopalIndia's fielding the in the first innings was poor, especially Rishabh Pant who was shaky while keeping the wickets. As the captain of the Indian cricket team in the absence of Virat Kohli, Rohit was frustrated and he took it out on the Bangladesh Cricket team. This is how Twitterati reacted.
Mother of coincidence indeed!
These 2 are insane!
Are you kidding me?!
This guy is a six hitting machine!
Relispray the real winner today!
Madman Dhoni!
How the times have changed!
Learning of the day!
ROHIT SHARMA! PLEASE STOP!
Sad that he missed out on a century today!
Cakewalk!
Is this even a comeptition now?


Length
inch
cm
mm
Degree
celsius
fahrenheit
Language
English
Last Job
:
33012
Job
:
5560
Reports count
:
34
Shop
:
SAMPLE
Components
:
Stage 1 Nozzle
Frame
:
2F
WIP Report
:
84
Completed Report
:
42557
Customer
:
SAMPLE


Car upside down after country road crash
by Jake FoxfordA car was left on its roof after a collision close to Haverhill.
Police were called to the scene of a one-vehicle collision in Thurlow Road, Little Wratting, at about 4.15pm on November 21.
At the scene the officers discovered the car involved had flipped over onto its roof, smashing several windows in the process.
The driver left the scene with no reported injuries and the car was cleared from the road roughly 45 minutes later, about 5pm.
In a tweet, the Haverhill Police account said: "One vehicle road traffic collision in Little Wratting. Road is currently closed as we await recovery, in Thurlow Road.
"Driver is uninjured and family are aware."


The buttons are connected to multiple states from an animation trigger to display boxes of different sizes and opacity.


This plugin displays and hides a splash screen during application launch.
Your application cannot call navigator.splashscreen.show() until the app has started and the deviceready event has fired. But since typically the splash screen is meant to be visible before your app has started, that would seem to defeat the purpose of the splash screen.


I once again strolled over to Axel’s blog for something and it reminded my that I wanted to write something in reply to his Viral Social Commerce posts. With just having finished a bit of planning to get the current sprint done and the next one spec’d I thought it’s a good time as any. :)
First of all I really like his postings in general, and these two really rang a bell as they are so clearly linked to what we do here. Let’s take one specific part:
Even more market volume may be created by opening the advertising market to new segments that, until now, had a high cost barrier towards advertising, for example in the Long Tail of smaller and mid-sized companies, or in niche markets which had to rely on direct marketing because there was no medium for them to address at sales efficient cost on a large scale.
I agree with him that user generated content companies have a different cost structure and might hence be able to live on lower CPM advertising than a big old-school publisher. This lower CPM advertising can then also come from smaller companies, but the problem that comes in there is that smaller companies do not have the resources, or knowledge, to run web campaigns. It’s just not their business and shouldn’t be. Above that several millionen small business can’t talk to agencies to handle their advertising buying. It needs to be easy, understandable and with measurable performance. And if you do it right and target it right, it is actually far from lower end CPMs. The last bit is where he also agrees.
on-demand fully trackable horizontal niche long tail CPA advertising
[…] My point in this Blog post is that there have to be, and there will be business models beyond advertising and they are starting to emerge. Essentially these will be transaction based and will be centered either around the handling of goods in an e-commerce sense (that is already being seen in a number of start-ups) for example, by itravel, but there will also more and more be transaction platforms centered around services, much in the sourcing logic mentioned above.
Hell yes. The thing is that the trackability of online media really allows for performance based advertising. I started an internet statistics company in 1996, so I do love statistics. :) But where does this lead. Facebook will convert a lot worse on a CPM basis than some other big publisher, but I will not have to negotiate deals with Facebook other than a revenue share and targeting systems will make sure that the right ads run at the right time and in the right place. Through the CPA model I move from an advertising channel to a sales channel and the budget there is a lot different. Above that, it is understandable for smaller publishers. I get the contact data of somebody interested in my services. No need for a web site, adwords campaign pro, SEO, campaign management, Flash Ads, … . All taken care of.
There is still one problem though, millions of small advertisers. That is where another strength of the internet comes in, aggregation. There might be lots of different small advertisers but many times they can be aggregated around services and they themselves serve only their local market. This is what Ormigo does. We give small advertisers a way to attract new customers in their local market, and aggregate them to become really powerful marketing force with real budget that is relevant even for the biggest players out there. Especially for services this is possible.
In his next post he goes into a bit more detail.
So cutting back on Web 2.0 technology by seeking not a mash-up of all the functionalities that happen to be the talk of the town and instead looking for ways to create real value with Web 2.0 technologies requires, first, an analysis not of Web 2.0, of these technologies or even of the Web 2.0 early adopter crowd.
This is something I have been repeating for a long time. Most of these Web 2.0 features, be it social networking, tagging, user generated content, … are features, not a product in itself. You have to address a need, help somebody that has a problem, and sometimes, some of these new capabilities will allow you to do just that a lot more efficiently. People are wondering why we are becoming a social network, and I can only tell them that it’s a side effect. We help local merchants get new customers, and that leads to social interaction, and that leads to more customers, and more knowledge, and better matching of clients and merchants. That is also why social networking capabilities have not been our first step, and are still under developed.
 Marketing then becomes not just a communication task but becomes much more a framework for the companyâ€™s role as the
host of a community of customers.
Good words to end this. The achievement is reaching an equilibrium between users, customers and publishers. For us, a potential field to achieve this is the local market. It’s interesting for all three and Web 2.0 enables clear benefits for all. Standard ads are just a start. Much more can come from this. As others have said, Web 3.0 will be about agents, among others. Interesting times ahead.


def initialize(sConnectHost, iConnectPort, sDatabaseName, sAuthUsername, sAuthPassword)
@_sConnectHost = sConnectHost
@_iConnectPort = iConnectPort
@_sDatabaseName = sDatabaseName
@_sAuthUsername = sAuthUsername
@_sAuthPassword = sAuthPassword
@_bDebugOn = false
@_bSessionActive = false
@_bSessionStarting = false
@_sEncoding = "UTF-8"
@_sHttpRequestMethod = "GET"
@_sCursorScroll = ""
@_sCursorSensitive = ""
@_bCursorOpened = false
@_sCursorLastHandle = ""
@_sMediaType = ""
@_countCreateDom = 0
@_countFreeDom = 0
@_sContentTransferEncoding = ""
@_sIsolationLevel = ""
@_sLockMode = ""
@_sLockWait = ""
@_sHeaderHttpServerName = ""
@_sHeaderMessageText = ""
@_sHeaderReason = ""
@_sHeaderResponseWrapper = ""
@_iHeaderReturnValue = 0
@_sHeaderXmlServerVersion = "unknown"
@_domResultBody = nil
end


|
Hello {{attributes['First Name']}}, Did you know that to launch your own token you just need to choose a
token name? OST's cutting-edge platform takes care of everything else. You can experience and evaluate the
potential of OST Platform in just a few simple steps without any technical knowledge.
Step 1 - Launch Your Own Token
Step 2 - Mint Your First Batch of Tokens
Step 3 - Run Transactions in the OST Wallet App
Step 4 - Integrate OST APIs into Your App and Go-Live!
Launch Your Token
|


Do git push-ups
You console.log
If it were served warm it would be justwater.
Should've seen her face when I drove pasta...
Dad: I can try but I dont think they'll fit!
They get jalapeno face...


I am a senior undergraduate student major in computer science at Tsinghua University (B.E. expected in 2016).
My research interest is in data science, especially in developing novel data analysis programs suitable for today's Big Data era.
I am applying for a graduate position that aligns with my interests starting from fall 2016. [CV]
| Institute |
Department of Computer Science and Technology (DCST), B.Eng. (Expected) in June 2016. |
| GPA |
GPA: 91/100 (3.8/4.0) |
| Selected Honors |
National Scholarship in China, 2014 Tung OOCL Scholarship, 2015 Class monitor in 2014 |
| Selected Courses |
Computer Organization. (100%) |
|
Research Assistant |
My research experience in KEG mainly focuses on machine learning and its applications in social network analysis and text mining. Related Projects: 1. Similarity text retrieval for patent data
2. Sentiment analysis in social network (weibo.com)
3. Topic evolution detection on AMiner.org
|
|
Research Intern |
My research at Imperial College London is about approximate algorithma and high performance data analysis. Related Projects: 1. Optimization of DBSCAN clustering algorithm in large scale and high dimension
2. Hardware acceleration of Locality sensitive hashing(LSH)
|
|
Research Intern |
My research in NRL is an extension of the course Computer Organization. It includes an architectural computer system design which consists of hardware, operating system and compiler. Related Projects: Cache_CPU: MIPS32 Computer Architecture Design [Github]
|
OurSQL: Database Management System (DBMS) [Github]
Single User Relational Database
Advisor: Dr. Jianhua Feng
Collaborator: Jinming Hu
THUSearch: Search Engine in Tsinghua [Github]
Search engine based on Lucene
Advisor: Dr. Yiqun Liu
Computer Graphics and Signal Processing
Several interesting and appealing projects implemented in C++ and OpenCV


SRCCON:WORK is built around two days of talks, peer-led discussions, and hands-on workshops. The community members who step up to speak and facilitate these sessions make it all possible.
After receiving nearly 50 amazing proposals, we’ve accepted sessions for our first SRCCON:WORK. We’ll publish a final schedule in November that includes these breakout sessions as well as a series of talks to introduce each of our conference themes.
SRCCON:WORK will explore how we as a community can make journalism more inclusive, representative, and responsive. Many of the biggest problems we face aren’t technical at all, so our program will focus on three big themes:
We want SRCCON:WORK to take on teamwork, careers, and care through:
The sessions on our schedule are proposed and led by community members who want to lead conversations or develop new resources to share. Successful sessions often emerge from a single question or problem—if you’ve been struggling with just about any aspect of your work, you can bet others have dealt with it, too.
There are a lot of ways to think about sessions at SRCCON:WORK, but the main thing is to consider how it’s different than other conferences you may have attended. We’ll set the stage for each of our three themes with talks for the full audience, but the sessions at the core of our program are highly collaborative: an opportunity to compare notes, share skills, and learn from each other.
We want to make SRCCON:WORK a genuinely participatory event, and it’s hard to be part of a conversation or work with peers toward a goal in a session that’s mostly lecture. We look for pitches that include real interactivity, and we love creative formats that support learning. Outstanding sessions might include design exercises, art and games, small-group work, role playing, even field trips—and we’re always interested in new ideas.
We also encourage facilitators to think about session length and information density. We anticipate that sessions at SRCCON:WORK will last about an hour. Overprogramming a session with too many activities can make it hard to reach a satisfying goal—but a session that’s underdesigned can easily turn into a conversation between a handful of the loudest people. We’re happy to help facilitators figure out the right balance.
Effective facilitation is about effort and preparation more than expertise. Our facilitators plan and guide sessions, ask great questions, share what they know, and learn from their peers. We find that the best sessions are often led by facilitators who:
On the flip side, facilitators who have a harder time have usually tried to fit too much into too little time, or are underprepared for guiding an active conversation.
If that sounds like a lot of effort…it is! But it also means that people who are brand-new to the community—or to a topic—can make excellent facilitators if they’re willing to put in a little prep time. We provide group and one-on-one support to help facilitators prepare for their sessions, and we can help match you with a co-facilitator if you’d like to work with someone else.
We asked some facilitators from previous SRCCONs to talk about their experiences:
And here are a few more examples of sessions that have worked well in the past:


The Ice Storm is that rare thing among the films disgorged each year from the United States: it is genuinely well-made. There are many things to like about it and some things which will leave the seasoned viewer in awe. Aong them are the razor-sharp photography aware of its own symbolism; the unpretty psycho-sexual verisimilitude; the beautifully detailed interiors of houses, conveying a strong nostalgia for a time - the seventies - when people did not so much lack a sense of style as 'suffer from style to a paralysing extent' (a useful judgement on the 70s I read recently in an art magazine).
The story concerns two neighbouring professional families in the north-east of the United States, the Hoods and the Carvers. The eldest son of one family, a beautiful and dreamy, uncertain boy of perhaps fourteen, is killed at the climax of the film and his death is clearly a punishment brought upon the adulterous and self-absorbed parents of the respective houses. The fact that this terrible event is the crux of the film suggests to me that Ang Lee is less interested in post-sixties infidelity as a theme (it's been done before, as Kevin Kline would remember well) than in the idea of the difficulty of socialising children in an amoral culture. This raises questions in turn about the possibility of 'growing up' at all in such a culture: bad behaviour spans the generations easily and makes them hard to tell apart. Parents in the film are adolescents encased in the ungainly shells of their own authority. They lumber about suffused with the bitterness of having missed the main chance romantically, which is the key to their adolescent optimism regarding the possibilities of delight contained in sex.
The adults' extramarital foolings-about are not half so poignant as their inability to give direction or, it seems, comfort to their children.  This disturbance comes about by setting human behaviours that are essential and pre-cultural in the glamorous, soothing domestic interiors of American modernity and the grey-white starkness of the Connecticut landscape in late autumn. Whenever the teenagers come together in this film, it is like discovering the thing that we know must be true but will not admit is true. Ang Lee seems to be pursuing something akin to the humourist P J O'Rourke's stipulation that for true horror we need a clash of homeliness and frank atavism: 'It has to be Mom eating snakes in the rec room.' The film stirs in its audience the anxiety that the pan of experience, exotic sets and decor notwithstanding, must be shallow indeed for these confrontations, upsets and refusals to feel so familiar, for their acid to cut so deeply. And yet the chief delight of the film is its delivery to us of privileged access to the players' mostly grim sexual adventures. No-one in the ensemble, least of all any of the youths, seems to mind being exposed utterly to us.
The plot evenly divides the time we spend with the parents and the time we spend with their offspring. We are invited both to laugh drily with the adults who like one another so little and to quiver with the adolescents who never seem far from biting one another with the urgency of erotic need. But the problem, of course, is that moving from one group to another is like trekking back and forth across the wintry wood that is shown several times to separate the neighbouring houses. The idea of a gulf between the generations is best shown when Wendy Hood, flustered by the entreaties of next-door neighbour Mikey Carver, collects herself afterward in a gesture of sexual bullying: she entices Mikey's younger brother, Sandy, who adores her, into a show-and-tell of genitalia. Sandy agrees, and they crowd together into the gleaming Carver bathroom. But face to face, it is too much for Sandy who, hyperventilating with anxiety, suddenly rejects the terms of the game with a cry of confused horror.  The moment is not comical; it is ugly in the feeling it generates of innocence having been trashed for no gain. The Ice Storm is serious about sex in a way American cinema almost never is, for its moralism never attempts to fool us with the absurdity of suggesting that we could succeed in avoiding 'bad' or 'coercive' sex: the suffering and anomie is built into the driving need. Banished in disgrace by Sigourney Weaver's halter-necked temptress after her misplaced power-play, Wendy stomps home. Kevin Kline, in the character of Ben Hood, the genially interested buffoon that he remains for much of the story, meets her on the stairs and asks her what she has done today. 'Nothing', she says, as any teenager might. It, like much of the film, is a beautifully managed exercise in suspending the audience between two utterly divergent points of view, showing the cold distances that lie underneath one roof.
The director Ang Lee, if not just the author of the novel that provided the film's narrative, has a keen sense of the rupture between mind and body that occurs at puberty. You could say that this rupture is the moment of being initiated into the ordeal of the civilised West. We have no external signs for it (or only inauthentic ones), and our parents seem unable to prepare us for it, but it is a transition one must make in order to be an adult in the West. Maturity in our culture is a willingness to make instruments of our bodies, to become comfortable with a life of 'self-actualisation' and its curious internalisation of the master-slave relation (a good idea of Baudrillard's, not mine). There is a finely-photographed metaphor for the rupture in the shot of Mikey, the dreamy, non-earthed elder son of the Carvers, wobbling at the end of a diving board slicked in wet ice, testing it for bounce above an emptied swimming pool in the wind and freezing rain of the ice storm.
Earlier we have seen Mikey and Wendy kiss one another passionately in this desolate pit, as it fills with dead leaves. Mikey desires her desperately, the film makes it clear, but he seems also to be suspicious of bodies and the corruption that goes on inside them, even if it is only rot at the level of the molecule. Smelling, he reads to his class from a homework sheet, is really like tasting, in that to smell something is to 'eat' the molecule that creates the odour.  On the night of the storm, Mikey tells Sandy that he is going out into the freezing air because the cold kills off all smells, and the air, being free of these molecules, is 'clean'. We know immediately that this sweet-natured, quietly morbid youth is going to die.
Many details glint appealingly among the heavy works of the larger themes in The Ice Storm. For the long familiarity of siblings, there is Wendy's often absent elder brother, Paul, whose train ride from home to a friend's place and back frames the story, seeing at once that his younger sister has nabbed a record from his collection by a tell-tale scratch that makes the needle jump in a certain place as she plays it. For the staleness of nuptial bliss, there are the buffeting waves of a water bed which threaten to toss its occupants on the floor when one sits on it, in a revenge of creature comforts bought in gayer, sillier times. For the horror of a dead son that Mikey's mother must confront on the morning after the storm, there is no confrontation at all: Sigourney Weaver's long elegant face only emerges from sleep in close-up, to the hoarse, nightmare-indistinct sound of her husband weeping at the other end of the house.
Daring ellipsis is one of the marks of a masterly director (think of the totally elided, because completely predictable, court case of the young murderer in Kieslowski's A Short Film About Killing), and it is pleasing when it occurs not only for its economy but because of its complicty with the audience. Lee is not going to bludgeon us with the obvious; instead, recurrently in The Ice Storm, there are breath-taking turns; turn after turn. There is a turn in the playing out of Mikey's death, but the most haunting of all is at another point altogether, and its nature I will spare you. It terminates the film in such a devastating way because of its surprise - not an intrusive or jarring one, since it only magnifies the point being made, but a sheerly formal beauty of a turn, like the appearance of the pressed flower in the last seconds of Kiarostami's Where is My Friend's House - lifting and breaking the heart.
Why more fuss has not been made over The Ice Storm baffles me. I can only assume that the American public has been brutalised by Hollywood, and cannot assimilate the complexity and precision of Lee's work. A palate scorched daily by jalapeno peppers will not recognise a translucent burgundy: such tastes will need time and training to acquire. Until then know only that this film is evidence of just how fine American cinema could become - if it wanted to.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Chinese Reader
Code
Chinese Reader
Read Chinese text with confidence.
Token:
Your token is either invalid or has expired.
Original text
Readable text


Location Weather
Look up weather forecasts from around the world.
If there are multiple locations around the world with a similar name, you may need to include the state and country in your search.
Weather Dashboard
For all your weather infomation.
Location Weather
Look up weather forecasts from around the world.
If there are multiple locations around the world with a similar name, you may need to include the state and country in your search.
Date
Current Weather


Exception: NetworkrError
- Inherits:
-
RuntimeError
- Object
- RuntimeError
- NetworkrError
- Defined in:
- lib/networkr/graphs/graph.rb
Overview
Class for undirected graphs.
A Graph stores nodes and edges with optional attributes.
Graphs hold undirected edges. Self loops are allowed but parallel edges are not.
Nodes can be arbitrary hashable Ruby objects with optional attributes.
Edges are represented as links between nodes with option attributes.
Parameters
options: attributes to add to graph as key/value pairs, optional (default is {})
See Also
DiGraph
Examples
Create an empty graph with no nodes and edges.
>>> g = Graph()
g can be grown in several ways
*Nodes:*
Add one node at a time:
>>> g.add_node(1)
*Edges:*
Add one edge at a time:
>>> g.add_edge(1, 2)
If some edges connect nodes not yet in the graph, the nodes are added automatically. There are no erros when adding nodes or edges that already exist.
*Attributes:*
Each graph, node, and edge can hold key/value attribute pairs in an associated attribute hash. By default these are empty, but can be added or changed using add_node, add_node, or direct manipulation of the attribute hashes named graph, nodes, and adj.
>>> g = Graph(name: “users”) >>> g.graph { name: “users” }
Add/update node attributes using add_node or g.nodes:
>>> g.add_node(1, username: “janedoe”) >>> g.add_node(3, username: “johndoe”) >>> g.nodes { username: “janedoe” } >>> g.nodes[:score] = 10 >>> g.nodes.delete(:score) # remove attribute >>> g.nodes { 1: { username: “janedoe” }, 3: { username: “johndoe” } }
Add/update edge attributes using add_edge or g.adj:
>>> g.add_edge(1, 2, weight: 10) >>> g.adj[2] = 4 >>> g.adj[2] { weight: 4 }
*Representation:* :TODO g.to_s
1-2 { weight: 4 } 2-6 { weight: 10 } 4-6 { weight: 8 } 3-5 { weight: 5 } 5-6 { weight: 1 }


Spoilers: Paul shares his abuse trauma in Corrie after row with Sean
Paul Foreman (Peter Ash) has had an incredibly difficult couple of months in Coronation Street, as — after Billy Mayhew (Daniel Brocklebank) questioned him about his past — he came to the horrifying realisation that Kel (Joe Alessi) had sexually abused him when he was a teenager. With him having revealed the truth about what happened to him to both Gemma and Bernie Winter (Dolly-Rose Campbell and Jane Hazelgrove), he begins to open up about his abuse to others.
With the festive season approaching, Sean (Antony Cotton) is excited about the prospect of decorating the flat.
However, Billy has decided against Christmas decorations this year, as he’s come to understand that they trigger bad memories for Paul from when he was a teenager.
Sean’s none too pleased at the lack of decorations, and he makes his opinion on the matter known.
Meanwhile, Paul is incredibly nervous about speaking to the police in regards to his abuse, but — after a conversation with David (Jack P Shepherd) in which he spoke about his own ordeal with Josh (Ryan Clayton) — he’s put at ease.
Advertisement Advertisement
Later, Paul returns to work and admits to the factory workers that the police want to speak to him in regards to him being sexually abused — and the factory staff are left speechless as a result.
Later in the week, Paul reveals to both Billy and Sean that he’s decorated the tree — confirming that he’s ready to move forward in life.
One to watch: Monday 2ndDecember at 8:30pm on ITV.


## Overview
- Music theory
- Web Audio API
- Audio graph
- Audio nodes
- Audio params
## Preamble
The web is silent
We are only connecting with people through sight
Audio opens up possiblities for completely new experiences
## Web Audio API
[https://www.w3.org/TR/webaudio/](https://www.w3.org/TR/webaudio/)
The specification is fairly stable and most features are implemented in modern browsers
What is sound?
In physics, sound is a vibration that propagates as a typically audible mechanical wave of pressure and displacement, through a medium such as air or water. In physiology and psychology, sound is the reception of such waves and their perception by the brain. (Wikipedia)
Everything is a wave
Volume is proportional to amplitude squared and pitch is logarithmically proportional to frequency
## Enough theory!
### What does that sound like?
```javascript
const audioContext = new AudioContext()
const gain = audioContext.createGain()
const osc = audioContext.createOscillator()
gain.gain.value = 0.2
osc.connect(gain).connect(audioContext.destination)
osc.start()
```
## Gotcha!
```javascript
osc.stop()
osc.start() // uh oh!
```
There are quite a few gotchas with web audio...
## Timing
What time is it?
```javascript
const {currentTime} = new AudioContext()
```
Time in seconds (to be consistent with the other JS timing APIs!) since AudioContext instance was created
## Equal temperament
- Let pitch number 0 be 440Hz
- If the octave is incremented the frequency doubles
- If the octave is decremented the frequency halves
- Each octave is divided into 12 notes
```javascript
const frequency = pitch => 440 * Math.pow(2, pitch / 12)
```
## AudioParams
Some AudioNode properties are AudioParams
```javascript
gain.gain.value = 1
osc.frequency.value = 440
```
## AudioParams
AudioParams have a few of cool methods for controlling their values over time
```javascript
const osc = audioContext.createOscillator()
const {currentTime} = audioContext
osc.connect(gain)
osc.frequency.setValueAtTime(110, currentTime)
osc.frequency.linearRampToValueAtTime(1760, currentTime + 1)
osc.start(currentTime)
osc.stop(currentTime + 1)
```


This is a demo PyWPS server, point your WPS client to
{{ url }}
. It exposes a few processes:
PyWPS documentation is at pywps.rtfd.org; source code and issue tracking at github.com/jachym/pywps-4. Code for this app is at github.com/jachym/pywps-4/tree/master/demo.


| Intent | {{entry.intent | intentTerms}} |
| Capability | {{entry.capability | capabilityTerms}} |
| Threat Level | {{entry.level}} |
| Category | {{entry.category}} |
| Source | {{entry.source}} |
| Threat Drivers |
|
| Escalation Trigger Events |
|
| De-escalation Trigger Events |
|
| Future Threats |
|


This is a template for a simple marketing or informational website. It includes a large callout called a jumbotron and three supporting pieces of content. Use it as a starting point to create something more unique.
Learn more »
Maandag
Dinsdag
Woensdag
Donderdag
Vrijdag
Zaterdag
Zondag


Hoyt Hutchinson, ‘Baby Trump’ slasher, defends actions
TUSCALOOSA, Ala. — An Alabama man charged with criminal mischief in the slashing of a towering “Baby Trump” balloon has defended his actions, saying it was a matter of good versus evil.
Al.com reports Hoyt Deau Hutchinson called the syndicated radio show “Rick & Bubba Show” on Monday to describe what happened. Hutchinson said he was shaking in anger when he drove past the balloon and its handlers Saturday during President Donald Trump’s visit to see Louisiana State play against the University of Alabama.
He yelled at the protesters, but then realized they might have seen him, so he bought a University of Alabama shirt to better blend into the crowd and get close to the balloon, he said. Pretending he wanted a picture with the balloon, Hutchinson said he used a material cutter with a sharp razor to slice the symbol open.
TOP STORIES
Franklin Graham calls on nation to pray for Trump as impeachment effort gains speed
Evangelist Franklin Graham calls impeachment hearing 'a day of shame for America'
Bill Clinton offers Trump advice on impeachment
The orange, diaper-clad caricature of the president is often floated at Trump appearances to protest and mock the president, which the balloon shows clutching a cellphone. The balloon measures over 20 feet (6.1 meters) tall and was left with an 8-foot-long (2.4-meter-long) gash in its backside.
“I get so mad about people not taking a stand,” he said. “The left wants to use religion against you like you shouldn’t act like this and stuff but I’ll tell you this - the Devil knows the Bible as good as we do.”
Asked if the slashing was Hutchinson’s attempt to echo the Biblical story of Jesus turning over the temple tables of money changers, he said yes.
“It comes a point when you gotta take a stand. We don’t have two parties anymore. We have good versus evil.
He said he yelled “Trump 2020” as he was being arrested. He later posted bail and was released.
When asked about his motivations, the 32-year-old Hutchinson told the radio station he keeps up with politics by watching Fox News and his two favorite anchors, Tucker Carlson and Sean Hannity.
“I’m not young but I’m not old. I’m sort of middle aged. I feel like a lot of people my age don’t keep up with the news and politics the way they should,” he said.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


Sometimes projects need to switch implementation languages. Rather than stopping software development and rewriting the project from scratch, transformation rules can map from the original language to the new language. These rules can be developed in parallel to standard software development, allowing the project to be cut over without any loss of development time, once the rules are complete. This paper presents a migration project that used transformation rules to successfully convert 1.5 MLOC of Delphi to C# in 18 months while allowing existing Delphi development to continue.


Please verify and claim your account to take full advantage of all the site's features - we've sent you a confirmation email with the instructions. If you didn't get the message, click here and we'll send another.
In addition to gaining access to our forums and resources, you can also join our e-mentorship program.
Having a mentor provides opportunities for personal growth and development that will help you to reach your goals.
JOIN!Mentoring a university or college student with a disability provides opportunities to make a difference, and to learn more about yourself and grow.
JOIN!


Returning home to Syria
Life as a refugee was never easy for Zahida, 35, who has been raising five children on her own ever since her husband went missing a few years into the war in Syria. In Lebanon, she said, jobs were scarce and rents were high. But coming home has brought new struggles. “The destruction was indescribable, and at first I didn’t recognize my town,” she said. Her two-storey home was reduced to rubble, and though relatives took them in, the windows and doors in their borrowed rooms were missing. “There was no water, no electricity,” she added. “We felt that we were in the stone age. But little by little, we made things better.”.


Class: Aws::Synthetics::Types::CanaryCodeInput
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-synthetics/lib/aws-sdk-synthetics/types.rb |
Overview
Use this structure to input your script code for the canary. This
structure contains the ::Aws::Lambda
handler with the location where the
canary should start running the script. If the script is stored in an
::Aws::S3
bucket, the bucket name, key, and version are also included. If the
script was passed into the canary directly, the script code is
contained in the value of Zipfile
.
Constant Summary
Instance Attribute Summary
-
#handler ⇒ String
rw
The entry point to use for the source code when running the canary.
-
#s3_bucket ⇒ String
rw
If your canary script is located in
::Aws::S3
, specify the bucket name here. -
#s3_key ⇒ String
rw
The S3 key of your script.
-
#s3_version ⇒ String
rw
The S3 version ID of your script.
-
#zip_file ⇒ String
rw
If you input your canary script directly into the canary instead of referring to an
::Aws::S3
location, the value of this parameter is the base64-encoded contents of the .zip file that contains the script.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Aws::Structure#to_h. |
Instance Attribute Details
#handler ⇒ String
(rw)
The entry point to use for the source code when running the canary.
For canaries that use the syn-python-selenium-1.0
runtime or a
syn-nodejs.puppeteer
runtime earlier than
syn-nodejs.puppeteer-3.4
, the handler must be specified as
fileName.handler
. For syn-python-selenium-1.1
,
syn-nodejs.puppeteer-3.4
, and later runtimes, the handler can be
specified as fileName.functionName
, or you can specify a folder
where canary scripts reside as folder/fileName.functionName
.
#s3_bucket ⇒ String
(rw)
If your canary script is located in ::Aws::S3
, specify the bucket name
here. Do not include s3://
as the start of the bucket name.
#s3_key ⇒ String
(rw)
The S3 key of your script. For more information, see Working with Amazon S3 Objects.
#s3_version ⇒ String
(rw)
The S3 version ID of your script.
#zip_file ⇒ String
(rw)
If you input your canary script directly into the canary instead of
referring to an ::Aws::S3
location, the value of this parameter is the
base64-encoded contents of the .zip file that contains the script.
It must be smaller than 225 Kb.
For large canary scripts, we recommend that you use an ::Aws::S3
location
instead of inputting it directly with this parameter.


Query¶
-
class
omexmeta
::
Query
¶ : variable name
librdf_query_results_get_binding_value_by_name: @query_results: #librdf_query_results query results
Get one binding value for a given name in the current result.
Return value: a new #librdf_node binding value or NULL on failure
-
std::string
getBindingValueByName
(const std::string &name)¶
-
int
getBindingsCount
()¶ librdf_query_results_get_bindings_count: @query_results: #librdf_query_results query results
Get the number of bound variables in the result.
Return value: <0 if failed or results exhausted
-
void
freeQuery
()¶ free resources associated with a query object.
it is the callers responsibility to ensure resources used by Query are released after use.
-
librdf_stream *
toStream
()¶ @breif returns the results as a librdf_stream* object
developers. Consider removing.
-
ResultsMap
map
()¶ returns query results in a map where keys are the variable names used in query and values are vectors of values for results.
This is the only supported mechanism for ascertaining query results programatically, without needing to read/write to/from file. This method uses an iterator from librdf. When it gets to the end of the iterator, the iterator is “used up”. Therefore at the end of collecting the results as a map, the original query is re-run, so that the presently instantiated Query object is not rendered useless.
If the query looks like this:
The column names will be x, y and z and the results will be string representations of all subjects (?x), predicates (?y) and resources (?z) in a vector of sizestd::string query_string = "SELECT ?x ?y ?z "WHERE {" " ?x ?y ?z" "}"; Query query(query_string);
n
, where n is the number of query results.
-
std::string
toString
(const std::string &output_format, std::string baseuri = "query_results") const¶ collect the result of the query as a string
- Parameters
output_format
: one of 9 strings used to choose how you want the results to be presented. Options are xml, json, table, csv, mkr, tsv, html, turtle and rdfxml.
-
void
runQuery
()¶ Run a query.
Users do not need to manually execute a query using this method. It is used automatically in the constructor for Query and again in Query::map.
-
void
printQueryResults
()¶ Output query results to cout.
Private Functions
-
int
next
()¶
-
bool
isBindings
()¶ librdf_query_results_is_bindings: @query_results: #librdf_query_results object
Test if librdf_query_results is variable bindings format.
Return value: non-0 if true
-
bool
isBoolean
()¶ Test if librdf_query_results is boolean format.
If this function returns true, the result can be retrieved by librdf_query_results_get_boolean().
Return value: non-0 if true
-
int
getBoolean
()¶ Get boolean query result.
The return value is only meaningful if this is a boolean query result - see librdf_query_results_is_boolean()
Return value: boolean query result - >0 is true, 0 is false, <0 on error or finished
-
int
size
()¶ librdf_query_results_get_count: @query_results: #librdf_query_results query results
Get number of bindings so far.
Return value: number of bindings found so far
-
std::string
getBindingsName
(int index)¶ @query_results: #librdf_query_results query results @offset: offset of binding name into array of known names
Get binding name for the current result.
Return value: a pointer to a shared copy of the binding name or NULL on failure
-
std::string


Tsitsipas earns 1st win over Medvedev at ATP Finals
by Mattias KarenLONDON (AP) — Stefanos Tsitsipas finally found a way to win against Daniil Medvedev, beating the Russian 7-6 (5), 6-4 Monday in their opening match at the ATP Finals.
The fourth-seeded Medvedev entered the match with a 5-0 record against Tsitsipas but couldn’t earn a single break point on the indoor hard court at the O2 Arena.
Instead, the sixth-ranked Tsitsipas converted the only break of the match to take a 5-4 lead in the second set and then clinched the victory with an overhead forehand at the net.
Both players are making their debut at the year-end tournament for the world’s top eight players, which features a round-robin stage before the semifinals. Medvedev established himself as one of the best hard-court players on tour this season, reaching the U.S. Open final and winning four titles on the surface.
But Tsitispas — the first Greek player to qualify for the ATP Finals — used an aggressive forehand to keep the Russian from dictating the match, coming to the net 26 times and winning 22 of those points.
In the first-set tiebreaker, Tsitsipas hit a forehand volley winner to go ahead 6-5 and then clinched the set when Medvedev netted a forehand.
Advertising
In the late match, top-ranked Rafael Nadal was to play defending champion Alexander Zverev. Nadal, who has a 5-0 record against Zverev, is looking for his first title at the event.
In the other group, Novak Djokovic beat Matteo Berrettini on Sunday while Roger Federer lost to Dominic Thiem.


15:27:59 > Data Sent Successfully !
15:27:57 > SENT score = 97230
15:27:57 > SENT ts = 51032
15:27:57 > SENT playerId =
15:27:57 > SENT gameId =
15:27:57 > SENT pass = 2a4e5174107a8c2c88d3da2fc8e08d1cc65aeb6735758cd9bf6186fccc9d4c60
15:27:57 > SENT user = mark
15:26:03 > No touch capability.
15:25:49 > = undefined
15:25:49 > OS: Windows
15:25:49 > Browser: Chrome 11
15:25:49 > Console ready.


| GEOS SDK TechDocs
|
| printRegions ...
| pvismon ...
ptext
ptext [<options>] <addr>
Examples:
-
"ptext"
- Prints the text in the object for the method being executed in the current stack frame.
Prints out the text and related structures for a text object
The flag may be one or more of the following:
-
-
c
- Print out the char attr structures.
-
-
e
- Print out elements in addition to runs.
-
-
f
<
field
>
- Print out given field of each element (default is Meta part).
-
-
g
- Print out graphics structures.
-
-
l
- Print out line and field structures.
-
-
p
- Print out para attr structures.
-
-
r
- Print out region attr structures.
-
-
s
- Print out style structures.
-
-
t
- Print out type structures.
-
-
E
- Limit printout to just the elements of whatever arrays are requeste. Do not attempt to print out associated text.
-
-
N
- Print out associated names.
-
-
R
- Print out full region descriptions.
pthread
pthread <id>
Examples:
-
"pthread 16c0h"
-
Prints information about the thread whose handle is 16c0h.
Provides various useful pieces of information about a particular thread including its current priority and its current registers.
<id> is the thread's handle ID, as obtained with the "ps -t" or "threadstat" command.
See Also: threadstat.
ptimer
ptimer <handle>
Examples:
-
"ptimer bx"
- Print out information about the timer whose handle is in the BX register.
Prints out information about a timer registered with the system: when it will fire, what it will do when it fires, etc.
<handle> may be a variable, register, or constant.
See Also: twalk,
phandle.
ptrans
ptrans [<flags>] [<address>]
Examples:
-
"ptrans"
- print the normal transform for the object at *ds:si.
-
"ptrans -s"
- print the sprite transform for the GrObj object at *ds:si.
-
"ptrans ^lbx:cx"
-
print the normal transform for the object whose OD is ^lbx:cx.
Prints the
ObjectTransform
data structure as specified.
-
The -s flag can be used to print the "sprite" transform (the "sprite" is the shape's outline which is drawn to give feedback to the user when said user is moving/rotating/etc. the GrObj).
-
<address> defaults to *ds:si
See Also: pobject.
ptreg
ptreg <start> [<obj-addr>]
Examples:
-
"ptreg 12"
- Print lines for region 12
-
"ptreg 12 ^lcx:dx"
-
Print lines for region 12 of object ^lcx:dx
Print information about the lines in a region.
See Also: ptext.
pusage
pusage [<address>]
Examples:
-
"pusage"
- print the usage of characters in the font
List the characters in a font and when they were last used.
-
The <address> argument is the address of a font. If none is given then ^hbx is used.
See Also: fonts,
pfont,
pfontinfo,
plist.
pvardata
pvardata [<entry>]
Examples:
-
"pvardata ds:si"
-
Prints vardata of object at *ds:si
-
"pvardata -i"
-
Prints vardata of object with implied grab.
-
The address argument is the address of an object with variable data. The default is *ds:si.
pvardentry
pvardentry <address> <object>
Examples:
-
"pvardentry ds:bx *ds:si"
-
The address argument is the address of a variable data entry in an object's variable data storage area. The default is ds:bx.
-
The <object> argument is required to determine the name of the tag for the entry, as well as the type of data stored with it.
pvis
pvis <element> [<object>]
Examples:
-
"pvis VI_bounds @65"
-
print the bounds of object 65
-
"pvis VI_optFlags"
-
print the flags of the object at *DS:SI
-
"pvis VI_attrs -i"
-
print the attributes of the object at the implied grab
Print an element of the visual instance data.
-
The <element> argument specifies which element in the object to print
-
The <object> argument is the address to the object to print out. It defaults to *DS:SI and is optional. The `-i' flag for an implied grab may be used.
See Also: vistree,
vup,
pobject,
piv,
pgen.
| GEOS SDK TechDocs
|
| printRegions ...
| pvismon ...


OpenTok Demo by
<% } else { %>WebRTC Demo
<% } %> <% if (isWebRTCVersion) { %>Built by TokBox on the OpenTok Platform
This WebRTC Demo enables group video conferencing, text chat, screen sharing, and more.
<% } %>
Need help?
About TokBox
/
Contact Sales


"Organising is what you do before you do something, so that when you do it, it is not all mixed up." A.A. Milne


~[tlist_sql;
SELECT
ps_customfields.getteacherscf(t.id,'blogURL') blogURL,
t.last_name || ', ' || substr(t.first_name,1,1) tchr
FROM Teachers t
WHERE nvl(ps_customfields.getteacherscf(t.id,'blogURL'),'zzzz') != 'zzzz'
AND ((nvl(ps_customfields.getteacherscf(t.id,'blogScope'),'1') = '3')
OR (nvl(ps_customfields.getteacherscf(t.id,'blogScope'),'1') = '2' AND t.schoolid = (SELECT s.schoolid FROM
Students s WHERE s.id = ~(curstudid)))
OR (t.id IN (SELECT cc.teacherid FROM cc INNER JOIN Terms ter ON cc.termid = ter.id AND cc.schoolid =
ter.schoolid WHERE cc.studentid = ~(curstudid) AND ter.yearid = ~(curyearid) AND cc.dateleft >= sysdate)))
ORDER BY nvl(ps_customfields.getteacherscf(t.id,'blogScope'),'1'), tchr]


vertical floater?
-
stevendombard
Not sure if this is coming up or not, but I think it would be a great feature addition. Something that I can place underneath my chat program's buddy list. Anyways, synergy is great, keep up the good work.
-
stevendombard
something like this:
-
anonymous
Yeah, my thoughts exactly (though not specifically for putting under a buddy list, but to make better use of tight spaces in general) - I was going to pose the question independently but thought I'd better check the forums first. Just as well!
-
Greg Hurrell
Reply
This topic is now closed.


{% extends "ajax_form.html" %} {% set html_classes='single-form-page' %} {% from 'forms.html' import confirmation_form %} {% block content %} {% call confirmation_form(form, 'Deletion confirmation', 'Delete') %}
Are you sure you want to delete the template named “{{ tpl.name }}”?
This action cannot be undone.
{% endcall %} {% endblock %}


my last website failed so i am starting over.
This website is finaly working.
The picture above is a megaraptor claw.
Above is a megaraptor skull.
Above is a megaraptor and 2 raptors.The megaraptor is the biggest one.

If you look at the bottom jaw what do you see?
If it's fuzzy it's still cool.
That's my website.If you liked it,press heer: go


Brunelleschi: Age of Architects (Brune) is an exciting online multiplayer game currently under development and on track to launch this fall.
The online gaming market is massive, with an enthusiastic global audience which is both growing all the time and constantly hungry for new gaming experiences.
Current products in the market focus on initial launch income rather than sustainable long term play, meaning games are rushed to market as mere accessories to their advertising campaigns, and leaving customers craving innovative game play perpetually dissatisfied.
In contrast, Brune offers a rich depth and variety of experience to players.
Brune is built on a foundation of open source software. Using cutting edge components such as the Symfony2 framework, PHP5 (with plans to upgrade to PHP7 at launch), mediawiki, phpbb, and the open source community Brune has been able to create innovative game play experiences using a minimal budget and small development team.
This, combined with automatically expanding and contracting server usage through Digital Ocean or a similar service, will allow us to continue to improve, support, and maintain the product after launch with sustainably low overhead.
Brune features a variety of features to attract and facilitate such communities within the game. Communication and shared storytelling are made easy through integrated forums, mediawiki, and game messaging.
Characters within the game are able to form relationships, groups, and even coalitions between their settlements as they work together to build steadily expanding civilizations.
One of the key elements to sustainable human happiness is satisfying the desire for self improvement. Games which allow for the passive absorption of real world concepts through gameplay have long been a favorite among gamers.
Brune accommodates this healthy human desire by offering fun interactive play rich with vocabulary, mathematics, and concepts from history, civics, tactics, economics, and more.
While never asking players to stop and solve a math problem or pass a pop quiz, simply playing the game rewards players with exposure to interesting ideas and real world mechanics, granting that precious sense of satisfaction that comes from learning new things.
For Example: Harvesting grain at a Farm, owning a Bakery which produces bread from grain, and pricing Bread sales on the markets for other players to purchase to eat for food bonuses or to sustain their troops are each simple fun interactions any player can have, but they also illustrate a production chain in an interactive way which leads to passively accumulated understanding.
Brune provides players a vast array of opportunities to explore, shape, and learn from their shared virtual world.
Aesop Games is offering 1% per $5,000 invested for up to 10% total ownership. Percentage ownership would entitle holder to a percentage of net profits in proportion to their ownership.
If a holder were interested in providing feedback in their area of expertise, such input would be welcome.
*Interested in outreach? Ask about our community profit sharing goals.
The first $4,000 raised will be used to cover server, electricity, and connectivity costs for the duration of development and for the initial game launch.
Funds raised between $4,000 and $10,000 will be used to advertise the product.
Funds over $10,000 will enable us to hire a community manager to accelerate growth.


{% extends "site_base.html" %} {% block head_title %}Setting Up pip{% endblock %} {% block body %}
To use Crate.io on a per command basis you can use pip's -i option to tell it to use https://simple.crate.io/ as it's index.
For Example if you wanted to install lxml from Crate.io you would simple type pip install -i https://simple.crate.io/ lxml
Pip also allows you to setup a custom index per requirements file, doing this is just as simple as per command, but it saves you from having to type it out each time.
To enable Crate.io for a particular requirements file, just edit the file and add -i https://simple.crate.io/
as the first line of the file. Save it and then run pip install -r requirements.txt
You've tried it out per command, set up some of your requirements files to use it, now you're ready to go all out and Globally switch to Crate.io
Luckily Pip makes this easy for us again and you can set up your global index url in pip.conf.
If you are on Unix or OSX your pip.conf is located at $HOME/.pip/pip.conf
while on windows it's located at %HOME%\pip\pip.ini
Once you have your pip.conf file open and ready to edit, just add (or edit!) your file so it includes a section like
[global] index-url = https://simple.crate.io/
Typing https://simple.crate.io/
on the command line can be kind of a drag, it is a little long after all.
That's why we've created a simple shortcut for you to use, instead of using https://simple.crate.io/
you
can use https://crate.io/s/
.
An example would be:
pip install -i https://crate.io/s/ lxml
Behind the scenes this just uses a simple redirect to send you to the https://simple.crate.io/
page so
everything will work with this new shortcut! (However I don't recommend using it in a requirements file or the global option,
for those you should still use the full fledged https://simple.crate.io/
option.


{% load staticfiles %}
Overnight.asia | Upload Pictures
Hi, {{request.user.first_name}}
Logout
{% csrf_token%}
Main Hotel Image
Gallery Images
Upload


DonorsChoose.org is a program started in 2000 with the intent to help a classroom in need with resources. Public
school teachers nearly from all over America create a classroom project requests stating the resources they need for
teaching, and donors can choose any school and a project to give either part of the amount or the entire amount to
the project through DonorsChoose.org. Teachers request for books as part of reading for the students, or technology
to aid student’s learning through the portal (DonorsChoose.org), corresponding to the request a project is created
with the required budget for the request along with the teacher’s note to the school requested. As donations fill
the required budget for the project, all the resources are bought and given to the schools along with an intimation
to the donors.
Our project is aimed to work on the dataset given by DonorsChoose.org to draw analysis and give collective
information on the data over time spread through various entities involved. Our website plans to give cumulative
information about the data for teachers, users, donors and for the admin of DonorsChoose.org helping each one to
understand how are the trends and where can they add more efforts to simplify the process and maximize the donations
as early as possible. Adding this level of analysis and projections about the process can also provide a positive
influence for users willing to donate by upholding the transparency of the system enabling more donations for
projects.