VentureReality Engine v0.1 alpha preview.

Hi, I have uploaded a Windows 10 alpha of my VentureReality Engine for those that would like to try it:

I’m the original inventor of the wearable glasses displaying graphics superimposed in to the real world. My proof is here dating back to 2011:

I’m quite sure this proof will gain I patents and to stop others gaining my value.

I want to see an elephant walk past my real home window and trunk I a ball that squashes on to my window, smiles, muffles “mnmnmn” and jumps in to my hand. Also play “Minotaur” with others in my local field.

Hopefully selling the engine and building a games/applications/assets store will make I money for patents, hardware and satellites for world positions triangulation (Edit: Just thought can do it without the satellites by simply triangulating the people and also possible objects too, but then again need a reference so will at least need some ground units), yes I know all this seems more than I can chew and probably fail in which case ill sell the patents with or without a deal.
I have an electronics background so should help with others for the hardware, yes I will require help(hint).

Enjoy the alpha, it’s only at a fraction of the possible speed as I have not done next frame calculations etc. using multi CPUtoGPU core interaction, it’s coded to prove portals within portals could be done.
You will find some bugs but it’s enough to enjoy the graphics and it’s trippy effect.

Let me know what you think, be honest. If you have ideas that you believe I have not thought of that you would like to share then please do.
I’m in the process of rewriting the engine… still be openGL and not Vulcan as don’t believe threading would be of any gain as everything is done in a single render(Edit: may use Vulcan if necessary for as need as many GPU cores as possible, (1 triangles and more that has no cross interaction and 6 shadows and more that has no cross interaction), (3 lighting and more and more that has no cross interaction or each light and more(filters, glass etc) that has no cross interaction and many for physics, for each portal that has no cross interaction) and then combine).

What I would like is a C++ designed processors, circuits for the features of for, do, switch etc. and “code to circuits” services to produce Modular Computers. “Printable Code”.

As for the glasses, so far multi-layer LELCD transparent screens as may or not want a pixel to glow and a wire that plugs in to your phone. Custom made lenses for each wearer.

Patents need creditable value, a “minimum to maximum allowable profit percentage or value” based on total “cost verses profit” value.

Here’s a value sign, Capital V with a line going across the base.

I like my idea of going for a walk without going for a walk and opening a portal to go somewhere else.

Paul Griffiths.

I’m not receiving any input and may be you have not tried it?
The screenshots above are older, the download includes my code for Multi-Pass Parallax for those that would like it, though it contains no licence I release the parallax code as public domain.

P.S Don’t think I won’t be patenting my Portals cutting technology.

I have a problem odd people point camera’s outview in to streets, I understand security but not odd.
Taking a picture without permission is illegal.

“I have every intention of patenting my stuff but I want you to freely share your stuff with me”. Yeah, that’s gonna fly.

Let’s be honest here, I have a lot to develop, have no problems with patents, copyright or even not knowing the potential value, a person may of not been well.
Currently patents are 25 years, as were living longer think it should be 50. Guess Ill have to do a good job by spreading out patents.
Others know of spreading out patents and have an interest of developing my technology, interesting future…
Like using distance meters to know of player position, which is mine for invention of “Predict-The-Ball”.
Also invented changing the camera view of video.

Off topic but I personally don’t agree with targeted advertising, think it gives anyone and not everyone too much knowledge and the position of manipulating markets.

I have an idea so others can’t access accounts. It’s a spin wheels mechanical encryption card. You see positions on a view and spin your card to reveal the access code and a one time login. Ill call this “SpinWheels”. No perfect yet as a hacker could block you out.

I know how to stop virus by code or memory coming in 3’s. Each code checks for differences between all 3, if one changes then the other 2 know it.
Could be 2.
Best done with additional hardware.
Also useful for piracy.

I like the idea of each processor is built differently, each having different machine mode numbers.
Guess decompiling prevention comes from the operating system not giving access to the machine code numbers.

Thanks for the tags, View Tag Cloud, may want to see a stampede of a million elephants.
May get to the stage of 1 million people viewing a billion objects. Think my “Printable Code” will be useful.

Overall seems easier to be cloud based and saves on battery power but problem with whoever may have the right to patent cloud. But you say the first network gave the ability of receiving back a result.

I understand the idea of open competition outside of patents and not to prevent competition, I don’t need stress.
You could say once your first patent is over any others is to prevent competition.

It is said the value of money half’s every 10 years.
Been using my calculator.
Lets say I complete my project and make 1 trillion profit.
In 100 years that profit would only be worth 1 million which is just about pocket change.
I don’t think it’s any real loss to be honest.
Have other ideas too.

If someone wants to give me a billion, ill patent it and it be theirs.

Seems very silly computers having floating point processor units.
Int’s are easy to pass around so only need an intToFloatText font function for text display or print to paper.
While ago(about 2 years back) was inventing lookup grids or cube(just) for faster maths calculations. Just move around the grid.
For instance a 10 by 10 grid of 0 to 99 can add or take away 10 by moving up or down.
Possibly the “Integer Computer”. Or “Abacus Computer”(about 2 years back, came after), fastest being pushing atoms and reading with light or other.
Guess depends if abacus can multiply or divide and profitable :
As for patents and development or advertising, it’s mine to do and others if I want them.
As much as profitably possible will be done in hardware.
Guess some rich people may want to see my “Reality”, technology, the entire world from above??
If copyright is 75 years does that mean everything dated is publicly available? Presume so. Does that include project files?

for now here’s a function:

// n is integer, p is point position
char* itf(int n, into p)
    // divide n by 10*p and p digits from right n for point
    return ...;

May have to include my vint, verify integer. If the numbers have not changed, why do the calculation twice.
I don’t like clocks.

There is Fractional Processing too.
You could have 57&5/27 * 24&7/17=…
Share prices? Currency? Be careful. I wouldn’t go further calculations based on floats or fractions. Many times a second over a long period could wipe out a lot.
1/ 123456789 / … =… … * 123456789 *… = 1. Seems ok. Anyone make a loss?

Think there needs to be a processing maths test available to software. Need to know if maths processing blows a transistor.

Integer lookup could be 100,000 times faster. Just rough guess. 10,000 to 1,000,000.
Binary addition is a lot of playing with bits. Count to 4,294,967,296 or 1111111111111111111111111111111111111111111111111111111111111111 anyone know how many bits are switched?
Mine may do it in less than 1000. So think it will be well over a million faster. 16 million?
Adding 2 numbers may not be done that way, have to investigate.

Edit: seems got it wrong. Stick to binary for addition but multiplication may be faster by using about 10 lookup tables?

Nope lookup tables is an old way.

Sill don’t like floats though. From Wikipedia:
In most modern computer architectures, there is some division of floating-point operations from integer operations. This division varies significantly by architecture; some, like the Intel x86 have dedicated floating-point registers, while some take it as far as independent clocking schemes.

Seems a lot of hassle when the only time you need to see floats is when printing font to a screen, fonts to printer or keyboard input etc.
Prefer “(binary)(int)float” and just process the binary and only convert to char* when screen/printer.
May have problem with decimal point positions have to be covered. But then that’s just multiply and dividing by 00000’s when needed for screen/printer.

123.456 + 78.9 = 202.356

123.456 could be multiplied by 1000 = 123456

78.9 could be multiplied by 1000 = 78900

123456+78900 = 202356
/ 1000 = 202.356 same result.

but 1.23456789 + 12345678.9 requires extra '000

Fine with float processor.

No disrespect to OpenGL or DirectX but why not do without floats?
Does seem the case of extra resolution. Say into is 65535. And a float between something like 0000.1 to 6553.5. Anyway a lot of extra.

Sorry people if you read all this, though new may be happy. Seem quicker than some.

Still like my verify numbers have changes before performing calculation.

Each line of code is either a single calculation or single logic.

Retrieve verify bits from memory, if not changed go on to next calculation. If changed, retrieve calculation from memory and the 2 variables, perform calculation, store result as variable and set verify bit.

Even go as far as advanced memory where the memory goes through each verify bits looking for changes. Could be a while before finding a change.

Seems different than current processors and memory to me.
The overhead is nothing compared to a possible length of no change.

Run the memory as a separate clock and be faster. While performing a calculation the memory could be looking for next possible change, that being it unless the calculation being performed is logic and going somewhere else. May be a lot of maths calculations before coming across logic.
Would be no slower but could be many many times faster.

Work for arrays too if know specific calculation.
Guess sometimes no profit so then use non verified numbers.

I got 8 gig of memory, a lot not being used.

Could have verify function too.
May be even classes.

Think it’s patentable with new memory and clock.

This is my project and theirs existing technology companies.

I’m willing to exchange if others are too.

Seems as CPU’s are multicore my “Distributor/Skipper” device may be part of the CPU.
May be lucky and work with existing OS & Software when some operations setting a “Always execute” bit. Using ~ may be before a line of code.
Without any recompiling, will see some increase in speed as my “Distributor/Skipper” will possibly know the next execution before the CPU has finished current execution.
To be honest a new “Standard” needs to be created between the CPU, GPU, Memory and my “Distributor/Skipper” to enjoy it’s full effect.

Going along with c/c++ Computers and “Distributor & skipper”.
I need machine codes and operations for each logic & maths function.
For now I’m guessing a 1500 times faster computer.
Guess the graphics at 60 frames a second would the equivalent of 30 seconds of processing of todays computers.
This is just a guess as hard for me to say.
Need random and encrypted machine codes, memory & storage and dedicated individual custom encryptor/decryptor with a unique boot code for software security.
Don’t need the clock for the Distributor & skipper.
I like the idea of SPI Ports with Network ID’s destination. NSPI.

I’m not liking c++ for quite a lot of reasons and creating new language called GRCode+.
Having fun translating GRCode+ for objects, inheritance and interface in to GRCode.
GRCode then converted to GRN, GRCode Numbers for ==, !=, <, <=, >, >=, &&, %, +, -, /, *, &, and =.
Compiled programs consisting of function numbers, function ends, variable numbers and GRN. With an Interface file for objects(.gri). Equivalent of a header file which is extracted from your source(.grs)

It’s a lot easier and doesn’t require assembly! :biggrin-new:

Say have line:

if (position == vec3(10.0, 15.0, 0.0)) elephant.setState(Elephant:STATES:JUMPING)

if position has changed then would require 3 instructions and the 3 pairs of variables to be sent to 3 separate processor units and then the 3 results compared to be all true.

So may be 3 times faster though require more hardware, but then transistors are only so fast so may be good.
Consecutive conditions is a problem for my skipper so an amount of bits added to the processor used to compare consecutive conditions would work. A new “Consecutive unit”. Or use the above.

Let’s say there’s a run function thread, after it and all functions called, at end then all the variables that have changed in the functions, the “Changed” bits in the skipper has to be updated so no longer seen as changed. So an extra bit is required for “Require Update” and iterate, set both bits to 0.

Seems doable, I want to jump 20/22/24 years, I want my G1500, G3000 or G6000 based Computer platform.

Guess “Reality” would be GRCode+ too. Probably no difference other than additional interface.

Show my efforts tomorrow.

Here’s something what GRCode+ may look like:

vec3(float x, float y, float z)

	enum STATES

	vec3 position(25.5, 15.0, .5)

	STATES state

	void setState(STATE state)
		:state = state

	vec3 colour(1.0, 0, .5)

	void setColour(vec3 color)
		:color = color

	vec3 colour(1.0, 0, .5)

	void setColour(vec3 color)
		:color = color

ClothedElephant:Elephant, Hat, Jacket
	Hat:setColor(0.0, 1.0, 0.0)
	Jacket:setColor(0.0, 1.0, 0.0)

	setState(STATE state)
		switch (state)
				Hat:setColour(1.0, 0.0, 0.0)

				Hat:setColour(0.0, 1.0, 0.0)

				Hat:setColour(0.0, 0.0, 1.0)

				Hat:setColour(1.0, 1.0, 1.0)

				Hat:setColour(0.0, 0.0, 0.0)

	void setColour(vec3 color)

vec3 position
int a;
int b;
int c;
Elephant elephant;
ClothedElephant elephants[][];

void init()
	a = 10
	position(10.0, 15.0, 20.0)


void run()
	if (position == vec3(10.0, 15.0, 0.0)) elephant.setState(Elephant:STATES:JUMPING)

	if (a < 5) elephants[][]

Thinking about an nBit computer, choose the bit size like bit[n]. May be useful for neural or more simulation.
May need to create array memory, bit[][][][][], Something like that, may be Serial network based for simplicity([roblem though with transistor switch on rise) or variable parallel type deal and with a max nBit size.

10,050,000,000(34 bit) is about the size of the planet with mm accuracy. So 40 bit would be great resolution.

Unlimited cores too. 1 or more program/'s/object/'s/function/'s/loop/'s/operation/'s can run in a core, some sort of thread wait going on.
A nBit64 GRCode Unlimited Modular Computer with wireless network capability.
x by y by z stackable.

Platform games—…___

Never did much of digital at college… May need to create my own software for simulation.

Since the planet is going to pot, and we’re be huddled on the poles like penguins sucking on ice lolly’s from nuclear driven warehouses, need something to look at other than baked mud, at least until the ground drop and we’re down with devil.

Seems these holes in russia are old produced by falling water, then eventually very slowly covered and now dropped, may be many times. Or visited by Independence day long time ago. See the rest, some old, some new.

On topic, we may need to create very tall tubes and extract the pollution by blowing the air in to large containers containing a liquid that can absorb the pollution. May be switch off and extract the rising carbon monoxide, or take the above.

Propellers, electrical wire and polythene tubes!

Or pump air constantly in to our old oil wells at the bottom to recreate the insulation layer which was once oil? Shame air rises and air expels heat.
John Conner with The Terminator never had this problem.

Since the planet is going to pot, and we’re be huddled on the poles like penguins sucking on ice lolly’s from nuclear driven warehouses, need something to look at other than baked mud, at least until the ground drop and we’re down with devil.[/QUOTE]

Am I the only one enjoying this thread? :))

But back on topic:
Cudos on your code, don’t get what you’re trying to achieve here, but at least it runs which is something, I guess.

But one tiny issue: This is an OpenGL forum, emphasis on Open. You’re talking about software patents and whatnot while using (I hope) google translate. That’s where most people’s attention will fall of a cliff.
Don’t expect much traction for this thread. Unless you want the same kind of responses you got from the thread you linked in the original post.

Let’s get back to basics, shall we?

Are you trying to code an engine in C++ using OpenGL?
If so, are you looking for feedback, advice and constructive criticism?

[QUOTE=IonutCava;1288073]Am I the only one enjoying this thread? :))

But back on topic:
Cudos on your code, don’t get what you’re trying to achieve here, but at least it runs which is something, I guess.

But one tiny issue: This is an OpenGL forum, emphasis on Open. You’re talking about software patents and whatnot while using (I hope) google translate. That’s where most people’s attention will fall of a cliff.
Don’t expect much traction for this thread. Unless you want the same kind of responses you got from the thread you linked in the original post.

Let’s get back to basics, shall we?

Are you trying to code an engine in C++ using OpenGL?
If so, are you looking for feedback, advice and constructive criticism?[/QUOTE]

OpenGL is open and yes I’m talking of Patents for my Reality Computer and Engine.
But yes my Computer will use OpenGL.
This thread started off me showing off my portals but has advanced due to my inventions of new motherboard and processor technologies. I’m sure many will use it as I’m predicting at least a 1600 times increase in speed, to be honest looking at internal images of processors I’m imagining very far beyond it. :o If my processors are 1 thousandth of the size then multiply 1600 by that.
Yes I’m open to criticism.

I have completed my code comparators logic(<, >, <=, >= & =) for my Reality Computer, can’t show it all but I’m sure your extremely impressed compared to PC’s etc assembly based processors, there based on 40 years old plus technology, with an emphasis on backwards compatibility.

Image below is 8 bit, so 8 of it and a little extra logic required for 64 bit. Will need to create logic for maths and my Distributor and Skipper. Start off using standard memory but will be changed once I’m in the position to do so.

I have designed a lot of circuits for my Reality Processor and luckily so far each circuit executes in 1 clock cycle. If this continues then will have an impressive processor.

I have completed my design for total security from Memory, Processor, Operating System, Software, Server and Server access. Beat that!